【C++】派生クラスを値で渡すと「切り取られる」原因とは？｜オブジェクトスライシングで仮想関数が効かなくなる現象を実測して防ぐ

▼e1_slice.cpp
// 派生クラスを、基底クラスの「値」で受け取ると、何が起きるか
#include <cstdio>

struct Enemy
{
    int id = 0;
    virtual ~Enemy() = default;
    virtual const char* name() const { return "敵(基底クラス)"; }
    virtual int attack() const { return 1; }
};

struct Dragon : Enemy
{
    int fireBreath = 100;
    const char* name() const override { return "ドラゴン"; }
    int attack() const override { return fireBreath; }
};

void byValue(Enemy e)            { std::printf("値渡し     : %s / 攻撃力 %3d / sizeof = %zu\n", e.name(), e.attack(), sizeof(e)); }
void byRef(const Enemy& e)       { std::printf("参照渡し   : %s / 攻撃力 %3d / sizeof = %zu\n", e.name(), e.attack(), sizeof(e)); }
void byPointer(const Enemy* e)   { std::printf("ポインタ渡し: %s / 攻撃力 %3d / sizeof = %zu\n", e->name(), e->attack(), sizeof(*e)); }

int main()
{
    Dragon d;
    std::printf("sizeof(Enemy) = %zu, sizeof(Dragon) = %zu\n\n", sizeof(Enemy), sizeof(Dragon));

    byValue(d);
    byRef(d);
    byPointer(&d);

    Enemy copy = d;     // 値でコピー
    std::printf("Enemy copy = d    : %s / 攻撃力 %3d\n", copy.name(), copy.attack());
    return 0;
}

sizeof(Enemy) = 16, sizeof(Dragon) = 24

値渡し     : 敵(基底クラス) / 攻撃力   1 / sizeof = 16
参照渡し   : ドラゴン / 攻撃力 100 / sizeof = 16
ポインタ渡し: ドラゴン / 攻撃力 100 / sizeof = 16
Enemy copy = d    : 敵(基底クラス) / 攻撃力   1

▼e2_vector.cpp
// vector<Enemy> に派生クラスを入れて、攻撃力の合計を出す
#include <cstdio>
#include <memory>
#include <vector>

struct Enemy
{
    virtual ~Enemy() = default;
    virtual int attack() const { return 1; }
};
struct Slime : Enemy  { int attack() const override { return 5; } };
struct Goblin : Enemy { int attack() const override { return 12; } };
struct Dragon : Enemy { int attack() const override { return 100; } };

int main()
{
    // ① 値で入れる
    std::vector<Enemy> byValue;
    byValue.push_back(Slime());
    byValue.push_back(Goblin());
    byValue.push_back(Dragon());
    int sum1 = 0;
    for (const Enemy& e : byValue) sum1 += e.attack();
    std::printf("vector<Enemy>                : 攻撃力の合計 = %3d\n", sum1);

    // ② ポインタ(unique_ptr)で入れる
    std::vector<std::unique_ptr<Enemy>> byPtr;
    byPtr.push_back(std::make_unique<Slime>());
    byPtr.push_back(std::make_unique<Goblin>());
    byPtr.push_back(std::make_unique<Dragon>());
    int sum2 = 0;
    for (const auto& e : byPtr) sum2 += e->attack();
    std::printf("vector<unique_ptr<Enemy>>    : 攻撃力の合計 = %3d   (5 + 12 + 100 = 117 のはず)\n", sum2);
    return 0;
}

vector<Enemy>                : 攻撃力の合計 =   3
vector<unique_ptr<Enemy>>    : 攻撃力の合計 = 117   (5 + 12 + 100 = 117 のはず)

▼e3_assign.cpp
// 基底クラスの参照どおしで代入すると、基底クラスの部分だけがコピーされる
#include <cstdio>

struct Base
{
    int id = 0;
    virtual ~Base() = default;
    virtual const char* who() const { return "Base"; }
};

struct Derived : Base
{
    int hp = 0;
    const char* who() const override { return "Derived"; }
};

int main()
{
    Derived a; a.id = 1; a.hp = 10;
    Derived b; b.id = 2; b.hp = 99;
    std::printf("代入の前 : a = {id %d, hp %2d}, b = {id %d, hp %2d}\n", a.id, a.hp, b.id, b.hp);

    Base& ra = a;
    Base& rb = b;
    ra = rb;            // 基底クラス同士の代入(= Base の部分だけがコピーされる)

    std::printf("ra = rb  : a = {id %d, hp %2d}   ← id だけ b の値になり、hp は元のまま\n", a.id, a.hp);
    return 0;
}

代入の前 : a = {id 1, hp 10}, b = {id 2, hp 99}
ra = rb  : a = {id 2, hp 10}   ← id だけ b の値になり、hp は元のまま

▼e4_abstract_bad.cpp
// 基底クラスを「抽象クラス」にして、値渡し・値コピーをコンパイルエラーにする
struct Enemy
{
    virtual ~Enemy() = default;
    virtual int attack() const = 0;      // 純粋仮想関数: Enemy そのものは作れない
};

struct Dragon : Enemy
{
    int attack() const override { return 100; }
};

void byValue(Enemy e) {}                 // 抽象クラスは値で受け取れない

int main()
{
    Dragon d;
    byValue(d);
    Enemy copy = d;                      // 値でコピーも、できない
    return 0;
}

e4_abstract_bad.cpp(13): error C2259: 'Enemy': 抽象クラスをインスタンス化できません。
e4_abstract_bad.cpp(18): error C2259: 'Enemy': 抽象クラスをインスタンス化できません。
e4_abstract_bad.cpp(19): error C2259: 'Enemy': 抽象クラスをインスタンス化できません。
e4_abstract_bad.cpp(19): error C2259: 'Enemy': 抽象クラスをインスタンス化できません。

▼e5_protected_bad.cpp
// 純粋仮想関数が無い基底クラスでは、コピーコンストラクタを protected にして守る
struct Enemy
{
    virtual ~Enemy() = default;
    virtual int attack() const { return 1; }
protected:
    Enemy() = default;
    Enemy(const Enemy&) = default;       // 外から Enemy をコピーさせない(派生クラスの中からは、使える)
};

struct Dragon : Enemy
{
    int attack() const override { return 100; }
};

int main()
{
    Dragon d;
    Dragon d2 = d;                       // 派生クラス同士のコピーは、これまでどおり
    Enemy copy = d;                      // 基底クラスへの値コピーは、ビルドが通らない
    return 0;
}

e5_protected_bad.cpp
e5_protected_bad.cpp(20): error C2248: 'Enemy::Enemy': protected メンバー (クラス 'Enemy' で宣言されている) にアクセスできません。
e5_protected_bad.cpp(8): note: 'Enemy::Enemy' の宣言を確認してください
e5_protected_bad.cpp(2): note: 'Enemy' の宣言を確認してください