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

{

public:

    enum MyHelpfulEnum

    {

        An,

        Enumeration,

        That,

        Usually,

        Helps,

        To,

        Clarify,

        Code

    };

    MyEnumClass();

    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.

MyEnumClass::MyEnumClass()

{

    // 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.

    ++rValueRef;

    // 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 http://www2.research.att.com/~bs/C++0xFAQ.html 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;

}

Speak Your Mind

Tell us what you're thinking...
and oh, if you want a pic to show with your comment, go get a gravatar!

You must be logged in to post a comment.