メモリ配置とキャスト

class Base
{
public:
    int a;
    short b;
    int c;
    char d;
};

#include <cstdio>
 
#define PRINT_OBJ(obj) \
    printf("%-10s: %08x, %-16s: %2d\n",\
        "&"#obj,\
        0,\
        "sizeof("#obj")",\
        sizeof(obj));
 
#define PRINT_FIELD(obj, field) \
    printf("%-10s: %08x, %-16s: %2d\n",\
        "&"#obj"."#field,\
        value(&obj.field) - value(&obj),\
        "sizeof("#obj"."#field")",\
        sizeof(obj.field));
 
namespace {
    class Base
    {
    public:
        int a;
        short b;
        float c;
        char d;
    };
 
    inline size_t value(void* p) { return reinterpret_cast<size_t>(p); }
}
 
int main(int argc, char* argv[])
{
    // 基底クラスのメモリ配置確認
    Base base;
    PRINT_OBJ(base);
    PRINT_FIELD(base, a);
    PRINT_FIELD(base, b);
    PRINT_FIELD(base, c);
    PRINT_FIELD(base, d);
    return 0;
}

class Sub : public Base
{
public:
    char e;
    short f;
    float g;
};

#include <cstdio>
 
#define PRINT_OBJ(obj) \
    printf("%-10s: %08x, %-16s: %2d\n",\
        "&"#obj,\
        0,\
        "sizeof("#obj")",\
        sizeof(obj));
 
#define PRINT_FIELD(obj, field) \
    printf("%-10s: %08x, %-16s: %2d\n",\
        "&"#obj"."#field,\
        value(&obj.field) - value(&obj),\
        "sizeof("#obj"."#field")",\
        sizeof(obj.field));
 
namespace {
    class Base
    {
    public:
        int a;
        short b;
        float c;
        char d;
    };
 
    class Sub : public Base
    {
    public:
        char e;
        short f;
        float g;
    };
 
    inline size_t value(void* p) { return reinterpret_cast<size_t>(p); }
}
 
int main(int argc, char* argv[])
{
    // 派生クラスのメモリ配置確認
    Sub sub;
    PRINT_OBJ(sub);
    PRINT_FIELD(sub, a);
    PRINT_FIELD(sub, b);
    PRINT_FIELD(sub, c);
    PRINT_FIELD(sub, d);
    PRINT_FIELD(sub, e);
    PRINT_FIELD(sub, f);
    PRINT_FIELD(sub, g);
    return 0;
}

#include <cstdio>
 
#define PRINT_OBJ(obj) \
    printf("%-10s: %08x, %-16s: %2d\n",\
        "&"#obj,\
        0,\
        "sizeof("#obj")",\
        sizeof(obj));
 
#define PRINT_OBJ_AS(obj, type) \
    printf("%-10s: %08x, size: %2d (as "#type")\n",\
        "&"#obj,\
        value(static_cast<type*>(&obj)) - value(&obj),\
        sizeof(type));
 
#define PRINT_FIELD(obj, field) \
    printf("%-10s: %08x, %-16s: %2d\n",\
        "&"#obj"."#field,\
        value(&obj.field) - value(&obj),\
        "sizeof("#obj"."#field")",\
        sizeof(obj.field));
 
#define PRINT_VPOINTER(obj) \
    printf("%-10s: %08x, %-16s: %2d, vptr: %08x\n",\
        "&"#obj".vptr",\
        0,\
        "sizeof(vptr)",\
        sizeof(void*),\
        *reinterpret_cast<int*>(&obj));
 
namespace {
    class VirtualBase
    {
    public:
        int a;
        virtual void func1() {}
        virtual void func2() {}
    };
 
    class NonVirtualBase
    {
    public:
        int a;
    };
 
    class VirtualSub1 : public VirtualBase
    {
    public:
        virtual void func2() override {}
        virtual void func3() {}
    };
 
    class VirtualSub2 : public NonVirtualBase
    {
    public:
        virtual void func() {}
    };
 
    inline size_t value(void* p) { return reinterpret_cast<size_t>(p); }
}
 
int main(int argc, char* argv[])
{
    {   // ポリモーフィックな基底クラスのメモリ配置とvpointer
        VirtualBase base;
        PRINT_OBJ(base);
        PRINT_VPOINTER(base);
        PRINT_FIELD(base, a);
    }
    {   // ポリモーフィックな基底クラスを継承したクラスのメモリ配置とvpointer
        VirtualSub1 sub;
        PRINT_OBJ(sub);
        PRINT_VPOINTER(sub);
        PRINT_FIELD(sub, a);
    }
    {   // 非ポリモーフィックな基底クラスを継承したポリモーフィックなクラスのポインタ変換
        VirtualSub2 sub;
        PRINT_OBJ_AS(sub, VirtualSub2);
        PRINT_OBJ_AS(sub, NonVirtualBase);
    }
    return 0;
}

#include <iostream>
 
using namespace std;
 
namespace {
    class Base {
    public:
        int a;
    };
    class Sub : public Base {};
 
    class VirtualBase {
    public:
        virtual void func() {}
    };
    class VirtualSub : public VirtualBase {
    public:
        virtual void func() override {}
    };
}
 
int main(int argc, char* argv[])
{
    {   // 非ポリモーフィック
        Sub sub;
        Base* p = &sub;
        cout << typeid(1).name() << endl;   // →int
        cout << typeid(1.28f).name() << endl;   // →float
        cout << typeid(Base).name() << endl;    // →Base
        cout << typeid(sub).name() << endl; // →Sub
        cout << typeid(*p).name() << endl;  // →Base
        p = nullptr;
        cout << typeid(*p).name() << endl;  // →Base
    }
    {   // ポリモーフィック
        VirtualSub sub;
        VirtualBase* p = &sub;
        cout << typeid(*p).name() << endl;  // →VirtualSub
        //p = nullptr;
        //cout << typeid(*p).name() << endl;    // これはできない
    }
    return 0;
}

#include <cstdio>
 
#define PRINT_OBJ_AS(obj, type) \
    printf("%-12s: %08x, size: %2d (as "#type")\n",\
        "&"#obj,\
        value(static_cast<type*>(&obj)) - value(&obj),\
        sizeof(type));
 
#define PRINT_FIELD(obj, field) \
    printf("%-12s: %08x, size: %2d\n",\
        "&"#obj"."#field,\
        value(&obj.field) - value(&obj),\
        sizeof(obj.field));
 
namespace {
    inline size_t value(void* p) { return reinterpret_cast<size_t>(p); }
 
    class Base1
    {
    public:
        int a;
    };
 
    class Base2 {
    public:
        int b;
    };
 
    class MultipleInheritance : public Base1, public Base2 {
    public:
        int c;
    };
}
 
int main(int argc, char* argv[])
{
    // 多重継承
    MultipleInheritance multi;
    PRINT_OBJ_AS(multi, MultipleInheritance);
    PRINT_OBJ_AS(multi, Base1);
    PRINT_OBJ_AS(multi, Base2);
    PRINT_FIELD(multi, a);
    PRINT_FIELD(multi, b);
    PRINT_FIELD(multi, c);
    return 0;
}

#include <cstdio>
 
#define PRINT_OBJ_AS(obj, type) \
    printf("%-12s: %08x, size: %2d (as "#type")\n",\
        "&"#obj,\
        value(static_cast<type*>(&obj)) - value(&obj),\
        sizeof(type));
 
#define PRINT_FIELD(obj, field) \
    printf("%-12s: %08x, size: %2d\n",\
        "&"#obj"."#field,\
        value(&obj.field) - value(&obj),\
        sizeof(obj.field));
 
#define PRINT_VPOINTER_AS(obj, type) \
    printf("%-12s: %08x, size: %2d, vptr: %08x (as "#type")\n",\
        "&"#obj".vptr",\
        value(static_cast<type*>(&obj)) - value(&obj),\
        sizeof(void*),\
        *reinterpret_cast<int*>(static_cast<type*>(&obj)));
 
namespace {
    inline size_t value(void* p) { return reinterpret_cast<size_t>(p); }
 
    class VirtualBase1
    {
    public:
        virtual void func1() {}
        int a;
    };
 
    class VirtualBase2 {
    public:
        virtual void func2() {}
        int b;
    };
 
    class VirtualMultipleInheritance1 : public VirtualBase1, public VirtualBase2 {
    public:
        int c;
    };
 
    class VirtualMultipleInheritance2 : public Base1, public VirtualBase2 {
    public:
        int c;
    };
}
 
int main(int argc, char* argv[])
{
    {   // ポリモーフィックなクラス同士の多重継承
        VirtualMultipleInheritance1 multi1;
        PRINT_OBJ_AS(multi1, VirtualMultipleInheritance1);
        PRINT_OBJ_AS(multi1, VirtualBase1);
        PRINT_OBJ_AS(multi1, VirtualBase2);
        PRINT_VPOINTER_AS(multi1, VirtualMultipleInheritance1);
        PRINT_VPOINTER_AS(multi1, VirtualBase1);
        PRINT_VPOINTER_AS(multi1, VirtualBase2);
        PRINT_FIELD(multi1, a);
        PRINT_FIELD(multi1, b);
        PRINT_FIELD(multi1, c);
    }
    {   // 非ポリモーフィックなクラスとポリモーフィックなクラスの多重継承
        VirtualMultipleInheritance2 multi2;
        PRINT_OBJ_AS(multi2, VirtualMultipleInheritance2);
        PRINT_OBJ_AS(multi2, Base1);
        PRINT_OBJ_AS(multi2, VirtualBase2);
    }
    return 0;
}

#include <cstdio>
 
#define PRINT_OBJ_AS(obj, type) \
    printf("%-12s: %08x, size: %2d (as "#type")\n",\
        "&"#obj,\
        value(static_cast<type*>(&obj)) - value(&obj),\
        sizeof(type));
 
#define PRINT_FIELD(obj, field) \
    printf("%-12s: %08x, size: %2d\n",\
        "&"#obj"."#field,\
        value(&obj.field) - value(&obj),\
        sizeof(obj.field));
 
#define PRINT_FIELD_AS(obj, field, type) \
    printf("%-12s: %08x, size: %2d (as "#type"'s member)\n",\
        "&"#obj"."#field,\
        value(&obj.type::field) - value(&obj),\
        sizeof(obj.type::field));
 
#define PRINT_VPOINTER_AS(obj, type) \
    printf("%-12s: %08x, size: %2d, vptr: %08x (as "#type")\n",\
        "&"#obj".vptr",\
        value(static_cast<type*>(&obj)) - value(&obj),\
        sizeof(void*),\
        *reinterpret_cast<int*>(static_cast<type*>(&obj)));
 
namespace {
    inline size_t value(void* p) { return reinterpret_cast<size_t>(p); }
 
    class CommonBase {
    public:
        int a;
    };
 
    class Inheritance1 : public CommonBase {
    public:
        int b;
    };
 
    class Inheritance2 : public CommonBase {
    public:
        int c;
        virtual void func() {}
    };
 
    class DiamondInheritance : public Inheritance1, public Inheritance2 {};
}
 
int main(int argc, char* argv[])
{
    // 菱形継承
    DiamondInheritance dia;
    PRINT_OBJ_AS(dia, DiamondInheritance);
    PRINT_OBJ_AS(dia, Inheritance1);
    PRINT_OBJ_AS(dia, Inheritance2);
    //PRINT_OBJ_AS(dia, CommonBase);    // Inheritance1とInheritance2のどちらか曖昧でエラー
    PRINT_VPOINTER_AS(dia, DiamondInheritance);
    PRINT_VPOINTER_AS(dia, Inheritance2);
    //PRINT_FIELD(diamond, a);  // Inheritance1とInheritance2のどちらか曖昧でエラー
    PRINT_FIELD_AS(dia, a, Inheritance1);
    PRINT_FIELD_AS(dia, a, Inheritance2);
    PRINT_FIELD(dia, b);
    PRINT_FIELD(dia, c);
    return 0;
}

#include <typeinfo>
#include <cstdio>
 
#define PRINT_OBJ_AS(obj, type) \
    printf("%-12s: %08x, size: %2d (as "#type")\n",\
        "&"#obj,\
        value(static_cast<type*>(&obj)) - value(&obj),\
        sizeof(type));
 
#define PRINT_FIELD(obj, field) \
    printf("%-12s: %08x, size: %2d\n",\
        "&"#obj"."#field,\
        value(&obj.field) - value(&obj),\
        sizeof(obj.field));
 
#define PRINT_FIELD_AS(obj, field, type) \
    printf("%-12s: %08x, size: %2d (as "#type"'s member)\n",\
        "&"#obj"."#field,\
        value(&obj.type::field) - value(&obj),\
        sizeof(obj.type::field));
 
#define PRINT_VPOINTER_AS(obj, type) \
    printf("%-12s: %08x, size: %2d, vptr: %08x (as "#type")\n",\
        "&"#obj".vptr",\
        value(static_cast<type*>(&obj)) - value(&obj),\
        sizeof(void*),\
        *reinterpret_cast<int*>(static_cast<type*>(&obj)));
 
namespace {
    inline size_t value(void* p) { return reinterpret_cast<size_t>(p); }
 
    class CommonBase {
    public:
        int a;
    };
 
    class VirtualInheritance1 : public virtual CommonBase {
    public:
        int b;
    };
 
    class VirtualInheritance2 : public virtual CommonBase {
    public:
        int c;
        virtual void func() {}
    };
 
    class VirtualDiamondInheritance : public VirtualInheritance1, public VirtualInheritance2 {};
}
 
int main(int argc, char* argv[])
{
    // 菱型継承+仮想継承
    VirtualDiamondInheritance dia;
    PRINT_OBJ_AS(dia, VirtualDiamondInheritance);
    PRINT_OBJ_AS(dia, VirtualInheritance1);
    PRINT_OBJ_AS(dia, VirtualInheritance2);
    PRINT_OBJ_AS(dia, CommonBase);
    PRINT_VPOINTER_AS(dia, VirtualDiamondInheritance);
    PRINT_VPOINTER_AS(dia, VirtualInheritance2);
    PRINT_FIELD(dia, a);
    PRINT_FIELD_AS(dia, a, VirtualInheritance1);
    PRINT_FIELD_AS(dia, a, VirtualInheritance2);
    PRINT_FIELD(dia, b);
    PRINT_FIELD(dia, c);
    return 0;
}

#include <iostream>
 
using namespace std;
 
#define TEST(expr) (cout << ((expr) != nullptr ? "[Success]" : "[Failure]") << " " << (expr) << ": " #expr << endl)
 
namespace {
    class Base;
    class Sub;
 
    Base* getSubAsBase();
    void testForwardDeclaration()
    {
        Base* p = getSubAsBase();
        p = nullptr;
        //static_cast<Sub*>(p); // 継承関係が見えずコンパイルエラー
    }
 
    class Base {
    public:
        virtual void func() {}
    };
    class Sub : public Base {};
 
    Base* getSubAsBase()
    {
        static Sub sub;
        return &sub;
    }
 
    class Dummy {};
 
    class CommonBase {
    public:
        int a;
    };
 
    class VirtualInheritance1 : public virtual CommonBase {
    public:
        int b;
    };
 
    class VirtualInheritance2 : public virtual CommonBase {
    public:
        int c;
        virtual void func() {}
    };
 
    class VirtualDiamondInheritance : public VirtualInheritance1, public VirtualInheritance2 {};
}
 
int main(int argc, char* argv[])
{
    // 前方宣言クラスのポインタ変換テスト
    ::testForwardDeclaration();
 
    {   // アップキャストとダウンキャスト
        Sub sub;
        Base* p = &sub;
 
        TEST(dynamic_cast<Base*>(&sub));    // アップキャスト（成功）
        TEST(dynamic_cast<Sub*>(p));        // ダウンキャスト（成功）
        TEST(dynamic_cast<void*>(p));       // voidポインタへキャスト（成功）
        TEST(dynamic_cast<Dummy*>(p));      // 不正なキャスト（失敗）
 
        TEST(static_cast<Base*>(&sub));     // アップキャスト（成功）
        TEST(static_cast<Sub*>(p));         // ダウンキャスト（成功）
        TEST(static_cast<void*>(p));        // voidポインタへキャスト（成功）
        //TEST(static_cast<Dummy*>(p));     // 不正なキャスト（コンパイルエラー）
    }
    {   // クロスキャスト
        VirtualDiamondInheritance dia;
        VirtualInheritance2* p = &dia;
        TEST(dynamic_cast<VirtualInheritance1*>(p));    // 成功
        //TEST(static_cast<VirtualInheritance1*>(p));   // コンパイルエラー
    }
    {   // voidポインタのダウンキャスト
        VirtualDiamondInheritance dia;
        void* p = static_cast<VirtualInheritance2*>(&dia);
        TEST(static_cast<VirtualInheritance1*>(p)); // 不正だが成功
        TEST(static_cast<VirtualInheritance2*>(p)); // 成功
    }
    return 0;
}