`std::array&lt;T, N&gt;` is an aggregate:  it doesn&#39;t have any user-declared constructors, not even one taking a `std::initializer_list`.  Initialization using braces is performed using _aggregate initialization_, a feature of C++ that was inherited from C.

The &quot;old style&quot; of aggregate initialization uses the `=`:

    std::array&lt;int, 4&gt; y = { { 1, 2, 3, 4 } };

With this old style of aggregate initialization, extra braces may be elided, so this is equivalent to:

    std::array&lt;int, 4&gt; y = { 1, 2, 3, 4 };

However, these extra braces may only be elided &quot;in a declaration of the form `T x = { a };`&quot; (C++11 &#167;8.5.1/11), that is, when the old style `=` is used .  This rule allowing brace elision does not apply for direct list initialization.  A footnote here reads:  &quot;Braces cannot be elided in other uses of list-initialization.&quot;

There is a defect report concerning this restriction: [CWG defect #1270](http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2012/n3367.html#1270).  If the proposed resolution is adopted, brace elision will be allowed for other forms of list initialization, and the following will be well-formed:

    std::array&lt;int, 4&gt; y{ 1, 2, 3, 4 };

(Hat tip to Ville Voutilainen for finding the defect report.)

Because `std::vector` offers a constructor that takes in a `std::initializer_list&lt;T&gt;`, while `std::array` has no constructors and the `{1, 2, 3, 4}` braced init-list is in fact not interpreted as a `std::initializer_list`, but aggregate initialization for the inner C-style array of `std::array` (that&#39;s where the second set of braces comes from: One for `std::array`, one for the inner C-style member array).

How can I alter a user-defined table type in SQL Server ?

Altering user-defined table types in SQL Server

I currently have php returning the current date/time like so: 

    $now = date(&quot;Y-m-d H:m:s&quot;);

What I&#39;d like to do is have a new variable `$new_time` equal `$now + $hours`, where `$hours` is a number of hours ranging from 24 to 800. 

Any suggestions? 



Add &#39;x&#39; number of hours to date

Code:

    std::vector&lt;int&gt; x{1,2,3,4};
    std::array&lt;int, 4&gt; y{{1,2,3,4}};

Why do I need double curly braces for std::array?


Why is the C++ initializer_list behavior for std::vector and std::array different?

Code:
<pre><code class="hljs language-c">std::vector&#x3C;int> x{1,2,3,4};
std::array&#x3C;int, 4> y{{1,2,3,4}};
</code></pre>
Why do I need double curly braces for std::array?

After conducting some experiments on square matrices of different sizes, a pattern came up. Invariably, **transposing a matrix of size `2^n` is slower than transposing one of size `2^n+1`**. For small values of `n`, the difference is not major.

Big differences occur however over a value of 512. (at least for me)

*Disclaimer: I know the function doesn&#39;t actually transpose the matrix because of the double swap of elements, but it makes no difference.*

Follows the code:

    #define SAMPLES 1000
    #define MATSIZE 512

    #include &lt;time.h&gt;
    #include &lt;iostream&gt;
    int mat[MATSIZE][MATSIZE];
 
    void transpose()
    {
       for ( int i = 0 ; i &lt; MATSIZE ; i++ )
       for ( int j = 0 ; j &lt; MATSIZE ; j++ )
       {
           int aux = mat[i][j];
           mat[i][j] = mat[j][i];
           mat[j][i] = aux;
       }
    }
 
    int main()
    {
       //initialize matrix
       for ( int i = 0 ; i &lt; MATSIZE ; i++ )
       for ( int j = 0 ; j &lt; MATSIZE ; j++ )
           mat[i][j] = i+j;

       int t = clock();
       for ( int i = 0 ; i &lt; SAMPLES ; i++ )
           transpose();
       int elapsed = clock() - t;

       std::cout &lt;&lt; &quot;Average for a matrix of &quot; &lt;&lt; MATSIZE &lt;&lt; &quot;: &quot; &lt;&lt; elapsed / SAMPLES;
    }

Changing `MATSIZE` lets us alter the size (duh!). I posted two versions on ideone:

- **size 512** - average **2.46 ms** - http://ideone.com/1PV7m
- **size 513** - average **0.75  ms** - http://ideone.com/NShpo

In my environment (MSVS 2010, full optimizations), the difference is similar :

- **size 512** - average **2.19 ms** 
- **size 513** - average **0.57  ms**

**Why is this happening?**

Why is transposing a matrix of 512x512 much slower than transposing a matrix of 513x513?

How can I output the value of an `enum class` in C++11? In C++03 it&#39;s like this:

    #include &lt;iostream&gt;
    
    using namespace std;
    
    enum A {
      a = 1,
      b = 69,
      c= 666
    };
    
    int main () {
      A a = A::c;
      cout &lt;&lt; a &lt;&lt; endl;
    }

in c++0x this code doesn&#39;t compile

    #include &lt;iostream&gt;
    
    using namespace std;
    
    enum class A {
      a = 1,
      b = 69,
      c= 666
    };
    
    int main () {
      A a = A::c;
      cout &lt;&lt; a &lt;&lt; endl;
    }


    prog.cpp:13:11: error: cannot bind &#39;std::ostream&#39; lvalue to &#39;std::basic_ostream&lt;char&gt;&amp;&amp;&#39;
    /usr/lib/gcc/i686-pc-linux-gnu/4.5.1/../../../../include/c++/4.5.1/ostream:579:5: error:   initializing argument 1 of &#39;std::basic_ostream&lt;_CharT, _Traits&gt;&amp; std::operator&lt;&lt;(std::basic_ostream&lt;_CharT, _Traits&gt;&amp;&amp;, const _Tp&amp;) [with _CharT = char, _Traits = std::char_traits&lt;char&gt;, _Tp = A]&#39;

compiled at [Ideone.com][1]


  [1]: https://ideone.com/

How can I output the value of an enum class in C++11

On my Linux (and OS X) machines, the `iconv()` function has this prototype:

    size_t iconv (iconv_t, char **inbuf...

while on FreeBSD it looks like this:

    size_t iconv (iconv_t, const char **inbuf...

I would like my C++ code to build on both platforms. With C compilers, passing a `char**` for a `const char**` parameter (or vice versa) typically emits a mere warning; however in C++ it&#39;s a fatal error. So if I pass a `char**`, it won&#39;t compile on BSD, and if I pass a `const char**` it won&#39;t compile on Linux / OS X. How can I write code that compiles on both, without resorting to trying to detect the platform?

One (failed) idea I had was to provide a local prototype that overrides any provided by the header:

    void myfunc(void) {
        size_t iconv (iconv_t, char **inbuf);
        iconv(foo, ptr);
    }

This fails because `iconv` needs C linkage, and you cannot put `extern &quot;C&quot;` within a function (why not?)

The best working idea I&#39;ve come up with is to cast the function pointer itself:

    typedef void (*func_t)(iconv_t, const char **);
    ((func_t)(iconv))(foo, ptr);

but this has the potential to mask other, more serious errors.

How can I portably call a C++ function that takes a char** on some platforms and a const char** on others?

I&#39;d be interested in aspects like:

 * scope/features
 * performance
 * maturity


How does libuv compare to Boost/ASIO?

How do I cast an int to an enum in C++?

For example:

    enum Test
    {
        A, B
    };

    int a = 1;

How do I convert `a` to type `Test::A`?


How to cast int to enum in C++?

I have a `vector&lt;CustomClass*&gt;` and I put a lot of items in the vector and I need fast access, so I don&#39;t use list. How to set initial size of vector (for example to be 20 000 places, so to avoid copy when I insert new)?

How to set initial size of std::vector?

I&#39;ve followed the instructions [on the GDB wiki][1] to install the python pretty-printers for viewing STL containers. My `~/.gdbinit` now looks like this:

    python 
    import sys 
    sys.path.insert(0, &#39;/opt/gdb_prettyprint/python&#39;) 
    from libstdcxx.v6.printers import register_libstdcxx_printers 
    register_libstdcxx_printers (None) 
    end 

However, when I run GDB and attempt to print an STL type, I get the following:

    print myString
    Python Exception &lt;class &#39;gdb.error&#39;&gt; No type named std::basic_string&lt;char&gt;::_Rep.: 
    $3 = 

  [1]: http://sourceware.org/gdb/wiki/STLSupport

Can anyone shed some light on this? I&#39;m running Ubuntu 12.04, which comes with GDB 7.4.


How to pretty-print STL containers in GDB?

We are developing a highly performance critical software in C++. There we need a concurrent hash map and implemented one. So we wrote a benchmark to figure out, how much slower our concurrent hash map is compared with `std::unordered_map`.

But, `std::unordered_map` seems to be incredibly slow... So this is our micro-benchmark (for the concurrent map we spawned a new thread to make sure that locking does not get optimized away and note that I never inser 0 because I also benchmark with `google::dense_hash_map`, which needs a null value):

    boost::random::mt19937 rng;
    boost::random::uniform_int_distribution&lt;&gt; dist(std::numeric_limits&lt;uint64_t&gt;::min(), std::numeric_limits&lt;uint64_t&gt;::max());
    std::vector&lt;uint64_t&gt; vec(SIZE);
    for (int i = 0; i &lt; SIZE; ++i) {
        uint64_t val = 0;
        while (val == 0) {
            val = dist(rng);
        }
        vec[i] = val;
    }
    std::unordered_map&lt;int, long double&gt; map;
    auto begin = std::chrono::high_resolution_clock::now();
    for (int i = 0; i &lt; SIZE; ++i) {
        map[vec[i]] = 0.0;
    }
    auto end = std::chrono::high_resolution_clock::now();
    auto elapsed = std::chrono::duration_cast&lt;std::chrono::milliseconds&gt;(end - begin);
    std::cout &lt;&lt; &quot;inserts: &quot; &lt;&lt; elapsed.count() &lt;&lt; std::endl;
    std::random_shuffle(vec.begin(), vec.end());
    begin = std::chrono::high_resolution_clock::now();
    long double val;
    for (int i = 0; i &lt; SIZE; ++i) {
        val = map[vec[i]];
    }
    end = std::chrono::high_resolution_clock::now();
    elapsed = std::chrono::duration_cast&lt;std::chrono::milliseconds&gt;(end - begin);
    std::cout &lt;&lt; &quot;get: &quot; &lt;&lt; elapsed.count() &lt;&lt; std::endl;


(EDIT: the whole source code can be found here: http://pastebin.com/vPqf7eya)

The result for `std::unordered_map` is:

    inserts: 35126
    get    : 2959

For `google::dense_map`:

    inserts: 3653
    get    : 816

For our hand backed concurrent map (which does locking, although the benchmark is single threaded - but in a separate spawn thread):

    inserts: 5213
    get    : 2594

If I compile the benchmark program without pthread support and run everything in the main thread, I get the following results for our hand backed concurrent map:

    inserts: 4441
    get    : 1180

I compile with the following command:

    g++-4.7 -O3 -DNDEBUG -I/tmp/benchmap/sparsehash-2.0.2/src/ -std=c++11 -pthread main.cc

So especially inserts on `std::unordered_map` seem to be extremely expensive - 35 seconds vs 3-5 seconds for other maps. Also the lookup time seems to be quite high.

My question: why is this? I read another question on stackoverflow where someone asks, why `std::tr1::unordered_map` is slower than his own implementation. There the highest rated answer states, that the `std::tr1::unordered_map` needs to implement a more complicated interface. But I can not see this argument: we use a bucket approach in our concurrent_map, `std::unordered_map` uses a bucket-approach too (`google::dense_hash_map` does not, but than `std::unordered_map` should be at least as fast than our hand backed concurrency-safe version?). Apart from that I can not see anything in the interface that force a feature which makes the hash map perform badly...

So my question: is it true that `std::unordered_map` seems to be very slow? If no: what is wrong? If yes: what is the reason for that.

And my main question: why is inserting a value into a `std::unordered_map` so terrible expensive (even if we reserve enough space at the beginning, it does not perform much better - so rehashing seems not to be the problem)?

EDIT:
=====

First of all: yes the presented benchmark is not flawless - this is because we played around a lot with it and it is just a hack (for example the `uint64` distribution to generate ints would in practice not be a good idea, exclude 0 in a loop is kind of stupid etc...).

At the moment most comments explain, that I can make the unordered_map faster by preallocating enough space for it. In our application this is just not possible: we are developing a database management system and need a hash map to store some data during a transaction (for example locking information). So this map can be everything from 1 (user just makes one insert and commits) to billions of entries (if full table scans happen). It is just impossible to preallocate enough space here (and just allocate a lot in the beginning will consume too much memory).

Furthermore, I apologize, that I did not state my question clear enough: I am not really interested in making unordered_map fast (using googles dense hash map works fine for us), I just don&#39;t really understand where this huge performance differences come from. It can not be just preallocation (even with enough preallocated memory, the dense map is an order of magnitude faster than unordered_map, our hand backed concurrent map starts with an array of size 64 - so a smaller one than unordered_map).

So what is the reason for this bad performance of `std::unordered_map`? Or differently asked: Could one write an implementation of the `std::unordered_map` interface which is standard conform and (nearly) as fast as googles dense hash map? Or is there something in the standard that enforces the implementer to chose an inefficient way to implement it?

EDIT 2:
=====
By profiling I see that a lot of time is used for integer divions. `std::unordered_map` uses prime numbers for the array size, while the other implementations use powers of two. Why does `std::unordered_map` use prime-numbers? To perform better if the hash is bad? For good hashes it does imho make no difference.

EDIT 3:
=====
These are the numbers for `std::map`:

    inserts: 16462
    get    : 16978

Sooooooo: why are inserts into a `std::map` faster than inserts into a `std::unordered_map`... I mean WAT? `std::map` has a worse locality (tree vs array), needs to make more allocations (per insert vs per rehash + plus ~1 for each collision) and, most important: has another algorithmic complexity (O(logn) vs O(1))!

Is gcc std::unordered_map implementation slow? If so - why?

What are the exception classes that are included in the standard C++ library, and what should they be used for?  I know there are a few new C++11 exceptions, but I&#39;m not sure what they are or where they are.

What exception classes are in the standard C++ library

What is the `capacity()` of an `std::vector` which is created using the default constuctor? I know that the `size()` is zero. Can we state that a default constructed vector does not call heap memory allocation?

This way it would be possible to create an array with an arbitrary reserve using a single allocation, like `std::vector&lt;int&gt; iv; iv.reserve(2345);`. Let&#39;s say that for some reason, I do not want to start the `size()` on 2345.

For example, on Linux (g++ 4.4.5, kernel 2.6.32 amd64)

    #include &lt;iostream&gt;
    #include &lt;vector&gt;
    
    int main()
    {
      using namespace std;
      cout &lt;&lt; vector&lt;int&gt;().capacity() &lt;&lt; &quot;,&quot; &lt;&lt; vector&lt;int&gt;(10).capacity() &lt;&lt; endl;
      return 0;
    }

printed `0,10`. Is it a rule, or is it STL vendor dependent?

Initial capacity of vector in C++

I was curious how `std:next_permutation` was implemented so I extracted the the `gnu libstdc++ 4.7` version and sanitized the identifiers and formatting to produce the following demo...

    #include &lt;vector&gt;
    #include &lt;iostream&gt;
    #include &lt;algorithm&gt;
     
    using namespace std;
     
    template&lt;typename It&gt;
    bool next_permutation(It begin, It end)
    {
            if (begin == end)
                    return false;
     
            It i = begin;
            ++i;
            if (i == end)
                    return false;
     
            i = end;
            --i;
     
            while (true)
            {
                    It j = i;
                    --i;
     
                    if (*i &lt; *j)
                    {
                            It k = end;
     
                            while (!(*i &lt; *--k))
                                    /* pass */;
     
                            iter_swap(i, k);
                            reverse(j, end);
                            return true;
                    }
     
                    if (i == begin)
                    {
                            reverse(begin, end);
                            return false;
                    }
            }
    }
     
    int main()
    {
            vector&lt;int&gt; v = { 1, 2, 3, 4 };

            do
            {
                    for (int i = 0; i &lt; 4; i++)
                    {
                            cout &lt;&lt; v[i] &lt;&lt; &quot; &quot;;
                    }
                    cout &lt;&lt; endl;
            }
            while (::next_permutation(v.begin(), v.end()));
    }

The output is as expected: http://ideone.com/4nZdx

My questions are: How does it work?  What is the meaning of `i`, `j` and `k`?  What value do they hold at the different parts of execution?  What is a sketch of a proof of its correctness?

Clearly before entering the main loop it just checks the trivial 0 or 1 element list cases.  At entry of the main loop i is pointing to the last element (not one past end) and the list is at least 2 elements long.

What is going on in the body of the main loop?


std::next_permutation Implementation Explanation

Suppose I have the following code:

    #include &lt;vector&gt;
    struct A {
        int a;
        int x;
    };
    int main() {
        using namespace std;
        A a1;
        A a2;
        vector&lt;A&gt; va;
        va.push_back(a1);
        va.push_back(move(a2));
    }
I am aware that the elements of std::vector are stored contiguously, unlike a std::list. In the above code `a2` is moved but is there really no copying of `a2` to the vector `va`? What is the difference between `va.push_back(a2);` and `va.push_back(move(a2));`?

Move with vector::push_back

Is it good practice when writing C++11 code to set default values for class members in the header file of the class?

Or is it better to do this in the constructor of the class?

EDIT:

I mean:

**foo.h**:

    #include &lt;string&gt;
    
    using std::string;
    
    class Foo{
        private:
            string greet = &quot;hello&quot;;
        public:
            Foo();
    };

VS

**foo.cpp** (of course with the necessary header file, but without the in-class initialization):

    Foo::Foo(){
        greet = &quot;hello&quot;;
    }


Which one is better and why?

Content Type	Original Author	Original Content on Stackoverflow
Question	Sungmin	View Question on Stackoverflow
Solution 1 - C++	James McNellis	View Answer on Stackoverflow
Solution 2 - C++	Xeo	View Answer on Stackoverflow

Why is the C++ initializer_list behavior for std::vector and std::array different?

C++ Problem Overview

C++ Solutions

Solution 1 - C++

Solution 2 - C++

Add 'x' number of hours to date

Altering user-defined table types in SQL Server

Attributions