Thinking In C++. Volume 2: Practical Programming

//!   char c = safe_cast(p);

} ///:~^.

This example defines a function template, safe_cast<>( ), that checks to see if the object it is casting from is no larger than the type of object it casts to. If the size of the target object type is smaller, then the user will be notified at compile time that a narrowing conversion was attempted. Notice that the StaticCheck class template has the curious feature that anything can be converted to an instance of StaticCheck (because of the ellipsis in its constructor^[71]), and nothing can be converted to a StaticCheck, because no conversions are supplied for that specialization. The idea is to attempt to create an instance of a new class and attempt to convert it to StaticCheck at compile time whenever the condition of interest is true, or to a StaticCheck object when the condition being tested is false. Since the sizeof operator does its work at compile time, it is used to attempt the conversion. If the condition is false, the compiler will complain that it doesn’t know how to convert from the new class type to StaticCheck. (The extra parentheses inside the sizeof invocation in STATIC_CHECK( ) are to prevent the compiler from thinking that we’re trying to invoke sizeof on a function, which is illegal.) To get some meaningful information inserted into the error message, the new class name carries key text in its name^.

The best way to understand this technique is to walk through a specific case. Consider the line in main( ) above which reads:

   int i = safe_cast(p);

The call to safe_cast(p) contains the following macro expansion replacing its first line of code:

{                                    \

   class Error_NarrowingConversion{};               \

   sizeof(StaticCheck \

           (Error_NarrowingConversion()));          \

}

(Recall that the token-pasting preprocessing operator, ##, concatenates its operand into a single token, so Error_##NarrowingConversion becomes the token Error_NarrowingConversion after preprocessing). The class Error_NarrowingConversion is a local class (meaning that it is declared inside a non-namespace scope) because it is not needed elsewhere in the program. The application of the sizeof operator here attempts to determine the size of an instance of StaticCheck (because sizeof(void*) <= sizeof(int) is true on our platforms), created implicitly from the temporary object returned by the call Error_NarrowingConversion( ). The compiler knows the size of the new class Error_NarrowingConversion (it’s empty), and so the compile-time use of sizeof at the outer level in STATIC_CHECK( ) is valid. Since the conversion from the Error_NarrowingConversion temporary to StaticCheck succeeds, so does this outer application of sizeof, and execution continues^.

Now consider what would happen if the comment were removed from the last line of main( ):

   char c = safe_cast(p);

In this case the STATIC_CHECK( ) macro inside safe_cast(p) expands to:

{                                     \

   class Error_NarrowingConversion{}; \

   sizeof(StaticCheck \

           (Error_NarrowingConversion()));           \

}

Since the expression sizeof(void*) <= sizeof(char) is false, a conversion from an Error_NarrowingConversion temporary to StaticCheck is attempted, as follows:

sizeof(StaticCheck(Error_NarrowingConversion()));

which fails, so the compiler halts with a message something like the following:^.

Cannot cast from 'Error_NarrowingConversion' to 'StaticCheck<0>' in function

char safe_cast(void *)

The class name Error_NarrowingConversion is the meaningful message judiciously arrange by the coder. In general, to perform a static assertion with this technique, you just invoke the STATIC_CHECK macro with the compile-time condition to check and with a meaningful name to describe the error^.

Expression templates

Perhaps the most powerful application of templates is a technique discovered independently in 1994 by Todd Veldhuizen^[72] and David Vandevoorde:^[73] expression templates. Expression templates enable extensive compile-time optimization of certain computations that results in code that is at least as fast as hand-optimized Fortran, and yet preserves the natural notation of mathematics via operator overloading. Although you wouldn’t be likely to use this technique in everyday programming, it is the basis for a number of sophisticated, high-performance mathematical libraries written in C++.^[74]