`const&amp;` means, that this overload will be used only for const, non-const and lvalue object.

    const A a = A();
    *a;

`&amp;` means, that this overload will be used only for non-const object.

    A a;
    *a;

`&amp;&amp;` means, that this overload will be used only for rvalue object.

    *A();

for more information about this feature of C++11 standard you can read this post https://stackoverflow.com/questions/8610571/what-is-rvalue-reference-for-this

It is a member function ref-qualifiers; it is one of the features added in C++11. It is possible to overload non-static member functions based on whether the implicit `this` object parameter is an lvalue or an rvalue by specifying a function ref-qualifier ([some details][1]).

To specify a ref-qualifier for a non-static member function, you can either qualify the function with `&amp;` or `&amp;&amp;`.

    #include &lt;iostream&gt;
    struct myStruct {
        void func() &amp; { std::cout &lt;&lt; &quot;lvalue\n&quot;; }
        void func() &amp;&amp;{ std::cout &lt;&lt; &quot;rvalue\n&quot;; }
    };
     
    int main(){
        myStruct s;
        s.func();            // prints &quot;lvalue&quot;
        std::move(s).func(); // prints &quot;rvalue&quot;
        myStruct().func();   // prints &quot;rvalue&quot;
    }


  [1]: http://en.cppreference.com/w/cpp/language/member_functions

Using the latest version of Android Studio.

Once you type the function name and open brackets, AS would automatically display hint with variable type and name (which is really handy). But sometimes it would just disappear.

Does anyone know the keymap (shortcut) that would trigger it to pop again? (haven&#39;t found one in AS options, may be I missed one). In particular, I&#39;d like to know the name of the corresponding shortcut so that I can find it through the Preferences screen and update the assigned keys if necessary.

Android Studio: name of keymap/shortcut that displays method parameters hint?

I&#39;m developing a java script client application, in server-side I need to handle CORS, all the services I had written in JAX-RS with JERSEY.
My code:
       
    @CrossOriginResourceSharing(allowAllOrigins = true)
    @GET
    @Path(&quot;/readOthersCalendar&quot;)
    @Produces(&quot;application/json&quot;)
    public Response readOthersCalendar(String dataJson) throws Exception {  
         //my code. Edited by gimbal2 to fix formatting
         return Response.status(status).entity(jsonResponse).header(&quot;Access-Control-Allow-Origin&quot;, &quot;*&quot;).build();
    }

As of now, i&#39;m getting error No &#39;Access-Control-Allow-Origin&#39; header is present on the requested resource. Origin &#39;http://localhost:8080&#39; is therefore not allowed access.”

Please assist me with this.

Thanks &amp; Regards
Buddha Puneeth

How to handle CORS using JAX-RS with Jersey

Recently I was reading through the [API of `boost::optional`][optional] and came across the lines:

    T const&amp; operator *() const&amp; ;
    T&amp;       operator *() &amp; ;
    T&amp;&amp;      operator *() &amp;&amp; ;

I also wrote my own program  that defines member functions as const&amp;, &amp; and &amp;&amp; (Note that I am not speaking about the return type, but the specifiers just before the semi-colons) and they seems to work fine. 

I know what it means to declare a member function const, but can anyone explain what it means to declare it  const&amp;, &amp; and &amp;&amp;.


[optional]: http://www.boost.org/doc/libs/release/libs/optional/doc/html/index.html

const&amp; , &amp; and &amp;&amp; specifiers for member functions in C++

Recently I was reading through the <a href="http://www.boost.org/doc/libs/release/libs/optional/doc/html/index.html" target="_blank" rel="noopener noreferrer">API of <code>boost::optional</code></a> and came across the lines:
<pre><code class="hljs language-arduino">T const&#x26; operator *() const&#x26; ;
T&#x26; operator *() &#x26; ;
T&#x26;&#x26; operator *() &#x26;&#x26; ;
</code></pre>
I also wrote my own program that defines member functions as const&#x26;, &#x26; and &#x26;&#x26; (Note that I am not speaking about the return type, but the specifiers just before the semi-colons) and they seems to work fine.
I know what it means to declare a member function const, but can anyone explain what it means to declare it const&#x26;, &#x26; and &#x26;&#x26;.

I am working on a project that has been built with both gcc and msvc so far. We recently started building with clang as well.

There are some parts in the code, where platform-specific things are done:

    #ifndef _WIN32
    // ignore this in msvc
    #endif

Since gcc has previously been the only non-windows build, this was equivalent to saying &quot;do this only for gcc&quot;. But now it means &quot;do this only for gcc and clang&quot;.

However there are still situations, where I would like to handle something specifically for gcc, and not for clang. Is there a simple and robust way to detect gcc, i.e.

    #ifdef ???
    // do this *only* for gcc
    #endif

Detect gcc as opposed to msvc / clang with macro

I frequently use a technique I call the &quot;lazy man&#39;s `enable_if`,&quot; where I use `decltype` and the comma operator to enable a function based on some template input. Here is a small example:

    template &lt;typename F&gt;
    auto foo(F&amp;&amp; f) -&gt; decltype(f(0), void())
    {
    	std::cout &lt;&lt; &quot;1&quot; &lt;&lt; std::endl;
    }
    
    template &lt;typename F&gt;
    auto foo(F&amp;&amp; f) -&gt; decltype(f(0, 1), void())
    {
    	std::cout &lt;&lt; &quot;2&quot; &lt;&lt; std::endl;
    }

With `--std=c++11`, g++ 4.7+ and Clang 3.5+ happily compile that bit of code (and it works as I would expect). However, when using MSVC 14 CTP5, I get this error complaining of `foo` already being defined:

&gt; Error	error C2995: &#39;unknown-type foo(F &amp;&amp;)&#39;: function template has
&gt; already been defined	c++-scratch	main.cpp	15

So my question is: Is the &quot;lazy man&#39;s `enable_if`&quot; legal C++ or is this an MSVC bug?

Is the &quot;lazy man&#39;s enable_if&quot; legal C++?

Shall this be the example:

    #include &lt;iostream&gt;
    using namespace std;

    int main()
    {
        cout &lt;&lt; &quot;Hola, moondo.\n&quot;;
    }

It throws the error:

```lang-none
gcc -c main.cpp gcc -o edit main.o  main.o: In function `main&#39;:
main.cpp:(.text+0xa): undefined reference to `std::cout&#39;
main.cpp:(.text+0xf): undefined reference to `std::basic_ostream&lt;char,std::char_traits&lt;char&gt; &gt;&amp; std::operator&lt;&lt; &lt;std::char_traits&lt;char&gt;&gt;(std::basic_ostream&lt;char, std::char_traits&lt;char&gt; &gt;&amp;, char const*)&#39;
main.o: In function `__static_initialization_and_destruction_0(int,int)&#39;:
main.cpp:(.text+0x3d): undefined reference to `std::ios_base::Init::Init()&#39;
main.cpp:(.text+0x4c): undefined reference to `std::ios_base::Init::~Init()&#39; collect2: error: ld
returned 1 exit status make: *** [qs] Error 1
```

Also, this example:

    #include &lt;iostream&gt;

    int main()
    {
        std::cout &lt;&lt; &quot;Hola, moondo.\n&quot;;
    }

throws the error:

```lang-none
gcc -c main.cpp gcc -o edit main.o  main.o: In function `main&#39;:
main.cpp:(.text+0xa): undefined reference to `std::cout&#39;
main.cpp:(.text+0xf): undefined reference to `std::basic_ostream&lt;char,std::char_traits&lt;char&gt; &gt;&amp; std::operator&lt;&lt;&lt;std::char_traits&lt;char&gt;&gt;(std::basic_ostream&lt;char,std::char_traits&lt;char&gt; &gt;&amp;, char const*)&#39;
main.o: In function `__static_initialization_and_destruction_0(int,int)&#39;: main.cpp:(.text+0x3d): undefined reference to `std::ios_base::Init::Init()&#39;
main.cpp:(.text+0x4c): undefined reference to `std::ios_base::Init::~Init()&#39; collect2: error: ld
returned 1 exit status make: *** [qs] Error 1
```

Note: I am using [Debian 7][1] (Wheezy).

  [1]: https://en.wikipedia.org/wiki/Debian_version_history#Debian_7_(Wheezy)






Error &quot;undefined reference to &#39;std::cout&#39;&quot;

Let&#39;s say I&#39;m writing a function to print the length of a string:

    template &lt;size_t N&gt;
    void foo(const char (&amp;s)[N]) {
        std::cout &lt;&lt; &quot;array, size=&quot; &lt;&lt; N-1 &lt;&lt; std::endl;
    }

    foo(&quot;hello&quot;) // prints array, size=5

Now I want to extend `foo` to support *non*-arrays:

    void foo(const char* s) {
        std::cout &lt;&lt; &quot;raw, size=&quot; &lt;&lt; strlen(s) &lt;&lt; std::endl;
    }

But it turns out that this breaks my original intended usage:

    foo(&quot;hello&quot;) // now prints raw, size=5

Why? Wouldn&#39;t that require an array-to-pointer conversion, whereas the template would be an exact match? Is there a way to ensure that my array function gets called?

Why does pointer decay take priority over a deduced template?

In the process of answering [another question](https://stackoverflow.com/q/28266382/3959454) I stumbled upon slightly different wordings for `std::vector::erase()` and `std::deque::erase()`. 

This is what C++14 says about `std::deque::erase` (`[deque.modifiers]/4-6`, emphasis mine):

&gt; *Effects:* ...

&gt; *Complexity:* The number of calls to the destructor is the same as the number of elements erased, but
The number of calls to the **assignment operator** is no more than the lesser of the number of elements
Before the erased elements and the number of elements after the erased elements.

&gt; *Throws:* Nothing unless an exception is thrown by the copy constructor, move constructor, assignment operator, or move assignment operator of `T`.


And here is what it says about `std::vector::erase` (`[vector.modifiers]/3-5`):

&gt; *Effects:* ...

&gt; *Complexity:* The destructor of `T` is called the number of times equal to the number of the elements erased, but the **move assignment operator** of `T` is called the number of times equal to the number of elements in the vector after the erased elements.

&gt; *Throws:* Nothing unless an exception is thrown by the copy constructor, move constructor, assignment operator, or move assignment operator of `T`.

As you can see, the exception specifications for both of them are the same, but for `std::vector` it&#39;s explicitly mentioned that move assignment operator is called.

There&#39;s also requirement for `T` to be `MoveAssignable` for `erase()` to work with both `std::vector` and `std::deque` (Table 100), but this doesn&#39;t imply the presence of the move assignment operator: one can define a copy assignment operator, and not define move assignment operator, and this class will be `MoveAssignable`.

Just in case, I checked with GCC and Clang, and indeed `std::vector::erase()` calls copy assignment operator if there&#39;s no move assignment operator, and `std::deque::erase()` does the same ([DEMO](http://coliru.stacked-crooked.com/a/c9377a2ee408fa16)).

So the question is: did I miss something, or this is an (editorial) issue in the standard?

**Update:**
I&#39;ve submitted an [LWG issue #2477](http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2477).

Copy/move assignment in std::vector::erase() and std::deque::erase()

In C++11, we can write this code:

    struct Cat {
       Cat(){}
    };
    
    const Cat cat;
    std::move(cat); //this is valid in C++11

when I call `std::move`, it means I want to move the object, i.e. I will change the object. To move a `const` object is unreasonable, so why does `std::move` not restrict this behaviour?  It will be a trap in the future, right?

Here trap means as Brandon mentioned in the comment:

&gt; &quot; I think he means it &quot;traps&quot; him sneaky sneaky because if he doesn&#39;t
&gt; realize, he ends up with a copy which is not what he intended.&quot;

In the book &#39;Effective Modern C++&#39; by Scott Meyers, he gives an example:

    class Annotation {
    public:
        explicit Annotation(const std::string text)
         : value(std::move(text)) //here we want to call string(string&amp;&amp;),
                                  //but because text is const, 
                                  //the return type of std::move(text) is const std::string&amp;&amp;
                                  //so we actually called string(const string&amp;)
                                  //it is a bug which is very hard to find out
    private:
        std::string value;
    };

If `std::move` was forbidden from operating on a `const` object, we could easily find out the bug, right?

Why can we use `std::move` on a `const` object?

After experiencing crashes when introducing nested calls of std::async in my real program, I was able to reproduce the problem in the following **minimum example**. It crashes often, but not always. Do you see anything what goes wrong, or is it a compiler or standard library bug? Note that the problem remains if `get()` calls to the futures are added.

    #include &lt;future&gt;
    #include &lt;vector&gt;
    
    int main (int, char *[])
    {
        std::vector&lt;std::future&lt;void&gt;&gt; v;
        v.reserve(100);
        for (int i = 0; i != 100; ++i)
        {
            v.emplace_back(std::async(std::launch::async, [] () {
                std::async(std::launch::async, [] { });
            }));
        }

        return 0;
    }


**I observe two different kinds of crashes:** (in about every fifth run)

 - Termination with *&quot;This application has requested the Runtime to terminate it in an unusual way.&quot;*
 - Termination after throwing an instance of *&#39;std::future_error&#39;, what():  Promise already satisfied*.


**Environment:**

 - Windows 7
 - gcc version 4.8.2 (i686-posix-dwarf-rev3, Built by
   MinGW-W64 project), as provided by Qt 5.3.2
 - Command line call: `g++ -std=c++11 -pthread futures.cpp`
 - Compiled and run on two independent machines

**Option `-pthread`?**
Could it be that in my environment for some reason the option `-pthread` is silently not taken into account? I observe the same behavior with and without that option.


Using C++11 futures: Nested calls of std::async crash: Compiler/Standard library bug?

Is it possible to pass a lambda function as a function pointer? If so, I must be doing something incorrectly because I am getting a compile error.

Consider the following example

    using DecisionFn = bool(*)();
    
    class Decide
    {
    public:
        Decide(DecisionFn dec) : _dec{dec} {}
    private:
        DecisionFn _dec;
    };
    
    int main()
    {
        int x = 5;
        Decide greaterThanThree{ [x](){ return x &gt; 3; } };
        return 0;
    }

When I [try to compile this](http://cpp.sh/5x5r), I get the following compilation error:

&lt;!-- language: lang-none --&gt;

    In function &#39;int main()&#39;:
    17:31: error: the value of &#39;x&#39; is not usable in a constant expression
    16:9:  note: &#39;int x&#39; is not const
    17:53: error: no matching function for call to &#39;Decide::Decide(&lt;brace-enclosed initializer list&gt;)&#39;
    17:53: note: candidates are:
    9:5:   note: Decide::Decide(DecisionFn)
    9:5:   note: no known conversion for argument 1 from &#39;main()::&lt;lambda()&gt;&#39; to &#39;DecisionFn {aka bool (*)()}&#39;
    6:7:   note: constexpr Decide::Decide(const Decide&amp;)
    6:7:   note: no known conversion for argument 1 from &#39;main()::&lt;lambda()&gt;&#39; to &#39;const Decide&amp;&#39;
    6:7:   note: constexpr Decide::Decide(Decide&amp;&amp;)
    6:7:   note: no known conversion for argument 1 from &#39;main()::&lt;lambda()&gt;&#39; to &#39;Decide&amp;&amp;&#39;

That&#39;s one heck of an error message to digest, but I think what I&#39;m getting out of it is that the lambda cannot be treated as a `constexpr` so therefore I cannot pass it as a function pointer? I&#39;ve tried making `x` constexpr as well, but that doesn&#39;t seem to help.

Passing capturing lambda as function pointer

It seems obvious that constexpr implies const and thus it is common to see:

    constexpr int foo = 42; // no const here

However if you write:

    constexpr char *const str = &quot;foo&quot;;

Then GCC will spawn &quot;warning: deprecated conversion from string constant to ‘char*’&quot; if -Wwrite-string flag is passed.

Writing:

    constexpr const char *const str = &quot;foo&quot;;

solves the issue.

So are constexpr const and constexpr really the same?

constexpr const vs constexpr variables?

I tried:

    #include &lt;vector&gt;
    
    int main () {
        std::vector&lt;int&gt; v;
        int size = v.size;
    }

but got the error:

    cannot convert &#39;std::vector&lt;int&gt;::size&#39; from type &#39;std::vector&lt;int&gt;::size_type (std::vector&lt;int&gt;::)() const noexcept&#39; {aka &#39;long unsigned int (std::vector&lt;int&gt;::)() const noexcept&#39;} to type &#39;int&#39;
     
Casting the expression to `int` like this:

    #include &lt;vector&gt;
    
    int main () {
        std::vector&lt;int&gt; v;
        int size = (int)v.size;
    }

also yields an error:

    error: invalid use of member function &#39;std::vector&lt;_Tp, _Alloc&gt;::size_type std::vector&lt;_Tp, _Alloc&gt;::size() const [with _Tp = int; _Alloc = std::allocator&lt;int&gt;; std::vector&lt;_Tp, _Alloc&gt;::size_type = long unsigned int]&#39; (did you forget the &#39;()&#39; ?)

Last I tried:

    #include &lt;vector&gt;
    
    int main () {
        std::vector&lt;int&gt; v;
        int size = v.size();
    }

which gave me:

    warning: implicit conversion loses integer precision

How can I fix this?




How can I get the size of an std::vector as an int?

I have been playing with ES6 for a while and I noticed that while variables declared with `var` are hoisted as expected...

    console.log(typeof name); // undefined
    var name = &quot;John&quot;;


...variables declared with `let` or `const` seem to have some problems with hoisting:

    console.log(typeof name); // ReferenceError
    let name = &quot;John&quot;;

and

    console.log(typeof name); // ReferenceError
    const name = &quot;John&quot;;

Does this mean that variables declared with `let` or `const` are not hoisted? What is really going on here? Is there any difference between `let` and `const` in this matter?

Are variables declared with let or const hoisted?

While reading I came across this type of declaration and the following line  -

    const volatile char *p=(const volatile char *) 0x30;

&gt;The value of p is changed by external conditions only


I don&#39;t get what are the external conditions . And also what is practical use of this type of _declaration_?

Pointer declared as constant as well as volatile

Why should I write (as my collegue says):

    import static org.apache.commons.lang.math.NumberUtils.INTEGER_ONE;
    if (myIntVariable == INTEGER_ONE) { ... }

instead of:

    if (myIntVariable == 1) { ... }

?

I know that the use of constants is recommended but I think the value of `NumberUtils.INTEGER_ONE` will never change! So I write `1`.

Content Type	Original Author	Original Content on Stackoverflow
Question	john_zac	View Question on Stackoverflow
Solution 1 - C++	ForEveR	View Answer on Stackoverflow
Solution 2 - C++	Alper	View Answer on Stackoverflow

const& , & and && specifiers for member functions in C++

C++ Problem Overview

C++ Solutions

Solution 1 - C++

Solution 2 - C++

How to handle CORS using JAX-RS with Jersey

Android Studio: name of keymap/shortcut that displays method parameters hint?

Attributions