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.

Vanessa

Welcome to SO! My compliments on a very well-phrased and interesting first question :D – Nancynandor

you should add a debug prefix to the name of those variable (e.g. debug_ or short dbg_) or you wont be able to tell which variable is a debug variable and which is not when you are looking at the source file, now that you dont have #ifndef NDEBUG lines anymore. – Premolar

Having different object layouts in debug/release mode is a hard time debugging waiting to happen. I find good practice to keep debug checks and asserts in release mode, and disable them after profiling and comprehensive debugging. If your release mode differs from your debug mode only in the optimization settings, you will be fine. Especially take care of the pesky _SECURE_SCL and _HAS_ITERATOR_DEBUGGING in Visual Studio, I always disable both unless I really need them. – Ere

Answer 1

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.

Therapist

I didn't know the solution would be this simple. Like Martin Stone mentions, you still have to define an instance of it somewhere, but that's just a minor nuisance. – Vanessa

@aschepler: what about if such debug var is required per object, not per class? yeah, I saw the example, but isn't the question wider? my personal recommentation is to read @VJo answer and @Alexandre C. comment – Alburg

@Andy T No, the genius part of this solution is that the nullclass instance can be static because it's only doing no-ops. The normal T instance (in debug mode) is still non-static. – Vanessa

Answer 2

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.

Ratal

By the same logic, assertions are hacks - you should properly unit test your code... right? – Wigley

@zeuxcg, asserting on things that are important to the business logic is good. Introducing new test only variables so that you can assert on them is bad. It's a subtle, but import difference – Descant

@Glen, sometimes there are certain complex assumptions that you need additional data to verify. At other times, debug data is to aid in the process of debugging - for example, object names that are redundant in release but very helpful while debugging. – Wigley

+1, but the second problem has a solution in the form of "empty base class optimization": simply move your debug variables into a base class, and use (multiple) inheritance. If the latter base class is empty, it can be optimized away. This is a good place to remind to always use static_cast and not C style casts in the presence of multiple inheritance. – Ere

@Alexandre: How would you associate an identifier like check with each empty base class? – Therapist

@aschepler: struct checker { #ifdef NDEBUG int check; #endif }; class A : checker { ... } – Ere

@Alexandre: Then in release mode, code like check += 1; won't compile at all. @Migi's nullclass hack allows that code to compile in release mode but do nothing, since it calls an empty inline function. – Therapist

@aschepler: you're right :). My point was only to tell about empty base class optimization. – Ere

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 (i.e. struct Foo { ... ; struct FooDebug* debugData; /* NULL in Release */ };)

Wigley

well, DEBUG_VAR_OP is just a shorter form of #ifndef NDEBUG. I might actually use it, though, because it wouldn't mess up my indenting like #ifndef does. – Vanessa

Yup, the only benefit is that it's a one-liner. – Wigley

+1 I would much prefer this solution to the accepted answer. Sure, it's not nearly as stylish and "modern c++-ish", but it has several benefits. First, it also solves problem 1) of the OP. Second, it shows clearly to everybody reading the code that whatever is inside DEBUG_VAR_OP is only executed in debug mode. – Swoosh

BTW: I think would remove the ; after code in the DEBUG_VAR_OP macro definition to force the user of the macro to supply it him/herself. Usually works better with tools that try to format your source code. Maybe wrap the whole thing into a "do { code; } while(0)". – Swoosh

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.

Bikini

Answer 5

The unfortunate double negative ("if not debug is not defined") comes from the original UNIX C "assert", which had to be turned off (a very bad idea).

Modern compilers have no problem with this:

if (0/*DEBUG*/) {
    do some expensive debugging
}

If local variables are required for the "expensive debugging" the fact that they are not used at the end of the day no long causes the GCC to emit fastidious warnings. The code just ends up with debugging which is disabled.

Nevertheless this is not really the answer to your question; it's just a way or making things look neater (no mysterious preprocessing).

My own answer might put me at odds with your Professors:

If debugging is necessary it should be there, always; no way to switch it off. So simply delete the "#ifdef NDEBUG" double negative; always leave the debugging in unless you are sure it is not required in which case delete the whole shebang.

A released product contains bugs; "debugging" statements detect those bugs and, if correctly programmed, allow safe recovery. They should never be disabled.

Waltraudwaltz