Gotcha #11: Unnecessary Cleverness

C++ and C seem to attract a disproportionate number of showoffs. (Have you ever heard of an "Obfuscated Eiffel" contest?) These programmers seem to think the shortest distance between two points is the great circle route on a spherical distortion of Euclidean space.

Case in point: it's well-known in C++ circles (Euclidean or otherwise) that the formatting of code is entirely for the benefit of its human readers; it has no effect on the meaning of the code as long as the same sequence of tokens occurs. That last proviso is important, since (for example) the following two lines mean very different things (but see Gotcha #87):

a+++++b; // error! 


a+++ ++b; // OK.

as do the following two lines (see Gotcha #17):

ptr->*m; // OK. 


ptr-> *m; // error!

That said, most C++ programmers would concur that, apart from issues of tokenization of the input stream of characters, formatting is irrelevant to a program's meaning. So, for example, we can declare a variable on one line or several, with the same result. (Some programming environment debuggers and other tools are implemented in terms of line numbers rather than a more exact notion of program location. This often forces programmers to employ unnatural or inconvenient multiline formatting to get accurate error messages, be able to set accurate breakpoints, and so on. This is not a C++ language issue; it's an issue for the designers of C++ programming environments.)

long curLine = __LINE__; // current line number 


long      curLine


     =                __LINE__


  ; // same declaration

Most C++ programmers are wrong. Let's look at a simple template metaprogramming device for selecting a type at compile time:

gotcha11/select.h

template <bool cond, typename A, typename B> 


struct Select {


   typedef A Result;


};


template <typename A, typename B>


struct Select<false, A, B> {


   typedef B Result;


};

An instantiation of the Select template evaluates a condition at compile time, then instantiates one of two versions of the template, depending on the Boolean result of the expression. It's a compile-time if-statement that says, "If the condition is true, the nested Result type is A; otherwise, it's B."

gotcha11/lineno.cpp

Select< sizeof(int)==sizeof(long), int, long >::Result temp = 0; 

This statement declares temp to be an int if ints and longs occupy the same number of bytes. Otherwise, temp is declared to be a long.

Let's look at our earlier declaration of curLine. Why should we waste all that space on a long if we don't have to? Let's get unnecessarily complex for no good reason:

gotcha11/lineno.cpp

const char CM = CHAR_MAX; 


const Select<__LINE__<=CM,char,long>::Result curLine = __LINE__;

That works (and is also correct), but the line is rather long, so the maintainer who comes after us reformats a bit:

gotcha11/lineno.cpp

const Select<__LINE__<=CM,char,long>::Result 


   curLine = __LINE__;

Now we've got a bug. See it?

What if the declaration occurs on line number CHAR_MAX (which may be as small as 127)? The type of curLine will then be char and will be initialized with the maximum value of a char. As soon as we put the initializer on the following line, we'll attempt to initialize a char with one more than the maximum value of a char. The result is probably that the line number is a negative number (like -128). Clever.

Unnecessary cleverness is a common problem with C++ programmers. Remember that it's nearly always preferable to be conventional, clear, and slightly less efficient than unnecessarily clever, unclear, and unmaintainable.