CODEWITHSUNDEEP
c++debuggingmetaprogramming
Migi
Migi

Reputation: 1142

Getting rid of #ifndef NDEBUG

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.

Upvotes: 11

Views: 8980

Answers (5)

John Bowler
John Bowler

Reputation: 1

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.

Upvotes: 0

Martin Stone
Martin Stone

Reputation: 13007

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.

Upvotes: 0

aschepler
aschepler

Reputation: 72401

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.

Upvotes: 8

BЈовић
BЈовић

Reputation: 64223

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.

Upvotes: 8

zeuxcg
zeuxcg

Reputation: 9404

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 */ };)

Upvotes: 6

Related Questions