According to Herb Sutter in [this article](http://herbsutter.com/gotw/_102/) it was &quot;partly an oversight&quot;. The article contains a nice implementation, and makes a strong case for using it:

    template&lt;typename T, typename ...Args&gt;
    std::unique_ptr&lt;T&gt; make_unique( Args&amp;&amp; ...args )
    {
        return std::unique_ptr&lt;T&gt;( new T( std::forward&lt;Args&gt;(args)... ) );
    }

**Update**: The original update [has been updated](http://herbsutter.com/2013/05/29/gotw-89-solution-smart-pointers/) and the emphasis has changed.



I have array with objects.

Something Like this:

    var arr = new Array(
      {x:1, y:2},
      {x:3, y:4}
    );

When I try:

    arr.indexOf({x:1, y:2});

It returns `-1`.

If I have strings or numbers or other type of elements but object, then `indexOf()` works fine.

Does anyone know why and what should I do to search object elements in array?

Of course, I mean the ways except making string hash keys for objects and give it to array...

Why Array.indexOf doesn&#39;t find identical looking objects

Having empty `Dictionary&lt;int, string&gt;` how to fill it with keys and values from XML like 

    &lt;items&gt;
    &lt;item id=&#39;int_goes_here&#39; value=&#39;string_goes_here&#39;/&gt;
    &lt;/items&gt;

and serialize it back into XML not using XElement?

How to serialize/deserialize to `Dictionary&lt;int, string&gt;` from custom XML not using XElement?

&gt; **Possible Duplicate:**  
&gt; [make_unique and perfect forwarding](https://stackoverflow.com/questions/7038357/make-unique-and-perfect-forwarding)  

&lt;!-- End of automatically inserted text --&gt;

Why does C++11 have a `make_shared` template, but not a `make_unique` template?

This makes code very inconsistent.

    auto x = make_shared&lt;string&gt;(&quot;abc&quot;);
    auto y = unique_ptr&lt;string&gt;(new string(&quot;abc&quot;));

Why does C++11 have `make_shared` but not `make_unique`

> Possible Duplicate: 
> <a href="https://stackoverflow.com/questions/7038357/make-unique-and-perfect-forwarding" target="_blank" rel="noopener noreferrer">make_unique and perfect forwarding</a>

Why does C++11 have a <code>make_shared</code> template, but not a <code>make_unique</code> template?
This makes code very inconsistent.
<pre><code class="hljs language-c">auto x = make_shared&#x3C;string>("abc");
auto y = unique_ptr&#x3C;string>(new string("abc"));
</code></pre>

I am a beginner in C++ programming. 

Today I come across a new topic: strongly typed `enum`. I&#39;ve researched it a bit but till now I am unable to find out why do we need this and what is the use of the same?

For example if we have:

    enum xyz{a, b, c};
    /*a = 0, b = 1, c = 2, (Typical C format)*/

Why do we need to write:

    enum class xyz{a, b, c};

What are we trying to do here?
My most important doubt is how to use it.
Could you provide a small example, which will make me understand.
 
 

Enum vs Strongly typed enum

Why doesn&#39;t `pop_back()` have a return value? I have Googled regarding this and found out that it makes it more efficient. Is this the only reason for making it so in the standard?

pop_back() return value?

I have two STL vectors `A` and `B` and I&#39;d like to clear all elements of `A` and move all elements of `B` to `A` and then clear out `B`. Simply put, I want to do this:

    std::vector&lt;MyClass&gt; A;
    std::vector&lt;MyClass&gt; B;
    ....
    A = B;
    B.clear();

Since `B` could be pretty long, it takes `k*O(N)` to do this operation, where `k` is a constant, and `N` is `max(size_of(A), size_of(B))`. I was wondering if there could be a more efficient way to do so. One thing that I could think of is to define `A` and `B` as pointers and then copy pointers in constant time and clear out `B`.



STL vector: Moving all elements of a vector

I&#39;m confusing myself with difference between a future and a promise.

Obviously, they have different methods and stuff, but what is the actual use case?

Is it?:

 - when I&#39;m managing some async task, I use future to get the value &quot;in future&quot;
 - when I&#39;m the async task, I use promise as the return type to allow the user get a future from my promise

Futures vs. Promises

Assume we&#39;re trying to use the tsc for performance monitoring and we we want to prevent instruction reordering.

These are our options: 

**1:** `rdtscp` is a serializing call. It prevents reordering around the call to rdtscp.

    __asm__ __volatile__(&quot;rdtscp; &quot;         // serializing read of tsc
                         &quot;shl $32,%%rdx; &quot;  // shift higher 32 bits stored in rdx up
                         &quot;or %%rdx,%%rax&quot;   // and or onto rax
                         : &quot;=a&quot;(tsc)        // output to tsc variable
                         :
                         : &quot;%rcx&quot;, &quot;%rdx&quot;); // rcx and rdx are clobbered

However, `rdtscp` is only available on newer CPUs. So in this case we have to use `rdtsc`. But `rdtsc` is non-serializing, so using it alone will not prevent the CPU from reordering it.

So we can use either of these two options to prevent reordering:

**2:** This is a call to `cpuid` and then `rdtsc`. `cpuid` is a serializing call.

    volatile int dont_remove __attribute__((unused)); // volatile to stop optimizing
    unsigned tmp;
    __cpuid(0, tmp, tmp, tmp, tmp);                   // cpuid is a serialising call
    dont_remove = tmp;                                // prevent optimizing out cpuid

    __asm__ __volatile__(&quot;rdtsc; &quot;          // read of tsc
                         &quot;shl $32,%%rdx; &quot;  // shift higher 32 bits stored in rdx up
                         &quot;or %%rdx,%%rax&quot;   // and or onto rax
                         : &quot;=a&quot;(tsc)        // output to tsc
                         :
                         : &quot;%rcx&quot;, &quot;%rdx&quot;); // rcx and rdx are clobbered

**3:** This is a call to `rdtsc` with `memory` in the clobber list, which prevents reordering

    __asm__ __volatile__(&quot;rdtsc; &quot;          // read of tsc
                         &quot;shl $32,%%rdx; &quot;  // shift higher 32 bits stored in rdx up
                         &quot;or %%rdx,%%rax&quot;   // and or onto rax
                         : &quot;=a&quot;(tsc)        // output to tsc
                         :
                         : &quot;%rcx&quot;, &quot;%rdx&quot;, &quot;memory&quot;); // rcx and rdx are clobbered
                                                      // memory to prevent reordering

My understanding for the 3rd option is as follows:

Making the call `__volatile__` prevents the optimizer from removing the asm or moving it across any instructions that could need the results (or change the inputs) of the asm. However it could still move it with respect to unrelated operations. So `__volatile__` is not enough.

Tell the compiler memory is being clobbered: ` : &quot;memory&quot;)`. The `&quot;memory&quot;` clobber means that GCC cannot make any assumptions about memory contents remaining the same across the asm, and thus will not reorder around it.

So my questions are:

 - 1: Is my understanding of `__volatile__` and `&quot;memory&quot;` correct?
 - 2: Do the second two calls do the same thing?
 - 3: Using `&quot;memory&quot;` looks much simpler than using another serializing instruction. Why would anyone use the 3rd option over the 2nd option?

Difference between rdtscp, rdtsc : memory and cpuid / rdtsc?

At http://blogs.msdn.com/b/vcblog/archive/2011/09/12/10209291.aspx, the VC++ team officially declare that they have not yet implemented the C++11 core feature &quot;Expression SFINAE&quot;. However, The following code examples copied from http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2634.html are accepted by the VC++ compiler.

example 1:

    template &lt;int I&gt; struct A {};
    
    char xxx(int);
    char xxx(float);
    
    template &lt;class T&gt; A&lt;sizeof(xxx((T)0))&gt; f(T){}
    
    int main()
    {
        f(1);
    }

example 2:

    struct X {};
    struct Y 
    {
        Y(X){}
    };
    
    template &lt;class T&gt; auto f(T t1, T t2) -&gt; decltype(t1 + t2); // #1
    X f(Y, Y);  // #2
    
    X x1, x2;
    X x3 = f(x1, x2);  // deduction fails on #1 (cannot add X+X), calls #2

**My question is: What is &quot;Expression SFINAE&quot;?**


What is &quot;Expression SFINAE&quot;?

I am [&#128542;](http://www.fileformat.info/info/unicode/char/1f61e/index.htm) to find that I cannot use [&#128515;](http://www.fileformat.info/info/unicode/char/1f603/index.htm) as a valid identifier with g++ 4.7, even with the `-fextended-identifiers` option enabled:

    int main(int argc, const char* argv[])
    {
      const char* &#128515; = &quot;I&#39;m very happy&quot;;
      return 0;
    }

&gt; main.cpp:3:3: error: stray ‘\360’ in program &lt;br/&gt;
main.cpp:3:3: error: stray ‘\237’ in program &lt;br/&gt;
main.cpp:3:3: error: stray ‘\230’ in program &lt;br/&gt;
main.cpp:3:3: error: stray ‘\203’ in program

After some googling, I discovered that [UTF-8 characters are not yet supported in identifiers](http://gcc.gnu.org/wiki/FAQ#What_is_the_status_of_adding_the_UTF-8_support_for_identifier_names_in_GCC.3F), but a *universal-character-name* should work. So I convert my source to:

    int main(int argc, const char* argv[])
    {
      const char* \U0001F603 = &quot;I&#39;m very happy&quot;;
      return 0;
    }

&gt; main.cpp:3:15: error: universal character \U0001F603 is not valid in an identifier

So apparently &#128515; isn&#39;t a valid identifier character. However, the standard specifically allows characters from the range `10000-1FFFD` in Annex E.1 and doesn&#39;t disallow it as an initial character in E.2.

My next effort was to see if any other allowed Unicode characters worked - but none that I tried did. Not even the ever important [PILE OF POO (&#128169;)](http://www.fileformat.info/info/unicode/char/1f4a9/index.htm) character.

So, for the sake of meaningful and descriptive variable names, what gives? Does `-fextended-identifiers` do as it advertises or not? Is it only supported in the very latest build? And what kind of support do other compilers have?





&#128515; (and other Unicode characters) in identifiers not allowed by g++

Normally you can define a cast for a class by using the following syntax:

    class Test {
    public:
      explicit operator bool() { return false; }
    };

Is there a way to do this or something similar for an `enum class`?

Content Type	Original Author	Original Content on Stackoverflow
Question	Šimon Tóth	View Question on Stackoverflow
Solution 1 - C++	juanchopanza	View Answer on Stackoverflow

Why does C++11 have `make_shared` but not `make_unique`

C++ Problem Overview

C++ Solutions

Solution 1 - C++

How to serialize/deserialize to `Dictionary<int, string>` from custom XML not using XElement?

Why Array.indexOf doesn't find identical looking objects

Attributions