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.

auto

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 ...
sendLStringID(pid, LSTR_SPILLED_BEER_ON_KEYBOARD) ;

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 :)

time

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…

parallelism

Oh, god, yes.

VS2011: Bummer

Apart from reading some hype about 2011 focusing on C++, I don’t really see much to be excited about in VS2011 so far. We’re running the game on Ubuntu now, and we’ve migrated development to 11.10, which means GCC 4.6. Even Intel’s C++ compiler has had excellent C++0x/C++11 support for over a year.

VS2011 is lagging horribly behind in C++11 support.

I’m fairly fond of some of the C++11 changes, in particular “enum class”, the use of (if not the name of) “auto” and “range based for”.

I’ll be very pleased when we can use the virtual function decorators, but really, I think code that has

class A {
virtual void foo() ;
};

class B {
void foo() ;
};

should be a compile error. From memory, this is allowed because of multiple-inheritance. If that’s true, fail, that is going to be a bug down the line so the language and compiler should reject it up front.

I’m still seething that C++11 is not going to give us discrete abstract-virtual classes. REMEMBER: Do NOT use the “i” word, it causes the C++ standards people to froth at the mouth or masturbate, I forget which.

It’s true, you can kinda implement interfaces in C++ already

class IWannaBeAnInterface {
void halt() = 0;
void catchFire() = 0;
};

Ooops, I forgot to make them public. Now, should I switch it to a struct or add an extra line?

// Since the point is not to have members, a struct feels weird.
struct IWannaBeAnInterface {
void halt() = 0;
void catchFire() = 0;
};

// Ok, a class feels more accurate, but remember to make stuff public.
class IWannaBeAnInterface {
public:
void halt() = 0 ;
public:
void catchFire() = 0 ;
} ;

// But I can also totally screw up by doing this:
class IWannaBeAnInterface {
private:
void halt() = 0 ;
protected:
void catchFire() = 0 ;
} ;

On the one hand, C++ has the most awesome template meta-programming system. On the other, it has a bunch of not-invented-here retards on the standards committee who won’t accept “interfaces” because Java did them.

Interfaces – pure virtual abstract classes – have countless reasons to exist: clarity of code (“this is an interface, not a struct or a class”), compiler code validation (“you can’t have private members of an interface”), virtual avoidance (“I want to describe an interface to this class hierarchy without having to expose all of the #includes, and without having to do a vtable lookup”), etc.

Well, those aren’t in the C++11 standard, so I can’t fault VS2011 for not including them, but I’m gonna skip 2011 because (a) it’s already 2021, (b) it doesn’t support near enough of C++11.

C++0x lambdas suck

int x = 3 ;
int y = 2 ;
vector<int> v = { 1, 2, 3, 4, 5, 6 } ;

sort(v.begin(), v.end(), [=x, &y](int lhs, int rhs) { return (lhs & x) < (rhs & y); }) ;

Ok – I stretched there to incorporate the capture in all it’s glory (the capture is the [=x,&y]).

Lets be frank here. The purpose of a lambda function is to be able to create a little snippet of code to be executed inside a loop.

Does C++ need it? IMHO, lambda functions are bad. And C++0x’s choice to make them hideously ugly doubly so.

Nearly done with PreparedStatement

It’s been a really busy week – starting out with me going locking down on Monday and working from home to get a whole bunch of stuff blasted out without having to go cowboy.

Somehow, inbetween everything else, I’ve managed to get a little ‘recreational coding’ out of the genuine need to get prepared statements integrated into the codebase for what we’re doing with the auth process.

So far, I only need data modifying statements, but the natural progression is a general encapsulation that will also support call/select etc. (Right now I never even both fetching the result set because none of my queries needs to).