Getting rid of #ifndef NDEBUG

Question

Most of my classes have debug variables, and this makes them often look like this:

class A
{
    // stuff
#ifndef NDEBUG
    int check = 0;
#endif
};

and methods might look like this:

for (/* big loop */) {
    // code
#ifndef NDEBUG
    check += x;
#endif
}

assert(check == 100);

Few things are uglier than all those #ifndef NDEBUG's. Unfortunately no compiler I know can optimize the check variable away without these #ifndefs (I don't know if that's even allowed).

So I've tried to come up with a solution that would make my life easier. Here's how it looks now:

#ifndef NDEBUG

#define DEBUG_VAR(T) T

#else

template <typename T>
struct nullclass {
    inline void operator+=(const T&) const {}
    inline const nullclass<T>& operator+(const T&) const { return *this; }
    // more no-op operators...
};

#define DEBUG_VAR(T) nullclass<T>

#endif

So in debug mode, DEBUG_VAR(T) just makes a T. Otherwise it makes a "null class" with only no-ops. And my code would look like this:

class A {
   // stuff
   DEBUG_VAR(int) check;
};

Then I could just use check as if it were a normal variable! Awesome! However, there are still 2 problems that I cannot get solved:

1. It only works with int, float, etc.

The "null class" doesn't have push_back() etc. No biggie. Most debug variables are ints anyway.

2. The "null class" is 1 char wide!!

Every class in C++ is at least 1 char wide. So even in release mode, a class that uses N debug vars will be at least N chars too big. This is in my eyes just unacceptable. It's against the zero-overhead principle which I aim for as much as I can.

So, how do I fix this second problem? Is it even possible to get rid of the #ifndef NDEBUG's without hurting performance in non-debug mode? I accept any good solution, even if it's your darkest C++ wizardry or C++0x.

Answer 1

You can not fix the 2nd problem, as the c++ standard requires the sizeof of a class or an object to be at least one byte.

The simplest solution would be not to introduce such hacks, and to properly unit test your code.

Answer 2

How about:

#ifndef NDEBUG
#define DEBUG_VAR(T) static nullclass<T>
#endif

Now no additional storage is added to a class where DEBUG_VAR(T) is used as a member, but the declared identifier can still be used as though it were a member.

Answer 3

Something like this could work:

#ifdef NDEBUG
    #define DEBUG_VAR(type, name)
    #define DEBUG_VAR_OP(code)
#else
    #define DEBUG_VAR(type, name) type name;
    #define DEBUG_VAR_OP(code) code;
#endif

Usage example:

struct Foo
{
    DEBUG_VAR(int, count)
};

void bar(Foo* f)
{
    DEBUG_VAR_OP(f->count = 45)
}

However, please note that in general the more differences there are in terms of memory layout between different configurations of your program, the more hard bugs ("it works in debug, but randomly crashes in release") you're going to get. So if you find yourself using additional debugging data often, you should redesign your data structures. When there's a lot of debug data, prefer leaving a pointer to debug data in release mode (ie struct Foo { ... ; struct FooDebug* debugData; /* NULL in Release */ }; )

Answer 4

How about declaring the member object static in debug mode:

#define DEBUG_VAR(T) static nullclass<T>

You will have to define an instance of each object somewhere.

(By the way, the reason that objects of an empty class must take up space is so that they can have unique this pointers.)

Edit: Removed second idea -- won't work.