如何修复基于cpp具有2种不同大小的C ++结构？

Question

Let's consider this class in a header file called TestHeader.h

class TestClass
{
public:
    TestClass();

    void DoStuff();
    BOOL v1;
    BOOL v2;
    bool v11;
    char u;
    bool v6;
    static TestClass*   s_pAvatar;
    static BOOL         s_bInputHighlight;

    int v7;
    BOOL v3;
    int v8;
    char t;
    bool v4;
    bool v9[2];
};

Now let's consider 2 cpps, a main.cpp containing this :

typedef bool BOOL;

#include "TestHeader.h"

int main()
{
    TestClass C;
    int s1 = sizeof( TestClass );
    int s2 = sizeof( C.v1 );
    void *v1p = &C.v1;
    void *v2p = &C.v2;
    int AddressDiff = ( int )v2p - ( int )v1p;
    C.DoStuff( );

    return 0;
}

And now TestHeader.cpp containing :

typedef int BOOL;

#include "TestHeader.h"

TestClass* TestClass::s_pAvatar = 0;

void TestClass::DoStuff()
{
    int S1 = sizeof(*this);
    int S2 = sizeof(*s_pAvatar);
    void *v1p = &v1;
    void *v2p = &v2;
    int AddressDiff = (int)v2p - (int)v1p;
    int v1size = sizeof(v1);
    if ( S1 != S2 )
    {
    }
}

If you run this sample on both Visual Studio 2013 and Xcode 6.3.1 which is what I tested with, you'll see that the sizeof of the TestClass is different based on what cpp you are currently in. In this case in main.cpp the class is supposedly 24 bytes while in TestHeader.cpp it's 28 due to BOOL being interpreted differently.

My question is, is this a known C++ issue ? Is there any linker flag to check if all structs at least have the same size across all compilation units ?

Answer 1

Note that including header is an inclusion of its text in the relevant translation unit.

Thus, the two different translation units get different definitions of the class.

The definitions of the class in various translation units, must be identical. The code therefore has Undefined Behavior, violating the One Definition Rule.

Answer 2

The REAL problem here is that you are defining a type BOOL that is different. This means that your compiler, doing exactly what you ask it to do, is generating two different structures.

It's the old joke of: Patient: "Doctor, it hurts when I do this..." Doctor: "Don't do that then..."

In this case, fix your definition of BOOL so that it is the same in all cases (the simplest way to achieve that is to only ever HAVE one definition, that is in one header file). There is no simple trick to achieve this, however. It is a case of discipline, code review and understanding what actually gets defined how and where.

[As others have pointed out, this is technically undefined behaviour as it breaks the rule that "you should only have one definition of something that is shared between modules"]