How to make sure different C++ code base using the same macro?

Question

We are working on two C++ code base, let's call it A and B, the A is an build as an library, and distribute the header files .h and .a file to B.

Let's say there is Lock.h file in A as following:

// Lock.h in code base A
class Lock {
    ... ...
#ifdef TRACK_THREAD_OWNER_FOR_DEBUG
    virtual int GetLockOwner();
#endif
    ... ...
private:
    CriticalSection section;
#ifdef TRACK_THREAD_OWNER_FOR_DEBUG
    int threadOwner;
#endif
};

// Caller.cc in code base B
#include "xxx/xxx/Lock.h"
Lock lockObject;
lockObject.Lock();

In code base A, we by default will enable TRACK_THREAD_OWNER_FOR_DEBUG and may change it just before final release day.

We hit some hard bug because TRACK_THREAD_OWNER_FOR_DEBUG are different in A and B, and cause memory corruption because the sizeof(Lock) is different in two library.

So how to protect from this error? Can we trigger an compiler error when build the caller.cc file if the build macro TRACK_THREAD_OWNER_FOR_DEBUG is different in two project?

Answer 1

It is not possible to make this into compiler error, however it should be possible to make this into reasonably clear linker error by exporting some symbol which name depends on the currently defined macros. For example using static guard variable:

//  Foo.hpp - library header file
#pragma once

class Foo
{
    public: Foo();
#ifdef IMPORTANT_CONDITION
    int m_field;
#endif
};

class ConditionGuard
{
    public:
    ConditionGuard(void) noexcept
    {
    #ifdef IMPORTANT_CONDITION
        CONDITION_ON();
    #else
        CONDITION_OFF();
    #endif
    }

#ifdef IMPORTANT_CONDITION
    private: static void CONDITION_ON(void);
#else
    private: static void CONDITION_OFF(void);
#endif
};

static ConditionGuard const condition_guard{};

// Foo.cpp - library implementation file 
#include "Foo.hpp"

Foo::Foo(void) {}

#ifdef IMPORTANT_CONDITION
void ConditionGuard::CONDITION_ON(void) {}
#else
void ConditionGuard::CONDITION_OFF(void) {}
#endif

Now when user code includes library header Foo.hpp it will also trigger construction of condition_guard static variable which will call a library function depending on condition being protected. So if there is a translation unit including Foo.hpp where IMPORTANT_CONDITION is defined differently than in compiled library then there will be a linker error for missing CONDITION_ON or CONDITION_OFF. CONDITION_ON and CONDITION_OFF function names should contain error text.