Since it is an expression that comma is simply the comma operator (meaning the type is the type of the rhs side: `void`), not another argument.

That code is using SFINAE - it&#39;s enabled if `t.reserve(n)` exists but it wants to keep the return type as `void`.

Is it possible to embed TypeScript code in a web page? I want to embed TypeScript code inside script tags, like this (so that it is automatically compiled to Javascript):

    &lt;script type = &quot;text/typescript&quot;&gt;
        //TypeScript code goes here
    &lt;/script&gt;


Embed TypeScript code in an HTML document

Am I doing this right? I&#39;m trying to delegate a C++ class constructor as it&#39;s basically the same code repeating 3 times.. I read up on C++x11 and read that g++ 4.7.2 allows this but I&#39;m not sure if I&#39;m doing it right:

    Bitmap::Bitmap(HBITMAP Bmp)
    {
       //Construct some bitmap stuff..
    }
    
    Bitmap::Bitmap(WORD ResourceID)
    {
       HBITMAP BMP = (HBITMAP)LoadImage(GetModuleHandle(NULL), MAKEINTRESOURCE(ResourceID), IMAGE_BITMAP, 0, 0, LR_SHARED);
    
       Bitmap(BMP);   //Delegates to the above constructor? Or does this create a temporary?
    }


OR  do I need to do:

    Bitmap::Bitmap(HBITMAP Bmp)
    {
       //Construct some bitmap stuff..
    }
    
    Bitmap::Bitmap(WORD ResourceID) : Bitmap((HBITMAP)LoadImage(GetModuleHandle(NULL), MAKEINTRESOURCE(ResourceID), IMAGE_BITMAP, 0, 0, LR_SHARED))
    {
    }

Delegate Constructor C++

I found code [here][1] that looked something like this:

    auto f(T&amp; t, size_t n) -&gt; decltype(t.reserve(n), void()) { .. }

In all the documentation I read I was told that `decltype` is signed as:

&gt; `decltype( entity )`

or

&gt; `decltype( expression )`

And there is no second argument anywhere. At least that&#39;s what&#39;s pointed to on [cppreference][2]. Is this a second argument to `decltype`? And if so, what does it do?


  [1]: https://stackoverflow.com/a/9531274/1594090
  [2]: http://en.cppreference.com/w/cpp/language/decltype

What does the &#39;void()&#39; in &#39;auto f(params) -&gt; decltype(..., void())&#39; do?

I found code <a href="https://stackoverflow.com/a/9531274/1594090" target="_blank" rel="noopener noreferrer">here</a> that looked something like this:
<pre><code class="hljs language-scss">auto f(T&#x26; t, size_t n) -> decltype(t.reserve(n), void()) { .. }
</code></pre>
In all the documentation I read I was told that <code>decltype</code> is signed as:
> <code>decltype( entity )</code>
or
> <code>decltype( expression )</code>
And there is no second argument anywhere. At least that's what's pointed to on <a href="http://en.cppreference.com/w/cpp/language/decltype" target="_blank" rel="noopener noreferrer">cppreference</a>. Is this a second argument to <code>decltype</code>? And if so, what does it do?

I am a beginner to Qt programming and use codeblocks for my programming. I created 3 files communicate.h,commmunicate.cpp and main.cpp as follows:

**communicate.h**

        #ifndef COMMUNICATE_H
        #define COMMUNICATE_H
        
        #include &lt;QWidget&gt;
        #include &lt;QApplication&gt;
        #include &lt;QPushButton&gt;
        #include &lt;QLabel&gt;
        
        class Communicate : public QWidget
        {
          Q_OBJECT
        
          public:
            Communicate(QWidget *parent = 0);
        
        
          private slots:
            void OnPlus();
            void OnMinus();
        
          private:
            QLabel *label;
        
        };
        
        #endif
    

**communicate.cpp**

    #include &quot;communicate.h&quot;
    
    Communicate::Communicate(QWidget *parent)
        : QWidget(parent)
    {
      QPushButton *plus = new QPushButton(&quot;+&quot;, this);
      plus-&gt;setGeometry(50, 40, 75, 30);
    
      QPushButton *minus = new QPushButton(&quot;-&quot;, this);
      minus-&gt;setGeometry(50, 100, 75, 30);
    
      label = new QLabel(&quot;0&quot;, this);
      label-&gt;setGeometry(190, 80, 20, 30);
    
      connect(plus, SIGNAL(clicked()), this, SLOT(OnPlus()));
      connect(minus, SIGNAL(clicked()), this, SLOT(OnMinus()));
    }
    
    void Communicate::OnPlus()
    {
      int val = label-&gt;text().toInt();
      val++;
      label-&gt;setText(QString::number(val));
    }
    
    void Communicate::OnMinus()
    {
      int val = label-&gt;text().toInt();
      val--;
      label-&gt;setText(QString::number(val));
    }
    
    
**main.cpp**

    #include &quot;communicate.h&quot;
    
    int main(int argc, char *argv[])
    {
      QApplication app(argc, argv);
    
      Communicate window;
    
      window.setWindowTitle(&quot;Communicate&quot;);
      window.show();
    
      return app.exec();
    }


and its showing errors as follows:

    obj\Debug\main.o(.text$_ZN11CommunicateD1Ev[Communicate::~Communicate()]+0xb)||In function `ZN7QStringC1EPKc&#39;:|
    C:\Qt\4.4.3\include\QtCore\..\..\src\corelib\arch\qatomic_windows.h||undefined reference to `vtable for Communicate&#39;|
    obj\Debug\main.o(.text$_ZN11CommunicateD1Ev[Communicate::~Communicate()]+0x17):C:\Qt\4.4.3\include\QtCore\..\..\src\corelib\arch\qatomic_windows.h||undefined reference to `vtable for Communicate&#39;|
    obj\Debug\communicate.o(.text+0x172)||In function `ZN11CommunicateC2EP7QWidget&#39;:|
    E:\Project\cam2\communicate.cpp|5|undefined reference to `vtable for Communicate&#39;|
    obj\Debug\communicate.o(.text+0x17e):E:\Project\cam2\communicate.cpp|5|undefined reference to `vtable for Communicate&#39;|
    obj\Debug\communicate.o(.text+0x63a)||In function `ZN11CommunicateC1EP7QWidget&#39;:|
    E:\Project\cam2\communicate.cpp|5|undefined reference to `vtable for Communicate&#39;|
    obj\Debug\communicate.o(.text+0x646):E:\Project\cam2\communicate.cpp|5|more undefined references to `vtable for Communicate&#39; follow|
    ||=== Build finished: 6 errors, 0 warnings ===|

guys please help...cant figure it out...

Qt undefined reference to vtable

[MSDN says](http://msdn.microsoft.com/en-us/library/f1863z4b.aspx):

&gt; `swap` should be used in preference to `iter_swap`, which was included in the C++ Standard for backward compatibility.

But [comp.std.c++ says](https://groups.google.com/forum/?fromgroups=#!topic/comp.std.c++/AMH7TXg5EsI):

&gt; Most STL algorithms operate on iterator ranges. It therefore makes sense to
use `iter_swap` when swapping elements within those ranges, since that is its
intended purpose --- swapping the elements pointed to by two iterators. This
allows optimizations for node-based sequences such as `std::list`, whereby the
nodes are just relinked, rather than the data actually being swapped.

So which one is correct? Should I use `iter_swap`, or should I use `swap`? (Is `iter_swap` only for backwards compatibility?) Why?

iter_swap() versus swap() -- what&#39;s the difference?

I have always asked this but I have never received a really good answer; I think that almost any programmer before even writing the first &quot;Hello World&quot; had encountered a phrase like &quot;macro should never be used&quot;, &quot;macro are evil&quot; and so on, my question is: why? With the new C++11 is there a real alternative after so many years?

The easy part is about macros like `#pragma`, that are platform specific and compiler specific, and most of the time they have serious flaws like `#pragma once` that is error prone in at least 2 important situation: same name in different paths and with some network setups and filesystems.

But in general, what about macros and alternatives to their usage?

Why are preprocessor macros evil and what are the alternatives?

    #include &lt;queue&gt;
    using namespace std;

    class Test{
	    int *myArray;

            public:
	    Test(){
		    myArray = new int[10];
	    }
	
	    ~Test(){
		    delete[] myArray;
        }

    };


    int main(){
        queue&lt;Test&gt; q
        Test t;
        q.push(t);
    }

After I run this, I get a runtime error &quot;double free or corruption&quot;. If I get rid of the destructor content (the `delete`) it works fine. What&#39;s wrong?




Double free or corruption after queue::push

I want to find out the clockwise angle between 2 vectors(2D, 3D). 

The clasic way with the dot product gives me the inner angle(0-180 degrees) and I need to use some if statements to determine if the result is the angle I need or its complement. 

Do you know a direct way of computing clockwise angle?

Direct way of computing clockwise angle between 2 vectors

Why does C++11 make [&quot;`delete`d&quot; functions participate in overload resolution](https://stackoverflow.com/a/13951621/541686)?  
Why is this useful? Or in other words, why are they hidden instead of being deleted entirely?

Why do C++11-deleted functions participate in overload resolution?

What&#39;s the difference between `constexpr` and `const`?

- When can I use only one of them?  
- When can I use both and how should I choose one?

What&#39;s the difference between constexpr and const?

I hear that `const` means _thread-safe_ in _C++11_. Is that true?

Does that mean `const` is now the equivalent of _Java_&#39;s `synchronized`?

Are they running out of _keywords_?


Does const mean thread-safe in C++11?

I&#39;m trying to figure out how/if I can use `unique_ptr` in a `queue`.

    // create queue
    std::queue&lt;std::unique_ptr&lt;int&gt;&gt; q;
    
    // add element
    std::unique_ptr&lt;int&gt; p (new int{123});
    q.push(std::move(p));

    // try to grab the element
    auto p2 = foo_queue.front();
    q.pop(); 

I do understand why the code above doesn&#39;t work.  Since the `front` &amp; `pop` are 2 separate steps, the element cannot be moved. Is there a way to do this?

remove unique_ptr from queue

Scott Meyers posted [content and status][1] of his next book EC++11.
He wrote that one item in the book could be *&quot;Avoid `std::enable_if` in function signatures&quot;*.

`std::enable_if` can be used as a function argument, as a return type or as a class template or function template parameter to conditionally remove functions or classes from overload resolution.

In [this question][2] all three solution are shown.

As function parameter:


    template&lt;typename T&gt;
    struct Check1
    {
       template&lt;typename U = T&gt;
       U read(typename std::enable_if&lt;
              std::is_same&lt;U, int&gt;::value &gt;::type* = 0) { return 42; }

       template&lt;typename U = T&gt;
       U read(typename std::enable_if&lt;
              std::is_same&lt;U, double&gt;::value &gt;::type* = 0) { return 3.14; }   
    };


As template parameter:

    template&lt;typename T&gt;
    struct Check2
    {
       template&lt;typename U = T, typename std::enable_if&lt;
                std::is_same&lt;U, int&gt;::value, int&gt;::type = 0&gt;
       U read() { return 42; }

       template&lt;typename U = T, typename std::enable_if&lt;
                std::is_same&lt;U, double&gt;::value, int&gt;::type = 0&gt;
       U read() { return 3.14; }   
    };


As return type:

    template&lt;typename T&gt;
    struct Check3
    {
       template&lt;typename U = T&gt;
       typename std::enable_if&lt;std::is_same&lt;U, int&gt;::value, U&gt;::type read() {
          return 42;
       }

       template&lt;typename U = T&gt;
       typename std::enable_if&lt;std::is_same&lt;U, double&gt;::value, U&gt;::type read() {
          return 3.14;
       }   
    };


  [1]: http://scottmeyers.blogspot.de/2013/01/effective-c11-content-and-status.html
  [2]: https://stackoverflow.com/questions/11055923/stdenable-if-parameter-vs-template-parameter

 * Which solution should be preferred and why should I avoid others? 
 * In which cases *&quot;Avoid `std::enable_if` in function signatures&quot;* concerns usage as return type (which is not part of normal function signature but of template specializations)?
 * Are there any differences for member and non-member function templates?

Why should I avoid std::enable_if in function signatures

&gt; **Edit, in order to avoid confusion: `decltype` does _not_ accept two arguments. See answers.**

The following two structs can be used to check for the existance of a member function on a type `T` during compile-time:

    // Non-templated helper struct:
    struct _test_has_foo {
        template&lt;class T&gt;
        static auto test(T* p) -&gt; decltype(p-&gt;foo(), std::true_type());

        template&lt;class&gt;
        static auto test(...) -&gt; std::false_type;
    };

    // Templated actual struct:
    template&lt;class T&gt;
    struct has_foo : decltype(_test_has_foo::test&lt;T&gt;(0))
    {};

I think the idea is to use SFINAE when checking for the existance of a member function, so in case `p-&gt;foo()` isn&#39;t valid, only the ellipses version of `test`, which returns the `std::false_type` is defined. Otherwise the first method is defined for `T*` and will return `std::true_type`. The actual &quot;switch&quot; happens in the second class, which inherits from the type returned by `test`. This seems clever and &quot;lightweight&quot; compared to different approaches with `is_same` and stuff like that.

The `decltype` with two arguments first looked surprising to me, as I thought it just gets the type of an expression. When I saw the code above, I thought it&#39;s something like &quot;try to compile the expressions and always return the type of the second. Fail if the expressions fail to compile&quot; (so hide this specialization; SFINAE).

But:

Then I thought I could use this method to write any &quot;is valid expression&quot; checker, as long as it depends on some type `T`. Example:

    ...
        template&lt;class T&gt;
        static auto test(T* p) -&gt; decltype(bar(*p), std::true_type());
    ...

http://ideone.com/dJkLPF

This, so I thought, will return a `std::true_type` if and only if `bar` is defined accepting a `T` as the first parameter (or if `T` is convertible, etc...), i.e.: if `bar(*p)` would compile if it was written in some context where `p` is defined of type `T*`.

However, the modification above evaluates *always* to `std::false_type`. **Why is this?** I don&#39;t want to fix it with some complicated different code. I just want to know why it doesn&#39;t work as I expected it to. Clearly, **`decltype` with two arguments** works different than I thought. I couldn&#39;t find any documentation; it&#39;s only explained with one expression everywhere.

What is decltype with two arguments?

Consider following code:

    #include &lt;iostream&gt;
    #include &lt;type_traits&gt;
    
    template &lt;typename T&gt;
    struct A {
        int val = 0;
    
        template &lt;class = typename std::enable_if&lt;T::value&gt;::type&gt;
        A(int n) : val(n) {};
        A(...) { }

        /* ... */
    };
    
    struct YES { constexpr static bool value = true; };
    struct NO { constexpr static bool value = false; };
    
    int main() {
        A&lt;YES&gt; y(10);
        A&lt;NO&gt; n;
        std::cout &lt;&lt; &quot;YES: &quot; &lt;&lt; y.val &lt;&lt; std::endl
                  &lt;&lt; &quot;NO:  &quot; &lt;&lt; n.val &lt;&lt; std::endl;
    }

I want to selectively define constructor A::A(int) only for some types using enable_if. For all other types there is default constructor A::A(...) which should be the default case for compiler when substitution fails. However this makes sense for me compiler (gcc version 4.9.0 20130714) is still complaining 

&gt; sfinae.cpp: In instantiation of &#39;struct A&lt;NO&gt;&#39;: sfinae.cpp:19:11:  
&gt; required from here sfinae.cpp:9:5: error: no type named &#39;type&#39; in  
&gt; &#39;struct std::enable_if&lt;false, void&gt;&#39;  
&gt;      A(int n) : val(n) {};  

Is something like this possible for constructor? Is this possible with another constructor(s) (copy-constructor and move-constructor)?

Select class constructor using enable_if

I was researching what is allowed in a [core constant expression*](http://en.cppreference.com/w/cpp/language/constant_expression), which is covered in section `5.19` *Constant expressions* paragraph *2* of the [draft C++ standard](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3485.pdf) which says:

&gt;A conditional-expression is a core constant expression unless it involves one of the following as a potentially evaluated subexpression (3.2), but subexpressions of logical AND (5.14), logical OR (5.15), and conditional (5.16) operations that are not evaluated are not considered [ Note: An overloaded operator invokes a function.—end note ]:

and lists out the exclusions in the bullets that follows and includes (*emphasis mine*):

&gt;— **an operation that would have undefined behavior** [ Note: including, for example, signed integer overflow (Clause 5), certain pointer arithmetic (5.7), division by zero (5.6), or certain shift operations (5.8) —end note ];

*Huh*? Why do *constant expressions* need this clause to cover [undefined behavior](http://en.wikipedia.org/wiki/Undefined_behavior)? Is there something special about *constant expressions* that requires *undefined behavior* to have a special carve out in the exclusions?

Does having this clause give us any advantages or tools we would not have without it?

For reference, this looks like the last revision of the proposal for [Generalized Constant Expressions](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2235.pdf).


Why do constant expressions have an exclusion for undefined behavior?

I watched Walter Brown&#39;s talk at Cppcon14 about modern template programming ([Part I][1], [Part II][2]) where he presented his `void_t` SFINAE technique.

Example:  
Given a simple variable template that evaluates to `void` if all template arguments are well formed:

    template&lt; class ... &gt; using void_t = void;

and the following trait that checks for the existence of a member variable called *member*:

    template&lt; class , class = void &gt;
    struct has_member : std::false_type
    { };

    // specialized as has_member&lt; T , void &gt; or discarded (sfinae)
    template&lt; class T &gt;
    struct has_member&lt; T , void_t&lt; decltype( T::member ) &gt; &gt; : std::true_type
    { };

I tried to understand why and how this works. Therefore a tiny example:


    class A {
    public:
        int member;
    };

    class B {
    };

    static_assert( has_member&lt; A &gt;::value , &quot;A&quot; );
    static_assert( has_member&lt; B &gt;::value , &quot;B&quot; );


**1.** `has_member&lt; A &gt;`

  -  `has_member&lt; A , void_t&lt; decltype( A::member ) &gt; &gt;`
      -  `A::member` exists
      -  `decltype( A::member )` is well-formed
      -  `void_t&lt;&gt;` is valid and evaluates to `void`
  -  `has_member&lt; A , void &gt;` and therefore it chooses the specialized template
  -  `has_member&lt; T , void &gt;` and evaluates to `true_type`

**2.** `has_member&lt; B &gt;`

  -  `has_member&lt; B , void_t&lt; decltype( B::member ) &gt; &gt;`
      -  `B::member` does not exist
      -  `decltype( B::member )` is ill-formed and fails silently (sfinae)
      -  `has_member&lt; B , expression-sfinae &gt;` so this template is discarded
  -  compiler finds `has_member&lt; B , class = void &gt;` with void as default argument
  -  `has_member&lt; B &gt;` evaluates to `false_type`

[http://ideone.com/HCTlBb][3]


Questions:  
1. Is my understanding of this correct?  
2. Walter Brown states that the default argument has to be the exact same type as the one used in `void_t` for it to work. Why is that? (I don&#39;t see why this types need to match, doesn&#39;t just any default type does the job?)  


  [1]: http://youtu.be/Am2is2QCvxY
  [2]: http://youtu.be/a0FliKwcwXE
  [3]: http://ideone.com/HCTlBb

How does `void_t` work

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?

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?

Content Type	Original Author	Original Content on Stackoverflow
Question	template boy	View Question on Stackoverflow
Solution 1 - C++	Pubby	View Answer on Stackoverflow

What does the 'void()' in 'auto f(params) -> decltype(..., void())' do?

C++ Problem Overview

C++ Solutions

Solution 1 - C++

Delegate Constructor C++

Embed TypeScript code in an HTML document

Attributions