Question

This is a part of a static assert trick. I can’t understand how the unspecialized class works. Can someone explain it to me?

EDIT: Full code with macro: (taken from http://www.skynet.ie/~caolan/Fragments/C++StaticAssert.html)

#ifndef STATICASSERT_HXX
#define STATICASSERT_HXX
/*
 Lifted direct from:
 Modern C++ Design: Generic Programming and Design Patterns Applied
 Section 2.1
 by Andrei Alexandrescu
*/
namespace ww
{
    template<bool> class compile_time_check
    {
    public:
        compile_time_check(...) {}
    };

    template<> class compile_time_check<false>
    {
    };
}

    /*
    Similiar to assert, StaticAssert is only in operation when NDEBUG is not
    defined. It will test its first argument at compile time and on failure
    report the error message of the second argument, which must be a valid c++
    classname. i.e. no spaces, punctuation or reserved keywords.
    */
#ifndef NDEBUG
#   define StaticAssert(test, errormsg)                         \
    do {                                                        \
        struct ERROR_##errormsg {};                             \
        typedef ww::compile_time_check< (test) != 0 > tmplimpl; \
        tmplimpl aTemp = tmplimpl(ERROR_##errormsg());          \
        sizeof(aTemp);                                          \
    } while (0)
#else
#   define StaticAssert(test, errormsg)                         \
    do {} while (0)
#endif

#endif

Answer 1

The macro calls this code in a way similar to this:

compile_time_check<static expression> temp(Error_Some_Struct_here);

So, for example, you could do this:

compile_time_check<sizeof(Foo) < sizeof(Bar)> temp(Error_Foo_must_be_smaller_than_Bar);

When sizeof(Foo) is less than sizeof(Bar), the template would instanciate the unspecialized version:

template<bool> class compile_time_check
{
public:
    compile_time_check(...) {}  //What is this?
};

and the code basically "compiles to" an instanciation of this class:

compile_time_check temp(Error_Foo_must_be_smaller_than_Bar);

which, being empty and doing nothing, the compiler can remove as dead code. Bam, no runtime overhead, done.

If, on the other hand, sizeof(Foo) is greater than or equal to sizeof(Bar), it would instead instanciate the specialized version:

template<> class compile_time_check<false>
{
};

and it would attempt to call the constructor compile_time_check::compile_time_check(struct), but since it doesn’t exist, its a compile error. Which is what you want, because static assert should only compile if the assert is true.

The reason for the constructor to take a variadic parameter list is, I believe, two-fold:

1. To make sure that it does not call the default constructor, which the specialized version would have. Its variadic so that you can pass in any struct as an error "string". Alternatively, this could have been templated and the constructor could have taken a template object as an argument instead.
2. So that the error message can be passed in. When the assert is true, this is ignored and nothing happens and the code is removed by the compilers optimizer. If the assert is false, however, the error string should show up in the error message. Something like constructor not found for compile_time_check::compile_time_check(ERROR_Assertion_error_blah()) perhaps.

An alternative, template-free (I believe its often used in C), static assert I’ve seen somewhere before is this:

#define compile_time_assert(pred) switch(0){case: 0: case pred:;}

This works because if pred is false, the code would end up as switch(0){case: 0: case 0:;} and two case labels with the same constant is an error. In depth explanation here.