The more redeeming features of C++11

C++11 is the now ratified and gradually being implemented C++ standard that finally solidifed last year after far far too many years in design. The process by which C++11 was finally settled on leaves me thinking that the people on the committee are far, far too divorced from day-to-day C++ usage and the needs of the average software developer. I’m not talking about what they finally gave us, but how they reached the decision on what would be included, how it would be phrased, and so forth.

Some of the features, especially lambdas, are going to be a real pain in the ass when they begin being commonly deployed, introducing write-once-scratch-head-forever crap into the language, and half-assed fixing solutions with copious obfuscation for lesser issues of the same source problem (virtual ‘override’).

But somehow, someway, somefolks got some good stuff into C++11 that I think I will personally benefit from.


While I may not be happy about the word itself, the “auto” feature is very nice.

// Before
typedef std::map< std::string, std::set<std::string> > StringSetMap ;
StringSetMap ssm ;
for ( StringSetMap::iterator it = ssm.begin() ; it != ssm.end() ; ++it )

// After
std::map< std::string, std::set<std::string> > ssm ;
for ( auto it = ssm.begin() ; it != ssm.end() ; ++it )

// Before
Host::Player::State* playerState = (Host::Player::State*)calloc(1, sizeof(Host::Player::State)) ;

// After
auto playerState = (Host::Player::State*)calloc(1, sizeof(Host::Player::State)) ;

range-based for

One of the big concerns of the C++ standards committee was breaking pre-existing code. As a result, awful choices like naming auto “auto” were made. range-based for is another case of “I’d rather teach people visual basic than explain C++11 range-based for to them”, but in practice it’s really nice:

// Before

std::map<unsigned int, std::string> myMap ;
// ...
for ( std::map<unsigned int, std::string>::iterator it = myMap.begin() ; it != myMap.end() ; ++it )
const unsigned int i = it->first ;
  const std::string& str = it->second ;
// ...

// After

std::vector<unsigned int> myUints ;
// ...
for ( auto it : myUints )
const unsigned int i = it.first ;
  const std::string& str = it.second ;
  // ...

One thing I’m not clear on, with range-based-for is whether it copes with iterator validity, e.g. what happens (yeah, I know, I could try it, duh) if you do

for ( auto it : myMap )
if ( it.first == 0 )
myMap.erase(it) ;

extended enum definitions

In the beginning, there were names. And the Stroustrop said, Let there be name spaces, that separate the code from the library. And he named the standard library “std::” and the rest “::”. And it was about bloody time.

Unfortunately, “enum”s slipped thru the cracks. In C and C++ I find to enums be something of a red-headed stepchild, lacking a few really, really important features that programmers always end up resorting to sloppy bad practices to work around.

In C++3 (before C++0x/C++11) there was no way to pre-declare them. If you wanted to declare a function prototype that accepted a LocalizationStringID enumeration, that mean’t including the whole bloody list of LocalizationStringIDs too.

Compounding this issue is the fact that enums are exposed in the scope they are declared in, so they generally pollute namespaces, so being forced to continually include is a real pain in the butt.

It also means you have to remember the special prefix that every enum list uses, because in order to hide stuff, people tend to make their enum names long.

But the compiler couldn’t, otherwise, tell what sort of variable was going to be needed for the enum, and there was no way to specify it. Especially when you’re dealing with networking, this is an abject pain in the ass because it’s a variable who’s type you don’t control in a language without reflection there is no way to find out what it has been given, in a situation where you care a great deal about exactly how the data is stored.

I’ll get to my other enum issues after I touch on what C++11 did do for enums.

// Before

// Localization string identifiers.
// Try to keep these in-sync with the localization database, please.
typedef enum LSTRING_ID {
LSTR_NONE  // No message,
, LSTR_NOTE  // NOTE: prefix
, LSTR_SPILLED_BEER_ON_KEYBOARD // = #6100 as of 11/21/09
, LSTR_PREFIX_LINE = -1  // More text to follow.
// ^- this may cause the compiler to use signed storage for the enum,
// or the compiler might always use signed storage for enums,
// or the compiler might never use signed storage.
// Either way, it's going to lead to some interesting type-pun errors.

extern void sendLString(playerid_t /*toPlayer*/, int /*lstringID*/) ;
extern void sendLStringID(playerid_t /*toPlayer*/, LSTRING_ID /*lstringID*/);
// ...
LSTRING_ID x = 90210 ; // Valid but bad.
sendLString(pid, LSTR_NONE) ; // Valid but bad practice.
sendLString(pid, 99999) ; // Valid but not good.
sendLStringID(pid, -100) ; // Valid but not good.
sendLStringID(pid, Client::Graphics::RenderType::OpenGL) ; // Valid but OMFG LTC&P MORON!
// Last but not least ...

C++11 cleans up on enums big time. Firstly with enum class, and here, I think hats off to the committee for coming up with a rather nice syntax although they had to fudge it to avoid what I find a dumb caveat of the C++ class definition :)

An enum class is a class-like namespace, complete with type safety, that contains an enumeration. Borrowing further from the class definition, it allows you to specify a base class which will be the underlying type used for the enumeration. If omitted, though, it’ll use the good old I-dunno-wtf-type-that-is enum type.

enum class LStringIds : signed short
PrefixLine = -1
, None = 0
, Note
, SpilledBeerOnKeyboard


sendLStringID(playerID, LStringIds::SpilledBeerOnKeyboard) ;

By using this class mechanism, you can also pre-declared enums now:

enum class LSTRING_ID : short ; // VS11 Beta doesn't support this as of 2012-03-03, though it says it does.

GCC 4.6 supports this, and it reduced game-server compilation time by about 8%. RAR!

We can also use nice names for the LString IDs now without worrying about naming clashes.

I would like to point out that anyone who knows C++ should have spotted that there is no access type specification,

enum class Foo : public unsigned char { public: Fred ... } ;

It makes no sense that the names in an enum class be private. But then it also makes no sense that the stuff in a class be private by default.

Note: There is also “enum struct” … which as far as I understand is exactly the same, it’s just less likely to make you forget to put “public” at the top of your next real class declaration :)

I’m going to write a separate post about my other gripes with enums :)


Not many people know this, but computers are utterly shit at keeping track of time. The hardware involved is a joke, and because of various historical bugs in each operating systems’ time keeping routines, it’s really bloody messy and expensive to get time in meaningful terms, never mind portable.

For example, under Windows you have to pratt about with QueryPerformanceCounter, and then you have to make sure to check for time going backwards or leaping forwards, and stuff.

C++11 doesn’t fix that, but it helps by providing functions to deal with a lot of this stuff in the standard library via the <chrono> header. Yay! The template origamists really came out and did their thing, there are some really nice features involved there, including the ability to create timing variables that include their quanta in their compile-time type information so that the compiler can do smart stuff like working out that you’re comparing seconds with minutes and what it needs to do to handle that situation…


Oh, god, yes.

Leave a Reply

Name and email address are required. Your email address will not be published.

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s

You may use these HTML tags and attributes:

<a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <pre> <q cite=""> <s> <strike> <strong> 

%d bloggers like this: