As quoted by Stroustrup “C enumerations constitute a curiously half-baked concept” and very few modifications are done to rectify there shortfalls resulting in manifestation of silent behavioral changes. Let's check an example to support this,

I bet the validation in above case will not be true as enumMyInterval will never be treated as unsigned int (4294967295) and will be -1. And there is no way to make INTERVAL_4 point to unsigned int as it will default to int.

Keeping all these in mind, in C++11, we got what is called enum class - A Strongly typed enum.NOTE : VS2010 do not support this feature... hope they will support in VS2011.

Let us quickly glance the new syntax:

1. With C++11, the enumerators are no longer exported to surrounding scope and requires scope identifer

To handle certain scenarios the c++ compilers silently create at times temporaries that can serioulsy hit the performance of the code. With evolution of compilers, few of these temporary creations are arrested but many more slipped leading to relativley in-efficent programs. Let's see what I am saying:

If we analyze this code, GetNDimensionalVector( ) method created a vector say of 10 doubles which will require 10*sizeof(double) bytes. Now while returning a compiler (prior to VS03 for example) will again create a copy. However recent compilers fixed this hole (via Return value optimization - aka RVO). Now the call to GetNDimensionalVector( ) will copy all its content again to vecNewMatrix (upon which further operations are done) and the result of GetNDimensionalVector( ) call is evaporated as after ; as this is temporary. What a pitty!, we are wasting a lot of memory chunks instead of just pilfering the data inside the temporary vector into vecNewMatrix.

A smart language should allow this. And this is exactly what they have provided us through Rvalue reference.

The '&&' is the token identifies the reference as an "rvalue reference" and distinguishes it from the current (lvalue) reference '&'.

The implementation of move semantics significantly increases the performance as the resorurces of temporary object( that cannot be referenced elsewhere in the program as it is going to evaporate) can be pilfered instead of copying.To get better understanding take the case when a vector needs more capacity and if no continuos memory is available. Then it will identify a memory location which is large enough to hold its old contents plus required (new) capacity. It will then copy all the old contents to this new location. Now this call to copy construcutor is expensive if the contents are a 'string' or a heavy-duty class/structure. The pitty here is that all the old location contents will be evaporated. How nice it would be if this operation involves just stealing the old contents instead of copying.

Hope you got what I say.

Please note that - The copy operation leaves the source unchanged while a move operation on the other hand leaves the source either unchanged or it may be radically different. Now if a developer chooses Move operation upon an object, then he should no more care about the state of the source object [he should keep in mind that the source object's state is disturbed and is not more useful]. If his intention is still to use source along with duplicate then he should be doing copying (as is done till now) and not move.

The comments in the sample code above are pretty much self explanatory. Just note that for Move constructor and assigment operator we took the argument without const, as we intent to modify them (we want to set them to default once we moved their content to target)There are many more points that need to be grasped in this feature but those are out-of-scope on this introductory part. I will just cover one more scenario and wind up this section.

In the above example, MyFileStream class have default member types. What if the members are of some other class type say like MyString.

Perfect forwarding:Another nice effect of Rvalue implementation is the solution to the Forwarding problem.Before going any further,lets grasp this forwarding problem. Suppose we have two structures handling Licence operations one OpenLicence and another ClosedLicence and say suppose if we want to do some master check before creating the object for either these structures, then we can use a wrapper template function where we can do this master check and then simply pass (forward) the arguments to the stuctures.

Now what if the first argument is an Rvalue ( Licence_Wrapper( 007, key2 ) ) or what if both are Rvalues ( Licence_Wrapper( 006, 007 ); ) To handle these we should have that many overloads. More number of arguments leads to more number of overloads. Our code will be pumped with overloads to handle all these ..... Welcome to the forwarding problem.Rvalue refrences just solve this in one stroke

That's it. No more overloads needed any where. This is called PERFECT FORWARDING. Really perfect, isn't it. There are many more to discuss in this topic, but again as this in introductory article I won't cover them here.

long long is a 64-bit integer type. Previous to C++11, the largest interger type is long and it's size is platform (32 or 64) dependent. But this long long guarantees to be atleast 64-bit long. Actually this concept is accepted in C++99 and as many compilers already supported it, the C++11 committee gave a thumbs up for this new integral type.

Say suppose we have a base class with a virtual function. In any of it's derived classes this function can be overrided and no special keyword or annotation is needed upon this function to do so. To put more clarity and to say that we are overriding a base class function, C++11 introduced a new keyword called override. A declaration marked 'override' is only valid if there is a function to override. This feature is shipped into VS2010. Let's see an example,

One little remark. Usefulness of rvalue references when returning big object is very often hidden by (named) return value optimization which is done by all modern compilers. Move constructors really shine in cases such as growth of containers - for instance when a vector reaches its capacity it needs to reallocate all memory and copy existing objects before adding any additional elements. With move constructors, all this copying becomes moving and that can be a huge performance win.

1) In your first article, at the bottom of it, you mentioned "As the standard is freezed just 3 months ago, there are no books describing the new features....". If I don't wrong remember there were two books that partially talk about the new standard, maybe at introductory level:
1.1) "C++ How to Program, 8ed, 2011, Deitel, Prentice Hall"
1.2) "Beginning Visual C++ 2010, 2010, Ivor Horton, Wiley Publishing"

2) I understood what you said about the "override" keyword. However, in my knowledge and before reading your article when you redefine the signature of a function (no virtual ones) in a derived class from a base class, your SomeFunction(), you have actually overridden the Base::SomeFunction() function and it will no be visible to clients of Object's Derived class. At this point I don't understand why the need for the keyword "override" for virtual functions (in a derived class) and not for redefined normal functions (in a derived class too), if the need was to make clear code.

"Regarding 1st point : Thanks. I should correct my statement then"
No problem, it was just to let you know that, some sort of sharing knowledge. But as I said I don't remember for sure.

"Regarding 2nd point : Sorry I can not follow your point, if possible please simplify"

Ok, let's take your example of Base and Derived classes and let's put aside the virtual functions for a while.
SomeFunction() is declared in both classes, Base and Derived. Derived derives from Base a redefines the method SomeFunction(), the two functions have the same signature. Clients of Derive class can use the Derive::SomeFunction() function but they never be able to use the Base::SomeFunction() function from a Derive class object. This because the Derive::SomeFunction(), having the same signature, overrides the Base::SomeFunction(). The virtual functions are a slightly different concept.

Now, what I have understood from your article is that the standard introduced the concept of Override Control "To put more clarity and to say that we are overriding a base class function". That in the case of virtual function. So when I see a declaration like this void Draw() override {} in the Derive class declaration I know that Draw() are going to override the the virtual Draw() function in the Base class, indeed they have the same signature (the methods).

Now comes my point:
introducing the override keyword to make code more clear for the programmer on a first sight could be very useful, so I know the method is overriding the the same virtual method in the base class. But what about Somefunction() in the Derive class? it is overriding the same method in the Base class and I'm not going to be able to use the Base::SomeFunction() method anymore. This is also an overriding concept. That could be done for purpose or just because the programmer forgot that there is a Base::SomeFunction() method (imagine big classes there). So, wasn't useful to add the same keyword "override" for Derive::SomeFunction() method? so the programmer could see, on a first sight, that Derive::SomeFunction() overrides the same method from the base class.
( Obviously we are talking about overriding and not overloading. )
Am I wrong?

Hmmm...
I did most of my coding in C++, where Uppercase convention is predominant. Here rather than casing multiple words, we use '_' to seprate them. Like S_OK, E_UNEXPECTED etc.
However I started liking CamelCase too.

I really liked this, and the amusing start is a great idea to get the reader's attention. My other comments:

There are quite a few spelling and grammar errors which could be tidied up (even though I still understood what you were saying).

You refer to items being available in VS2010 or VS2011, whereas availability is down to the version of the compiler, which can be used independently of Visual Studio. I think compiler versions would be clearer and a comment as to which version of Visual Studio the compiler is auto shipped with.

In the section on the Move Assignment operator you have the following code sequence:

Reg 1st comment : I am in a weekend mood and want to publish this part before I go for weekend. And more over I am still struggling with Codeproject formatting style. For instance while typing templates with <> tags I am getting strange results in preview!!!
Any way no excuses I will try to do better for the coming articles.

Reg 2nd comment : YES what you said is appropriate and will update in that manner at the earliest.

Reg 3rd comment : It is copy/paste mistake, which I have corrected right away.

Corrected.
My intention is also to mention about 'delete' keyword (which stops from overriding a function - this is not shipped in VS2010 - Hope I got correct for this). But I mixed up while formatting the article. I will try to update this section with an example.