`decltype` is a way to specify a type: You give it an *expression*, and `decltype` gives you back a type which corresponds to the type of the expression. Specifically, `decltype(e)` is the following type:

* If `e` is the name of a variable, i.e. an &quot;id-expression&quot;, then the resulting type is the type of the variable.

* Otherwise, if `e` evaluates to an lvalue of type `T`, then the resulting type is `T &amp;`, and if `e` evaluates to an rvalue of type `T`, then the resulting type is `T`.

Combining these rules with reference collapsing rules allows you to make sense of `decltype(e) &amp;&amp;`, which is always a &quot;suitable&quot; reference. (C++14 also adds `decltype(auto)` to give you the type-deduction of `auto` combined with the value category semantics of `decltype`.)

Examples:

    int foo();
    int n = 10;

    decltype(n) a = 20;             // a is an &quot;int&quot; [id-expression]

    decltype((n)) b = a;            // b is an &quot;int &amp;&quot; [(n) is an lvalue]

    decltype(foo()) c = foo();      // c is an &quot;int&quot; [rvalue]

    decltype(foo()) &amp;&amp; r1 = foo();  // int &amp;&amp;
    decltype((n)) &amp;&amp; r2 = n;        // int &amp; [&amp; &amp;&amp; collapses to &amp;]

It might be worth stressing the difference between `auto` and `decltype`: `auto` works on *types*, and `decltype` works on *expressions*.

You shouldn&#39;t be seeing or using `decltype` in &quot;day-to-day&quot; programming. It is most useful in generic (templated) library code, where the expression in question is not known and depends on a paramater. (By contrast, `auto` may be used generously all over the place.) In short, if you&#39;re new to programming, you probably won&#39;t need to use `decltype` for some time.

What is the correct way in the post C++11 world for setting the priority of an instance of std::thread


Is there a portable way of doing this that works at least in Windows and POSIX (Linux) environments?


Or is it a matter of getting a handle and using whatever native calls are available for the particular OS?



Portable way of setting std::thread priority in C++11

I&#39;m fairly new to R and I made a type-o while entering some code and now instead of getting the &quot;&gt;&quot; prompt I get a &quot;+&quot; prompt. I appear to be stuck in some kind of function that is looking for input, but I can&#39;t seem to get out of it. I figure that there must be a better way to fix this problem then closing R and rerunning my script but I haven&#39;t been able to find anything on google (likely because I don&#39;t know the right search terms). 
 
Thanks for your help, sorry it&#39;s a trivial question

The code I entered was as follows: 

    &gt; fit = lm(x~`y)
    + fit = lm(x~y)
    + fit
    + summary(fit)
    + 
    + 
    + end
    + ;
    + break
    + )
    + 
    + 
    + 
    +           
    +      
    + quit()
    + 
    + quit
    + break()
    + abline(b0hat,b1hat)
    + return(null)
    + 



ending &quot;+&quot; prompt in R

I haven&#39;t been able to find a good explanation of decltype. Please tell me, as a beginning programmer, what it does and why it is useful.


For example, I am reading a book that asked the following question. Can someone explain to me the answer and why, along with some good (beginner-level) examples?


&gt; What would be the type of each variable and what value would each variable have when the code finishes?


&gt;     int a = 3, b = 4;    
&gt;     decltype(a) c = a;
    
&gt;     decltype((b)) d = a; 
    
&gt;     ++c; 
    
&gt;     ++d;

A line-by-line explanation would be very helpful.

What is decltype and how is it used?

I haven't been able to find a good explanation of decltype. Please tell me, as a beginning programmer, what it does and why it is useful.
For example, I am reading a book that asked the following question. Can someone explain to me the answer and why, along with some good (beginner-level) examples?
> What would be the type of each variable and what value would each variable have when the code finishes?
> int a = 3, b = 4; 
> decltype(a) c = a;
> decltype((b)) d = a;
> ++c;
> ++d;
A line-by-line explanation would be very helpful.

What is a good approach to read the whole file content in a buffer for C++?

While in plain C I could use `fopen(), fseek(), fread()` function combination and read the whole file to a buffer, is it still a good idea to use the same for C++? If yes, then how could I use RAII approach while opening, allocating memory for buffer, reading and reading file content to buffer. 

Should I create some wrapper class for the buffer, which deallocates memory (allocated for buffer) in it&#39;s destructor, and the same wrapper for file handling?

C++ read the whole file in buffer

I&#39;m pretty new to CMake, and read a few tutorials on how to use it, and wrote some complicated 50 lines of CMake script in order to make a program for 3 different compilers. This probably concludes all my knowledge in CMake.

Now my problem is that I have some source code, whose folder I don&#39;t want to touch/mess with when I make the program. I want that all CMake and `make` output files and folders to go into `../Compile/`, so I changed a few variables in my CMake script for that, and it worked for sometime when I did something like this on my laptop:

    Compile$ cmake ../src
    Compile$ make

Where with that I had a clean output in the folder I&#39;m in right now, which is exactly what I&#39;m looking for.

Now I moved to another computer, and recompiled CMake 2.8.11.2, and I&#39;m almost back to square one! It always compiles the thing into the `src` folder where my `CMakeLists.txt` is located.

The part where I choose the directory in my CMake script is this:

    set(dir ${CMAKE_CURRENT_SOURCE_DIR}/../Compile/)
    set(EXECUTABLE_OUTPUT_PATH ${dir} CACHE PATH &quot;Build directory&quot; FORCE)
    set(LIBRARY_OUTPUT_PATH ${dir} CACHE PATH &quot;Build directory&quot; FORCE)
    set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${dir})
    set(CMAKE_BUILD_FILES_DIRECTORY ${dir})
    set(CMAKE_BUILD_DIRECTORY ${dir})
    set(CMAKE_BINARY_DIR  ${dir})
    SET(EXECUTABLE_OUTPUT_PATH ${dir})
    SET(LIBRARY_OUTPUT_PATH ${dir}lib)
    SET(CMAKE_CACHEFILE_DIR ${dir})
    

And now it always ends with:

    -- Build files have been written to: /.../src

Am I missing something?

CMake output/build directory

I have a class containing an enum class.

    class Shader {
    public:
    	enum class Type {
    		Vertex   = GL_VERTEX_SHADER,
    		Geometry = GL_GEOMETRY_SHADER,
    		Fragment = GL_FRAGMENT_SHADER
    	};
        //...

Then, when I implement the following code in another class...

    std::unordered_map&lt;Shader::Type, Shader&gt; shaders;

...I get a compile error.

    ...usr/lib/c++/v1/type_traits:770:38: 
    Implicit instantiation of undefined template &#39;std::__1::hash&lt;Shader::Type&gt;&#39;

What is causing the error here?

Can&#39;t use enum class as unordered_map key

When evaluating integers as booleans in C/C++, are negative numbers true or false?  Are they always true/false regardless of compilers?

Do negative numbers return false in C/C++?

C++11 introduced the [`std::atomic&lt;&gt;`][1] template library. The standard specifies the `store()` and `load()` operations to atomically set / get a variable shared by more than one thread.

My question is are assignment and access operations also atomic? 

Namely, is:

    std::atomic&lt;bool&gt; stop(false);
    ...
    void thread_1_run_until_stopped()
    {
        if(!stop.load())
            /* do stuff */
    }

    void thread_2_set_stop()
    {        
        stop.store(true);
    }

Equivalent to:

    void thread_1_run_until_stopped()
    {
        if(!stop)
            /* do stuff */
    }

    void thread_2_set_stop()
    {        
        stop = true;
    }


  [1]: http://en.cppreference.com/w/cpp/atomic/atomic

Must I call atomic load/store explicitly?

I use the following code to test the C++ `&lt;random&gt;` library.

Why do I get the exact same sequence for every run of the compiled executable? Is `rd()` deterministic upon compilation? How do I get different output for each run?

GCC 4.8.1 on Windows 7 64bit. Using MinGW distribution from [http://nuwen.net/mingw.html][1].

**EDIT:** I tested the same piece code with Visual Studio. There is no problem. The outputs are non deterministic. This could be a bug in mingw gcc 4.8.1 that I used.

    #include &lt;iostream&gt;
    #include &lt;random&gt;
    using namespace std;

    int main(){
     random_device rd;
     mt19937 mt(rd());
     uniform_int_distribution&lt;int&gt; dist(0,99);
     for (int i = 0; i&lt; 16; ++i){
        cout&lt;&lt;dist(mt)&lt;&lt;&quot; &quot;;
     }
     cout &lt;&lt;endl;
    }


  [1]: http://nuwen.net/mingw.html

Why do I get the same sequence for every run with std::random_device with mingw gcc4.8.1?

In Stack Overflow question *[Redefining lambdas not allowed in C++11, why?][1]*, a small program was given that does not compile:

    int main() {
        auto test = []{};
        test = []{};
    }

The question was answered and all seemed fine. Then came [Johannes Schaub][2] and made [an interesting observation][3]:

&gt; If you put a `+` before the first lambda, it magically starts to work.

So I&#39;m curious: Why does the following work?

    int main() {
        auto test = +[]{}; // Note the unary operator + before the lambda
        test = []{};
    }

It compiles fine with both [GCC][4] 4.7+ and [Clang][5] 3.2+. Is the code standard conforming?

  [1]: https://stackoverflow.com/questions/18755787
  [2]: https://stackoverflow.com/users/34509
  [3]: https://stackoverflow.com/questions/18755787/redefining-lambdas-not-allowed-in-c11-why#comment27726224_18755787
  [4]: http://en.wikipedia.org/wiki/GNU_Compiler_Collection
  [5]: http://en.wikipedia.org/wiki/Clang


A positive lambda: &#39;+[]{}&#39; - What sorcery is this?

Consider the following program:

    int main ()
    {
        const int e = 10;

        for (decltype(e) i{0}; i &lt; e; ++i) {
            // do something
        }
    }

This fails to compile with clang (as well as gcc):

    decltype.cpp:5:35: error: read-only variable is not assignable
        for (decltype(e) i{0}; i &lt; e; ++i) {
                                      ^ ~

Basically, the compiler is assuming that `i` must be const, since `e` is.

Is there a way I can use `decltype` to get the type of `e`, but removing the `const` specifier?

Using decltype to get an expression&#39;s type, without the const

I came across the following code:

    template &lt;typename T, typename T1&gt; auto compose(T a, T1 b) -&gt; decltype(a + b) {
       return a+b;
    }

There is one thing I cannot understand:
 
Where could I find out what the arrow operator (`-&gt;`) means in the function heading?

I guess purely logically, that the `-&gt;` operator determines a type, that `auto` will be deduced to, but I want to get this straight. I can&#39;t find any information.

Arrow operator (-&gt;) in function heading

In c++14 the `decltype(auto)` idiom is introduced. 

Typically its use is to **allow `auto` declarations to use the `decltype` rules on the given expression**. 

Searching for examples of &quot;good&quot; usage of the idiom I can only think of things like the following (by [Scott Meyers](http://scottmeyers.blogspot.gr/2013/07/when-decltype-meets-auto.html)), namely for **a function&#39;s return type deduction**:

    template&lt;typename ContainerType, typename IndexType&gt;                // C++14
    decltype(auto) grab(ContainerType&amp;&amp; container, IndexType&amp;&amp; index)
    {
      authenticateUser();
      return std::forward&lt;ContainerType&gt;(container)[std::forward&lt;IndexType&gt;(index)];
    }

Are there any other examples where this new language feature is useful?

What are some uses of decltype(auto)?

We know that a &quot;const variable&quot; indicates that once assigned, you cannot change the variable, like this:

    int const i = 1;
    i = 2;

The program above will fail to compile; gcc prompts with an error:

    assignment of read-only variable &#39;i&#39;

No problem, I can understand it, but the following example is beyond my understanding:

    #include&lt;iostream&gt;
    using namespace std;
    int main()
    {
        boolalpha(cout);
        int const i = 1;
        cout &lt;&lt; is_const&lt;decltype(i)&gt;::value &lt;&lt; endl;
        int const &amp;ri = i;
        cout &lt;&lt; is_const&lt;decltype(ri)&gt;::value &lt;&lt; endl;
        return 0;
    }

It outputs

    true
    false

Weird. We know that once a reference is bound to a name/variable, we cannot change this binding, we change its bound object. So I suppose the type of `ri` should be the same as `i`: when `i` is an `int const`, why is `ri` not `const`?

Why are references not &quot;const&quot; in C++?

As I understood in C++11 `decltype(expression)` is used to deduce the exact same type of the given expression. But when the expression is put into parentheses itself, then the deduces type is *lvalue reference* to the expression type. For example:

    int x;
    decltype(x) y = x;

is equivalent to `int y = x;` but,

    int x;
    decltype((x)) y = x;

is equivalent to `int&amp; y = x;`.

Respectively

     decltype(auto) f1()
     {
       int x = 0;
       return x; // decltype(x) is int, so f1 returns int
     }

but

     decltype(auto) f2()
     {
       int x = 0;
       return (x); // decltype((x)) is int&amp;, so f2 returns int&amp;
     }

What is the rationale for this behavior to be chose by the standard committee?

**Afterwords:**

Now I observed that at least in the case of **GCC 6.2** implementation when the expression in the parentheses is more complex for example `decltype((x + x))` the deduced type is `T`, but not `T&amp;`. This is even more confusing. I don&#39;t know whether this behavior is standard.

Content Type	Original Author	Original Content on Stackoverflow
Question	Olpers	View Question on Stackoverflow
Solution 1 - C++	Kerrek SB	View Answer on Stackoverflow

What is decltype and how is it used?

C++ Problem Overview

C++ Solutions

Solution 1 - C++

ending "+" prompt in R

Portable way of setting std::thread priority in C++11

Attributions