Gotcha #25: #define Literals

#define MAX 1<<16 

The basic problem with preprocessor symbols is that the preprocessor expands them before the C++ compiler proper has the opportunity to examine them. The preprocessor knows nothing about the scoping or type rules of C++.

void f( int ); 
void f( long );
// . . .
f( MAX ); // which f?

The preprocessor symbol MAX is just the integral value 1<<16 by the time the compiler performs overload resolution. The value 1<<16 could be an int or a long, depending on the target platform of the compilation. Compiling this code on a different platform could result in invocation of a different function.

The #define directive does not respect scope. Most C++ facilities are now encapsulated in namespaces. This has a number of benefits, not the least of which is that different facilities are less likely to interfere with each other. Unfortunately, a #define is not scoped inside a namespace:

namespace Influential { 
#      define MAX 1<<16
// . . .
}
namespace Facility {
const int max = 512;
// . . .
}
// . . .
int a[MAX]; // oops!

The programmer forgot to import the name max and also misspelled it as MAX. However, the preprocessor replaced MAX with 1<<16, so the code compiled anyway. "I wonder why I'm using so much memory…"

The solution to all these problems is, of course, to use an initialized constant:

const int max = 1<<9; 

Now the type of max is the same on all platforms, and the name max follows the usual scoping rules. Note that use of max will probably be just as efficient as use of the #define, since the compiler is free to optimize away storage for the variable and simply substitute its initial value wherever it's used as an rvalue. However, because max is an lvalue (it just happens to be a nonmodifiable lvalue; see Gotcha #6), it has an address, and we can point to it. This isn't possible with a literal:

const int *pmax = &Facility::max; 
const int *pMAX = &MAX; // error!

Another problem with #define literals concerns the lexical, rather than syntactic, nature of their substitution by the preprocessor. Our #define of MAX didn't cause any problems in how we used it above, but it wouldn't be hard to make it do so:

int b[MAX*2]; 

That's right. Because we didn't parenthesize the expression in the #define, we've actually attempted to declare a truly large array of integers:

int b[ 1<<16*2 ]; 

Admittedly, this error is the result of an improperly constructed #define, but it's an error that can't occur with the corresponding use of an initialized constant.

We have the same problem in class scope. Here, we'd like to make a value available throughout the scope of the class and nowhere else. The traditional C++ solution to this problem is to employ an enumerator:

class Name { 
   // . . .
   void capitalize();
   enum { nameLen = 32 };
   char name_[nameLen];
};

The enumerator nameLen occupies no storage, has a well-defined type, and is available only within the scope of the class—including, of course, the class's member functions:

void Name::capitalize() { 
   for( int i = 0; i < nameLen; ++i )
       if( name_[i] )
           name_[i] = toupper( name_[i] );
       else
           break;
}

It's also legal, but not yet universally supported, to declare and initialize a constant static integral data member with an integral constant expression within the body of a class (see Gotcha #59):

class Name { 
   // . . .
   static const int nameLen_ = 32;
};
// . . .
const int Name::nameLen_; // no initializer here!

However, it's possible that the space for this static data member will not be optimized away, and the traditional use of an enumerator is preferred for simple integral constants.