For completeness let’s look at the static_assert keyword introduced as part of C++0x. Picking up where the previous two posts (I & II) left off (in 2008!).

int main( ) {
    static_assert( false, "This must be true" );

    return 0;
}

Visual Studio 2010 outputs:
1>main.cpp(2): error C2338: This must be true

Hooray for progress!

A static assertion that outputs a user controlled error message. Making it much easier to indicate what the actual problem is, and avoiding the need to dig through large amounts of invalid and/or undefined type related compiler output mess.

Better yet; BOOST_STATIC_ASSERT will take advantage of static_assert if your compiler supports it.

#include <boost/static_assert.hpp>

#pragma pack( push, 1 )
struct PktData {
    char b1;
    char b2;
};
#pragma pack( pop )

BOOST_STATIC_ASSERT( 1 == sizeof(PktData) );

Visual Studio 2010 outputs:
1>main.cpp(10): error C2338: 1 == sizeof(PktData)

Where the error message is populated by the failing expression. Which may be nicer than having to specify your own error message as required by static_assert.

Following on from the very quick introduction to static assertions we can now look at how they are actually implemented. Well… how they are currently implemented before C++0x comes along and cleans it all up.

Nicest way to roll your own static assertion is to use C++ templates:

template <bool B>
struct StaticAssertion;

template <>
struct StaticAssertion<true> { };

#define STATIC_ASSERT( x ) StaticAssertion<x>( )

First we forward declare a class template. Then specialise it for the true case. Finally adding a preprocessor macro to tidy up the end user syntax. As we haven’t defined the false case, the compiler will issue an error if it ever tries to instantiate it.

int main( ) {
    STATIC_ASSERT( false );
   
    return 0;
}

Visual Studio 2008 outputs:

1>main.cpp(11) : error C2514: 'StaticAssertion<B>' : class has no constructors
1>        with
1>        [
1>            B=false
1>        ]

GCC v4.0.1:

main.cpp: In function 'int main()':
main.cpp:11: error: invalid use of undefined type 'struct StaticAssertion<false>'
main.cpp:3: error: declaration of 'struct StaticAssertion<false>'

Both error messages contain the StaticAssertion type and give you the correct line the violation occurred on. From this you can deduce that a static assertion has occurred. Further improvements could be made by the use of additional type parameters to let you know the flavour of the assertion. Which is an exercise left for the reader 😉

–

Fortunately static assertions are not limited to C++. You can accomplish the same result using straight C.

#define STATIC_ASSERT( x ) sizeof( char[ (x) ? 1 : -1 ] )

This one liner relies on the fact that you can’t declare a negatively sized array.

Visual Studio 2008:

1>main.cpp(11) : error C2148: total size of array must not exceed 0x7fffffff bytes
1>main.cpp(11) : error C2148: total size of array must not exceed 0x7fffffff bytes
1>main.cpp(11) : error C2070: 'char [-1]': illegal sizeof operand

GCC v4.0.1:

main.cpp: In function 'int main()':
main.cpp:11: error: size of array is negative

Error messages still indicate the offending line, but that’s about it. Not as nice as the C++ templated version but the end result is the same. Program fails to compile.

An assertion statement is used at runtime to verify that an assumption holds true. Typically assert is only used in debug builds, while release builds switch it out completely.

Keep in mind that while an assertion is no substitute for proper error checking, it is useful for a quick verification of low level assumptions. If you design a function with the expectation that the provided pointer will always be valid; then adding an assert will warn the caller when they aren’t playing by the same rules that you are.

int get_nth_char( const char* str, int idx ) {
    assert( str ); // program stops here if str is invalid
    if ( idx < 0 ) return -1;
    return str[ idx ];
}

Static assertions take assert a step further and provide sanity checks at compile time. While static assertions can only operate on known compile time data it is still really useful. A good example is the packing of network data where it is vital that the data is packed correctly and is of the right size. Not only will a static assert verify this. It will also catch the case if it gets changed at a later stage.

#pragma pack( push, 1 )
struct PktData {
    char b1;
    char b2;
};
#pragma pack( pop )

BOOST_STATIC_ASSERT( 2 == sizeof(PktData) );

While the static assert in the above code is courtesy of boost, the upcoming C++0x standard will also include this functionality.

Boost has released v1.35.0 of their C++ libraries. This includes many great goodies such as asio (asynchronous networking library), bimap (indexable by both the key and value), circular buffer, interprocess (shared memory access), and more.

“Boost provides free peer-reviewed portable C++ source libraries”

http://boost.org

Recently I’ve been doing alot of custom drawing and graphic manipulation. Having been frustrated with other on screen magnifiers I finally went about creating my own solution.

• Left mouse drag panning
• Right mouse drag area selection
• Quick scroll wheel zoom in/out
• Rough rulers (which you can turn off)
• RGB pixel value reporting

Magnifier is available from the programs section.