See part 1: Name Lookup
See part 2: Template Argument Deduction
See part 3: Overload Resolution
See part 4: Virtual Functions
See part 5: Explicit and Partial Specialization
See part 6: New C++11 features added to the Visual C++ 2012 compiler (CTP)

This compiler is now available as a Customer Technology Preview release to everyone. If you want to test-drive this new compiler too, download it from here: http://aka.ms/vc-ctp. More details on this release are available on Visual C++ Blog (http://blogs.msdn.com/vcblog/).

Make sure to watch Herb Sutter's C++ keynote at BUILD 2012.

See part 1: Name Lookup
See part 2: Template Argument Deduction
See part 3: Overload Resolution
See part 4: Virtual Functions
See part 5: Explicit and Partial Specialization

From MSDN ->

Class templates can be specialized for specific types or values of the template arguments. Specialization allows template code to be customized for a specific argument type or value. Without specialization, the same code is generated for each type used in a template instantiation. In a specialization, when the specific types are used, the definition for the specialization is used instead of the original template definition. A specialization has the same name as the template of which it is a specialization. However, a template specialization can be different in many ways from the original template. For example, it can have different data members and member functions.

Use specialization to customize a template for a specific type or value. Use partial specialization when the template has more than one template argument and you only need to specialize one of them, or when you want to specialize behavior for an entire set of types, such as all pointer types, reference types, or array types.

// explicit_specialization1.cpp
// compile with: /EHsc
#include <iostream>
using namespace std;

// Template class declaration and definition
template <class T> class Formatter
{
   T* m_t;
public:
   Formatter(T* t) : m_t(t) { }
   void print()
   {
      cout << *m_t << endl;
   }
};

// Specialization of template class for type char*
template<> class Formatter<char*>
{
   char** m_t;
public:
   Formatter(char** t) : m_t(t) { }
   void print()
   {
      cout << "Char value: " << **m_t << endl;
   }
};

int main()
{
   int i = 157;
   // Use the generic template with int as the argument.
   Formatter<int>* formatter1 = new Formatter<int>(&i);

   char str[10] = "string1";
   char* str1 = str;
   // Use the specialized template.
   Formatter<char*>* formatter2 = new Formatter<char*>(&str1);

   formatter1->print();
   formatter2->print();
}

See part 1: Name Lookup
See part 2: Template Argument Deduction
See part 3: Overload Resolution
See part 4: Virtual Functions

This was filmed at GOTO Aarhus 2012, an excellent developer event. Huge thanks to Lars and Steve for the excellent conversation and to the folks at GOTO for providing a room for me for all these interviews (and lights, too!).

From Scott's recently published article in the October 2012 edition of ACCU's Overload:

Given that rvalue references are declared using "&&", it seems reasonable to assume that the presence of "&&" in a type declaration indicates an rvalue reference. That is not the case:

Widget&& var1 = someWidget; // here, "&&" means rvalue reference

auto&& var2 = var1; // here, "&&" does not mean rvalue reference

template<typename T>

void f(std::vector<T>&& param); // here, "&&" means rvalue reference

template<typename T>

void f(T&& param); // here, "&&" does not mean rvalue reference

In this article, I describe the two meanings of "&&" in type declarations, explain how to tell them apart, and introduce new terminology that makes it possible to unambiguously communicate which meaning of "&&" is intended. Distinguishing the different meanings is important, because if you think "rvalue reference" whenever you see "&&" in a type declaration, you'll misread a lot of C++11 code.

Tune in. Scott's an incredible presenter and it's well worth your time to both read his article and watch his presentation on the subject. Great stuff!

Download slides

So, go get this free Windows 8 app, make some art (mix different oil colors, zoom in, check out the realistic fluid dynamical effects). Then, come back and learn about what's going on inside of Fresh Paint and meet the developers who wrote it.

[00:00] GoingNative(); //Very quick ctor this month.
[01:34] Charles interviews the Fresh Paint development team
[40:04] ~GoingNative(); // Meet the new Visual C++ Community PM, Eric Battalio!!

Tune in. Learn.

See part 1: Name Lookup
See part 2: Template Argument Deduction
See part 3: Overload Resolution
See part 5: Explicit and Partial Specialization

As STL says: "I walk through why foo(const T&) beats foo(const T *), when given int *. The reason is surprisingly subtle."

Tune in.

These Windows-specific talks will use both portable ISO C++ and Visual C++-specific compiler extensions; for brevity below we'll refer to both as "C++" (i.e., this day is about Visual C++, not Visual C# or JavaScript).

We will have pragmatic advice for every developer writing Metro style apps and games with XAML and/or DirectX and C++.

This event is sold out.  However, it will stream live right here on Channel 9! Tune in on May 18, 2012, 8:00AM PDT.

Agenda:

• VC++ for Windows 8, Keynote by Herb Sutter
• Building Windows 8 apps with XAML and C++
• Building Windows 8 games with DirectX and C++
• Introduction to the Windows Runtime Library  (WRL)
• Writing Connected apps: Writing networking code with C++
• Combining XAML & DirectX in a Metro style apps
• Writing WinRT components to be consumed from any language
• VC11 compiler flags for getting the most out of C++

Get the latest PPL to experiment with writing asynchronous code for "Windows 8" Metro style applications. Don't forget to provide feedback to the PPL team! They want to hear from you, so please write some code and see if you find this comfortable/useful/etc.

See the BUILD sessions on WinRT to get more information about asynchrony in "Windows 8."

We proudly present Herb Sutter's opening presentation at C++ and Beyond 2011. Thanks to Herb, Scott, and Andrei for allowing C9 to film this and air it

Here, Herb Sutter answers the question "Why C++?" in his usual thoughtful and well-articulated manner. He shares his perspectives on C++11 (yes, the name of the next version of C++ is officially official now!) and the C++ Renaissance as well as why C++ still matters and will continue to matter far into the future. This is a great introduction to the current state of the language, including a glimpse into the future of general purpose, performance-intensive, power-friendly, powerful native programming. As Herb says, C++ has legs and will continue to enable us to run fast into the future.

Download the slides for this presenation

Tune in. Go native!

As usual, this Erik-led conversation involves several forays into technical areas and we jump head first into a few rabbit holes (like managed "versus" native (versus in quotes to emphasize that it's not some sort of duel...). Erik is a managed guy, after all). Lots of great geeky goodness here. So, Erik sends Rick to the whiteboard and Rick teaches Erik some modern C++ and provides some insights into his coding behavior/patterns (which is a key part of Checking In, remember?). We also sort of learn about what Rick's up to these days (secrets, secrets...).

Tune in. Enjoy. Thanks for spending time with us, Rick!

GoingNative is a new show on C9 dedicated to native development and native developers, with an emphasis on modern C++. In our inaugural episode, we keep things light and easy as we introduce you to what we're doing, why we're doing it, and how it will go down. The most important thing to realize right off the bat is that we want you to join us in the cockpit and help us fly this plane.

The main goal of episode 0 is to introduce the cast of characters, including your hosts Charles and Diego, and to present some ideas of how we think this show will be organized and executed. For example, Diego Dagum and I will typically construct the show, iterate through some code demos of varying complexity, converse with native developers from Microsoft and across the industry, and then destruct the show. We're not sure if we should add a news component—you tell us. We're not sure how much rambling you want hear from me and Diego—you tell us. And we're not sure how advanced we should make the programming section—you tell us (do we provide both intro and advanced topics?).

Now, of course this first episode isn't just a "Hey, we have a new show. Yay! Tell us what you want for next time" type of affair! We do talk about and demo a few new C++ features (shared_ptr, lambdas, auto) and have a conversation with Ale Contenti - development manager of VC's front-end compiler, libraries, and IDE.

[You can play around with the demos in this episode by downloading the free VC++ Express IDE]

Table of Contents(click time code links to navigate player accordingly)

[00:09]Charles and Diego construct the show and talk about modern C++ (how 'bout that set, eh?)
[07:27]Diego demos shared_ptr (Please see STL's incredible C9 lecture on shared_ptr for much more detail)
[10:01]Charles and Diego chat briefly about C++ lambdas
[10:32]Diego demos lambdas
[12:13]Charles and Diego chat briefly about C++ auto keyword (seen in the lambdas demo)
[13:30]Charles and Diego talk about the audience and how you can help us fly this plane
[15:32]Charles interviews Ale Contenti
[26:35]Charles and Diego destruct the show ( it won't usually take this long )

We really want to hear from you, so please tweet feedback to @C9GoingNative (follow us!) and send your requests, ideas, complaints, praises, hate mail, and love letters to C9GoingNative@hotmail.com. We will read and respond to all messages! That's how we roll, brothers and sisters. If you are a Facebook user (who isn't these days?), then please join our C9::GoingNative Facebook group.

Go native!