Ruminations on C++11

// Preface
// This is a blog about the new version of C++, C++11. It has been many years in the
// making and adds lots of new features to the C++ language. Some of those features
// are already supported by commonly used compilers, a description of these features
// follows.
// As you can see, this 'blog' is a bit unusual. It's actually a C++ source code file
// annotated with lots of comments. So it can be read on its own, with the code being
// examples of the things being described, or it can be viewed in Visual Studio (VS)
// 2010, built and even executed. With a few minor adjustments pointed out along the
// way, it can also be built using GCC and executed on whatever system that it is
// installed on.

// Ignore these, I couldn't think of anywhere else to put them.
#include "stdafx.h"
#include <vector>
#include <algorithm>
#include <map>
#include <iostream>
// Ruminations on C++11 (the bits currently supported anyway).
// Of the many new features of C++11, only a subset are available on stable releases of
// the well-used contemporary C++ compilers. I thought that it would be a good exercise
// in understanding these new features to try them out. I decided that I'd try VS2010 on
// Windows 7 and GCC on Ubuntu, as these are easy for me to access and a reasonable
// approximation of other developers environments.
// The main differences being there is no support for nullptr in GCC, and no support for
// initialiser lists in VS2010. Of these, the initialiser lists seem the most useful feature, I hope it gets into VS soon.
// The features described here are:
//     * static_assert
//     * trailing return types
//     * constructors calling other constructors in the same class
//     * lambda functions
//     * initialiser lists
//     * a fix for the 'std::map< int, std::vector<int>>' '>>' problem
//     * 'auto' variable declarations
//     * 'decltype' variable declarations
//     * rvalue references, move constructors and perfect forwarding
//     * nullptr, improved typing for the null pointer value
// I have annotated some C++11 code that shows the new features, this code does not fully
// comply with our coding standards in order for the descriptions to be clearer. This
// blog contains code that compiles with VS2010, the GCC supported C++11 features are
// provided in the comments.
// 1. static_assert
// First we have an example of 'static_assert', these are compile time assertions. In
// this case, a check is made to ensure that the size of the type used to instantiate the
// object is sufficient. This check occurs at compile time, so the supplied error message
// is displayed as a compile error if the condition is false.
template<class T>
class TemplateTest
    // if the size of the type used to instantiate an object is too small, a compile
    // time error is produced.
   static_assert( sizeof(T) > 1, "sizeof(T) not > 1!" );
   T m_test;
// 2. Trailing return type declarations
// Next up, an example of trailing return types on method declarations.
// If we have a class that defines an enumeration (very handy for code clarity).
class MyEnumClass
    enum MyHelpfulEnum
    MyEnumClass( MyHelpfulEnum initialValue );
    // We can declare the method like this, with a trailing return type,
    static auto KeepCodeClear() -> MyHelpfulEnum;
    // or like this, it makes no difference to the compiler.
    //static MyHelpfulEnum KeepCodeClear();
    // But I think it is helpful to keep things consistent.
// The advantage of this feature comes when declaring the method implementation, as this
// method returns an enumeration defined within the class. Previously you'd have to
// declare the method decorated with lots of scope to help the compiler know what was
// going on (it has enough to contend with without having to deal with this kind of
// thing). Like so,
//MyEnumClass::MyHelpfulEnum MyEnumClass::KeepCodeClear()
// But now you can declare the method like this.
auto MyEnumClass::KeepCodeClear() -> MyHelpfulEnum
// The '->' is a little different, but less repetition is involved (sort of).
    // we'll see more from 'auto' later (why keep a keyword for one use when it can
    // have three!?)
    return Usually;
// 3. One constructor calling another
// Here we have an example of one constructor calling another, I found it annoying that
// this was missing from C++ in the past.
    // this constructor can call another constructor.
    MyEnumClass( Helps );
MyEnumClass::MyEnumClass( MyHelpfulEnum initialValue )
// Here are some function prototypes for the nullptr description (something to look
// forward to).
void NullPointerCall( int notAPointerParameter );
void NullPointerCall( int* aPointerParameter );
// 4. Lambda functions
int _tmain(int argc, _TCHAR* argv


    // Next we have an example of a lambda function (familiar to C# developers). I
    // have to admit I'm not a fan of these; if it's a function make it one, at least
    // it can be called from other places then. Now I've got that rant out of the way
    // we can continue!
    // If we have a list of interest:
    std::vector<int> anInterestingList;
    // And that list has some elements, in GCC we can use initialiser lists, like
    // so...
    //std::vector<int> anInterestingList{1,2,3,4}; // so much nicer.
    // But for VS we cannot, so add some elements the old fashioned way.
    anInterestingList.push_back( 1 );
    anInterestingList.push_back( 2 ); // boo
    anInterestingList.push_back( 3 );
    anInterestingList.push_back( 4 ); // hiss
    // Declare an accumulator for our demonstration.
    int accumulator( 0 );
    // From time to time, it is necessary to loop through all the elements in a list
    // (not all that often, but it does happen).
    std::for_each( anInterestingList.begin(), anInterestingList.end(),
    // Below is the lambda function, the start is defined by '[', the ampersand
    // defines the capture list (the variables accessible by the lambda function),
    // if the capture list is empty, i.e. there is only '&', all variables in scope
    // are available. It seems like good practice to explicitly state what is
    // accessible rather than implying everything. If no '&' appears, i.e '[]' is
    // used, no variables are captured. There is also, like any other function a
    // parameter list.
                   [&accumulator](int element){ accumulator += element; } );
                   // the lambda function, accumulates the values in the list.
    std::cout << "Accumulator = " << accumulator << std::endl;
    // 5. '>>' in variable declarations
    // The next feature is more of a fix than anything else. Allowing '>>' in
    // declarations. Of course you could always get around this problem by sub
    // classing, (or even using typedef, but that's not very OO is it?) but if you did
    // do this the error message was, well, ...confusing (I'll leave it at that before
    // I say something I shouldn't).
    std::map< int, std::vector<int>> lookItWorks;
    // It's better to subclass if you can though. This is not a C++11 feature, but I
    // rarely see it in C++ and it seems so obviously OO.
    class AListOfInts : public std::vector<int>{};
    class AMapOfIntvsInts : public std::map< int, AListOfInts>{};
    // Of course if you wish to use the constructors of the base classes this method
    // is annoying. If only there was a way...
    AMapOfIntvsInts anAsideToProceedings;
    // Well C++11 allows the use of 'using' to use base class constructors in derived
    // classes, which helps this 'problem'. If they were implemented by VS or GCC
    // I'd add an example.
    // 6. 'auto' types for variable declarations
    // This very simple extract of code shows another new use of the auto keyword.
    // Here you let the compiler automatically deduce the type.
    auto autotest( anInterestingList.begin() );
    // 7. 'decltype' types for variable declarations
    // Similar to the 'auto' type deduction feature above, this time declaring a type
    // that is the same as another type.
    decltype(autotest) decltypetest(autotest);
    // declare decltypetest as the same type as autotest.
    std::cout << "*autotest = " << *autotest << std::endl;
    std::cout << "*decltypetest = " << *decltypetest << std::endl;
    // 8. rvalue references
    // As you can only assign lvalues (like variables, objects and other references)
    // to references, C++11 introduces rvalue references for the others (like
    // temporaries and literals). I'm not going to get into the details here as
    // those subjects require whole documents to themselves. So you can have:
    int aValue( 9 );
    int& myPreferenceIsAReference( aValue );
    int& alsoReferingToAValue( myPreferenceIsAReference );
    // But you can't have:
    // MyEnumClass::MyHelpfulEnum& isTheCodeClear( MyEnumClass::KeepCodeClear() );
    // as the return from MyEnumClass::KeepCodeClear() is a temporary variable.
    // In C++11 using rvalue references you can:
    MyEnumClass::MyHelpfulEnum&& isTheCodeClear( MyEnumClass::KeepCodeClear() );
    if ( isTheCodeClear == MyEnumClass::Usually )
        std::cout << "isTheCodeClear == MyEnumClass::Usually, must do better!"
                  << std::endl;
    // You can also do things that seem very strange.
    int&& rValueRef = 2;
    // assign the rvalue reference to a reference to an rvalue, in this case the
    // literal number 2.
    // Has this blown your mind? We have incremented 2! Surely all that we know and
    // love is doomed. It's ok though, as rValueRef is assigned a reference to a
    // temporary variable, this is saving time rather than creating a temporary
    // and then copying it to a variable.
    std::cout << "rValueRef referencing the literal number 2 = "
              << rValueRef << " OMG!" << std::endl;
    // These two examples show that less copying of values is attained by using rvalue
    // references. The C++11 standard libraries and STL have been written to take
    // advantage of this to improve performance without requiring users of these
    // libraries to do anything different (apparently). There's lots of talk about
    // 'move semantics' and 'perfect forwarding' which is nice if you like that kind
    // of thing, these subjects require blogs of their own.
    // In summary, they allow less copying, making copy constructors and equals
    // operators more efficient. This in turn helps developers to write logical
    // code that is far less likely to cause performance issues.
    // 1. (again) static_assert
    // static_assert (for compile time assertions). This time we are using the
    // static_assert feature to check the sanity of a constant value against another
    // constant. This is especially useful to stop people changing constants to
    // erroneous values.
    const int someConfigValue = 1;
    const int someConfigValueCheck = 2;
    // As before in the template example, if the condition is false the compiler
    // outputs the error text supplied.
    static_assert( someConfigValue < someConfigValueCheck,
                   "someConfigValue is not less than someConfigValueCheck!" );
    TemplateTest<int> inttest;
    // This is fine, an int passes the static_cast in TemplateTest.
    // TemplateTest<bool> booltest;
    // This generates a compile time error due to the static cast in the template
    // class defined above.
    // 9. nullptr
    // nullptr is more strongly typed than 0 or NULL, which helps make things clearer.
    // nullptr is not available on GCC at the time of writing so comment out the rest
    // of this example to compile with GCC.
    int* nullptrtest( nullptr );
    if ( nullptrtest == nullptr )
        // the pointer is null.
        std::cout << "The nullptrtest null pointer is set to nullptr."
                  << std::endl;
    // If we don't use nullptr, which function is called for our old null pointer
    // values?
    NullPointerCall( 0 );
    NullPointerCall( NULL );
    // If we use nullptr instead things are clearer.
    NullPointerCall( nullptr );
    // 10. initialiser lists
    // This is supported by GCC, but not VS, so I've commented it out. Obviously
    // initialiser lists can also be used to pass data to methods. I think this is one
    // of the more useful features of C++11, if only for reasons of clarity.
    //std::map< int, int> myuselessnumbermap{ { 1,1 }, { 2, 2 } };
    // There are many other C++11 features that haven't made it into stable versions
    // of either VS or GCC, but now that the standard has been ratified I expect they
    // will soon follow. Better enum support, in-class member variable initialisation,
    // override control and thread support like thread local storage are all useful
    // features, there are many more new features that future compilers will support.
    // See for a description of these
    // and the unimplemented C++11 features (aka C++0x, they must've been a bit late).
    return 0;
    // Literals in code!! Just this one time I'll let myself off (anyway, I've broken
    // most of our other coding standards along the way).
// These are the implementations of the nullptr description function calls.
void NullPointerCall( int notAPointerParameter )
    std::cout << "So you'd like me to process your integer?" << std::endl;
void NullPointerCall( int* aPointerParameter )
    std::cout << "So you'd like me to process your pointer?" << std::endl;