 - [ISO C++ committee](http://www.open-std.org/jtc1/sc22/wg21/)
 - [Bjarne Stroustrup](http://www.research.att.com/~bs)
  - Especially his [C++0x FAQ](http://www.research.att.com/~bs/C++0xFAQ.html)
  - [*The Design of C++0x* (pdf)](http://www.research.att.com/~bs/rules.pdf) from C/C++ Users Journal, May 2005
 - Wikipedia&#39;s [C++0x article](http://en.wikipedia.org/wiki/C%2B%2B0x)
 - G++&#39;s [experimental support for C++0x](http://gcc.gnu.org/projects/cxx0x.html) with the -std=c++0x switch
 - SO&#39;s [tag:c++0x] tag


Articles on
------------

[Lambda Expressions][1],

[The Type Traits Library][2],

[The rvalue Reference][3],

[Concepts][4],

[Variadic Templates][5],

[shared_ptr][6]

[Regular Expressions][7]

[Tuples][8]

[Multi Threading][9]

General Discussion
--------------

[The C/C++ Users Journal][10],

[The New C++][11],

[Article][12]


Videos
------

[Google tech talk][13] 

overview of various features
---------------------------------
[overview at wikipedia][14]

Library
-------
[Boost][15]


  [1]: http://www.informit.com/guides/content.aspx?g=cplusplus&amp;seqNum=254
  [2]: http://www.informit.com/guides/content.aspx?g=cplusplus&amp;seqNum=276
  [3]: http://www.informit.com/guides/content.aspx?g=cplusplus&amp;seqNum=310
  [4]: http://www.informit.com/guides/content.aspx?g=cplusplus&amp;seqNum=313
  [5]: http://www.informit.com/guides/content.aspx?g=cplusplus&amp;seqNum=396
  [6]: http://www.informit.com/guides/content.aspx?g=cplusplus&amp;seqNum=239
  [7]: http://www.ddj.com/cpp/185300414
  [8]: http://www.ddj.com/cpp/184401974
  [9]: http://www.informit.com/guides/printerfriendly.aspx?g=cplusplus&amp;seqNum=414
  [10]: http://www.petebecker.com/newlib1.html
  [11]: http://www.petebecker.com/newlib.html
  [12]: http://www.artima.com/cppsource/cpp0x.html
  [13]: http://video.google.com/videoplay?docid=2768126766555555011
  [14]: http://en.wikipedia.org/wiki/C%2B%2B0x
  [15]: http://www.boost.org/

[Herb Sutter](http://herbsutter.wordpress.com)&#39;s blog, He posts new developments in C++0x and links to detailed references

[Bjarne Stroustrup](http://www.research.att.com/~bs/)&#39;s Website


Both are ISO-C++ standards committee members. Herb Sutter will posts an update on each meeting that he attends.

[Working Draft, Standard for Programming
Language C++](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2798.pdf)

Wikipedia article seems like an excellent starting point: [C++0x][1]

  [1]: http://en.wikipedia.org/wiki/C%2B%2B0x

It provides a good summary with brief examples and is updated regularly to match latest additions.

Here are two videos on the subject. They are a bit old, but still very relevant:
New Features in the Next C++ Standard ( http://www.youtube.com/watch?v=ZAG5txfYnW4 ) and [Advanced Topics in Programming Languages Series: C++ Threads][2]

  [2]: http://video.google.com/videoplay?docid=3528799355371049884

There is a ton of stuff on this very site - some of the posts include very informative discussion.  I would point you to Google but it&#39;s going to be more efficient to search in [C++0x tagged posts][1] here imo.  

Here&#39;s [a good one][2] to start with, which includes indirection to [Stroustrup&#39;s own summary][3].  Scott Meyers has presentation materials on the topic [here][4].

Check up on your favourite compiler&#39;s support for the new version.  Microsoft VC10 support is summarized [here][5].  GCC info can be found [here][6].

Official state of the standard for the language is available [here][7].  Evolution of the language is in many places tied to ongoing work in Boost.  See [here][8] for some info on that.

Honestly my preference these days is to look here for 99% of needed info rather than resort to a book.

  [1]: https://stackoverflow.com/questions/tagged/c%2b%2b0x
  [2]: https://stackoverflow.com/questions/3645326/new-version-of-c
  [3]: http://www2.research.att.com/~bs/C++0xFAQ.html
  [4]: http://www.artima.com/shop/overview_of_the_new_cpp
  [5]: http://blogs.msdn.com/b/vcblog/archive/2010/04/06/c-0x-core-language-features-in-vc10-the-table.aspx
  [6]: http://gcc.gnu.org/projects/cxx0x.html
  [7]: http://www.open-std.org/jtc1/sc22/wg21/
  [8]: https://stackoverflow.com/questions/2193605/which-boost-libraries-are-heading-for-tr2

You may refer [Presentation Materials: Overview of the New C++ (C++0x)][1] by Scott Meyers.


  [1]: http://www.artima.com/shop/overview_of_the_new_cpp

I&#39;ve been working for years with VS&#39;s debugger, but every now and then I come across a feature I have never noticed before, and think &quot;Damn! How could I have missed that? It&#39;s **so** useful!&quot;

[Disclaimer: These tips work in VS 2005 on a C# project, no guarantees for older incarnations of VS or other languages] 

### Keep track of object instances ###
Working with multiple instances of a given class? How can you tell them apart?
In pre-garbage collection programming days, it was easy to keep track of references - just look at the memory address. With .NET, you can&#39;t do that - objects can get moved around.
Fortunately, the watches view lets you right-click on a watch and select &#39;Make Object ID&#39;. 

&gt;&gt;![watches view][1] 

This appends a {1#}, {2#} etc. after the instance&#39;s value, effectively giving the instance a unique label. It looks like this: 
&gt;&gt; ![numbered instance][2]

The label is persisted for the lifetime of that object.

### Meaningful values for watched variables ###
By default, a watched variable&#39;s value is it&#39;s type. If you want to see its fields, you have to expand it, and this could take a long time (or even timeout!) if there are many fields or they do something complicated.

However, some predefined types show more meaningful information :

- strings show their actual contents
- lists and dictionaries show their elements count etc.

![meaningful info][3]

Wouldn&#39;t it be nice to have that for my own types? 

Hmm... 

...some quality time with .NET Reflector shows how easily this can be accomplished with the `DebuggerDisplay` attribute on my custom type:

    [System.Diagnostics.DebuggerDisplay(&quot;Employee: &#39;{Name}&#39;&quot;)]
    public class Employee {
        public string Name { get { ... } }
        ...
    }

... re-run, and...

![ta da!][4]

There&#39;s a lot more info on the subject here: [MSDN][5]

### Break on all exceptions ###
... even the ones that are handled in code!
I know, I&#39;m such a n00b for not knowing about this ever since I was born, but here it goes anyway - maybe this will help someone someday:

You can force a debugged process to break into debug mode each time an exception is thrown. Ever went on a bug hunt for hours only to come across a piece of code like this?

    try {
        runStrangeContraption();
    } catch(Exception ex) {
        /* TODO: Will handle this error later */
    }

Catching all exceptions is really handy in these cases.
This can be enabled from *Debug &gt; Exceptions... (Ctrl-Alt-E)*. Tick the boxes in the &#39;Thrown&#39; column for each type of exception you need.

-----

Those were a few forehead-slapping moments for me. 
Would you care to share yours?


  [1]: http://img403.imageshack.us/img403/461/52518188cq3.jpg
  [2]: http://img383.imageshack.us/img383/7351/11732685bl8.jpg
  [3]: http://img205.imageshack.us/img205/4808/37220487md1.jpg
  [4]: http://img60.imageshack.us/img60/926/79816018ha1.jpg
  [5]: http://msdn.microsoft.com/en-us/magazine/cc163974.aspx

Visual Studio debugger tips &amp; tricks for .NET

When Windows Internet Properties -&gt; Connections -&gt; LAN Settings -&gt; Automatic Configuration is set to &quot;Automatically detect settings&quot; how does Windows actually determine/discover what the settings are? Is it a network broadcast or some kind of targeted query to a server configured somewhere in the registry, or something else?

How does Windows actually detect LAN (proxy) settings when using Automatic Configuration

I would like to learn more about C++0x. What are some good references and resources? Has anyone written a good book on the subject yet?

Where can I learn more about C++0x?

<p>I would like to learn more about C++0x. What are some good references and resources? Has anyone written a good book on the subject yet?</p>


Suppose we have some named enums:

    enum MyEnum {
          FOO,
          BAR = 0x50
    };

What I googled for is a script (any language) that scans all the headers in my project and generates a header with one function per enum.

    char* enum_to_string(MyEnum t);

And a implementation with something like this:

    char* enum_to_string(MyEnum t){
          switch(t){
             case FOO:
                return &quot;FOO&quot;;
             case BAR:
                return &quot;BAR&quot;;
             default:
                return &quot;INVALID ENUM&quot;;
          }
     }

The gotcha is really with typedefed enums, and unnamed C style enums. Does anybody know something for this?

EDIT: The solution should not modify my source, except for the generated functions. The enums are in an API, so using the solutions proposed until now is just not an option.

Is there a simple way to convert C++ enum to string?

How do I concatenate two `std::vector`s?


Concatenating two std::vectors

I am coding a program that reads data directly from user input and was wondering how could I (without loops) read all data until EOF from standard input. I was considering using `cin.get( input, &#39;\0&#39; )` but `&#39;\0&#39;` is not really the EOF character, that just reads until EOF or `&#39;\0&#39;`, whichever comes first.

Or is using loops the only way to do it? If so, what is the best way?


How to read until EOF from cin in C++

I&#39;ve been getting this undefined symbol building with this command line:

    $ gcc test.cpp
    Undefined symbols:
      &quot;___gxx_personality_v0&quot;, referenced from:
      etc...

test.cpp is simple and should build fine.  What is the deal?

Undefined Symbol ___gxx_personality_v0 on link

The [C++ friend keyword][1] allows a `class A` to designate `class B` as its friend.  This allows `Class B` to access the `private`/`protected` members of `class A`.

I&#39;ve never read anything as to why this was left out of C# (and VB.NET). Most answers to this [earlier StackOverflow question](https://stackoverflow.com/questions/17434/when-should-you-use-friend-in-c) seem to be saying it is a useful part of C++ and there are good reasons to use it.  In my experience I&#39;d have to agree.

Another [question](https://stackoverflow.com/questions/200079/inheritance-trees-and-protected-constructors-in-c#200117) seems to me to be really asking how to do something similar to `friend` in a C# application.  While the answers generally revolve around nested classes, it doesn&#39;t seem quite as elegant as using the `friend` keyword.

The original [Design Patterns book](http://www.amazon.com/Design-Patterns-Object-Oriented-Addison-Wesley-Professional/dp/0201633612) uses it regularly throughout its examples.

So in summary, why is `friend` missing from C#, and what is the &quot;best practice&quot; way (or ways) of simulating it in C#?

(By the way, the `internal` keyword is *not* the same thing, it allows *all* classes within the entire assembly to access `internal` members, while `friend` allows you to give a certain class *complete access* to *exactly one* other class)


  [1]: http://www.cplusplus.com/doc/tutorial/inheritance/

Why does C# not provide the C++ style &#39;friend&#39; keyword?

[C++11](http://en.wikipedia.org/wiki/C%2B%2B11) introduces [user-defined literals](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2378.pdf) which will allow the introduction of new literal syntax based on existing literals (`int`, `hex`, `string`, `float`) so that any type will be able to have a literal presentation.

**Examples:**

    // imaginary numbers
    std::complex&lt;long double&gt; operator &quot;&quot; _i(long double d) // cooked form
    { 
        return std::complex&lt;long double&gt;(0, d); 
    }
    auto val = 3.14_i; // val = complex&lt;long double&gt;(0, 3.14)

    // binary values
    int operator &quot;&quot; _B(const char*); // raw form
    int answer = 101010_B; // answer = 42

    // std::string
    std::string operator &quot;&quot; _s(const char* str, size_t /*length*/) 
    { 
        return std::string(str); 
    }

    auto hi = &quot;hello&quot;_s + &quot; world&quot;; // + works, &quot;hello&quot;_s is a string not a pointer
  
    // units
    assert(1_kg == 2.2_lb); // give or take 0.00462262 pounds

At first glance this looks very cool but I&#39;m wondering how applicable it really is, when I tried to think of having the suffixes `_AD` and `_BC` create dates I found that it&#39;s problematic due to operator order. `1974/01/06_AD` would first evaluate `1974/01` (as plain `int`s) and only later the `06_AD` (to say nothing of August and September having to be written without the `0` for octal reasons). This can be worked around by having the syntax be `1974-1/6_AD` so that the operator evaluation order works but it&#39;s clunky. 

So what my question boils down to is this, do you feel this feature will justify itself? What other literals would you like to define that will make your C++ code more readable?

----
Updated syntax to fit the final draft on June 2011

What new capabilities do user-defined literals add to C++?

Consider the case of a templated function with variadic template arguments:

    template&lt;typename Tret, typename... T&gt; Tret func(const T&amp;... t);

Now, I have a tuple `t` of values. How do I call `func()` using the tuple values as arguments?
I&#39;ve read about the `bind()` function object, with `call()` function, and also the `apply()` function in different some now-obsolete documents. The GNU GCC 4.4 implementation seems to have a `call()` function in the `bind()` class, but there is very little documentation on the subject.

Some people suggest hand-written recursive hacks, but the true value of variadic template arguments is to be able to use them in cases like above.

Does anyone have a solution to is, or hint on where to read about it?

How do I expand a tuple into variadic template function&#39;s arguments?

For example the [c++0x interfaces][1]

I am having a hard time figuring out when to use which of these things (cv, mutex and lock).
Can anyone please explain or point to a resource?

Thanks in advance.

  [1]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2320.html

Differences between Conditional variables, Mutexes and Locks

for example:

    Beta_ab&amp;&amp;
    Beta::toAB() const {
    	return move(Beta_ab(1, 1));
    }



Is returning by rvalue reference more efficient?

How can I iterate over a tuple (using C++11)? I tried the following:

    for(int i=0; i&lt;std::tuple_size&lt;T...&gt;::value; ++i) 
      std::get&lt;i&gt;(my_tuple).do_sth();

but this doesn&#39;t work:

&gt; Error 1: sorry, unimplemented: cannot expand ‘Listener ...’ into a fixed-length argument list.  
&gt; Error 2: i cannot appear in a constant expression.

So, how do I correctly iterate over the elements of a tuple?

Content Type	Original Author	Original Content on Stackoverflow
Question	yesraaj	View Question on Stackoverflow
Solution 1 - C++	Ozgur Ozcitak	View Answer on Stackoverflow
Solution 2 - C++	yesraaj	View Answer on Stackoverflow
Solution 3 - C++	TG.	View Answer on Stackoverflow
Solution 4 - C++	Suma	View Answer on Stackoverflow
Solution 5 - C++	gnobal	View Answer on Stackoverflow
Solution 6 - C++	Steve Townsend	View Answer on Stackoverflow
Solution 7 - C++	bhadra	View Answer on Stackoverflow

Where can I learn more about C++0x?

C++ Problem Overview

C++ Solutions

Solution 1 - C++

Solution 2 - C++

Articles on

General Discussion

Videos

overview of various features

Library

Solution 3 - C++

Solution 4 - C++

Solution 5 - C++

Solution 6 - C++

Solution 7 - C++

How does Windows actually detect LAN (proxy) settings when using Automatic Configuration

Visual Studio debugger tips & tricks for .NET

Attributions