【C++】仮想デストラクタを付け忘れると、派生クラスの後始末が呼ばれない？｜メモリが増え続ける様子を実測して、unique_ptrとshared_ptrの違いも確かめる

▼v1_basic.cpp(VIRTUAL_DTORを0と1にして、2通りでビルド)
#include <cstdio>

#ifndef VIRTUAL_DTOR
#define VIRTUAL_DTOR 0
#endif

static int g_baseDtor = 0;
static int g_derivedDtor = 0;

class Enemy                                    // 基底クラス
{
public:
    Enemy() { std::printf("  Enemy() 生成\n"); }
#if VIRTUAL_DTOR
    virtual ~Enemy() { ++g_baseDtor; std::printf("  ~Enemy() 破棄\n"); }
#else
    ~Enemy() { ++g_baseDtor; std::printf("  ~Enemy() 破棄\n"); }
#endif
    virtual void Update() {}
};

class Slime : public Enemy                     // 派生クラス: 自分でメモリを確保する
{
public:
    Slime() : memory_(new char[1024]) { std::printf("  Slime() 生成(1024バイト確保)\n"); }
    ~Slime() { delete[] memory_; ++g_derivedDtor; std::printf("  ~Slime() 破棄(1024バイト解放)\n"); }
    void Update() override {}

private:
    char* memory_;
};

int main()
{
    std::printf("[virtual デストラクタ: %s]\n", VIRTUAL_DTOR ? "あり" : "なし");
    Enemy* e = new Slime();                    // 基底クラスのポインタで持つ
    std::printf("delete e を実行\n");
    delete e;                                  // 基底クラスのポインタ経由で、delete する
    std::printf("結果: ~Enemy が呼ばれた回数 = %d, ~Slime が呼ばれた回数 = %d\n", g_baseDtor, g_derivedDtor);
    return 0;
}

[virtual デストラクタ: なし]
  Enemy() 生成
  Slime() 生成(1024バイト確保)
delete e を実行
  ~Enemy() 破棄
結果: ~Enemy が呼ばれた回数 = 1, ~Slime が呼ばれた回数 = 0

[virtual デストラクタ: あり]
  Enemy() 生成
  Slime() 生成(1024バイト確保)
delete e を実行
  ~Slime() 破棄(1024バイト解放)
  ~Enemy() 破棄
結果: ~Enemy が呼ばれた回数 = 1, ~Slime が呼ばれた回数 = 1

v1_basic.cpp
v1_basic.cpp(17): warning C4265: 'Enemy': クラスは仮想関数を含んでいますが、その非単純デストラクターが仮想ではありません。このクラスのインスタンスは正しく消滅されない可能性があります
v1_basic.cpp(26): warning C4265: 'Slime': クラスは仮想関数を含んでいますが、その非単純デストラクターが仮想ではありません。このクラスのインスタンスは正しく消滅されない可能性があります

▼v3_mem.cpp
#include <windows.h>
#include <psapi.h>
#include <cstdio>

#ifndef VIRTUAL_DTOR
#define VIRTUAL_DTOR 0
#endif

class Enemy
{
public:
#if VIRTUAL_DTOR
    virtual ~Enemy() {}
#else
    ~Enemy() {}
#endif
    virtual void Update() {}
};

class Slime : public Enemy
{
public:
    Slime() : memory_(new char[1024]) { memory_[0] = 1; }
    ~Slime() { delete[] memory_; }

private:
    char* memory_;
};

static double privateMB()
{
    PROCESS_MEMORY_COUNTERS_EX pmc{};
    GetProcessMemoryInfo(GetCurrentProcess(), (PROCESS_MEMORY_COUNTERS*)&pmc, sizeof(pmc));
    return pmc.PrivateUsage / (1024.0 * 1024.0);
}

int main()
{
    std::printf("virtual デストラクタ: %s\n", VIRTUAL_DTOR ? "あり" : "なし");
    std::printf("%-14s %s\n", "作って消した数", "プロセスのメモリ(MB)");
    std::printf("%-14d %.1f\n", 0, privateMB());
    for (int round = 1; round <= 4; ++round)
    {
        for (int i = 0; i < 100000; ++i)
        {
            Enemy* e = new Slime();
            delete e;                                  // 基底クラスのポインタ経由で解放する
        }
        std::printf("%-14d %.1f\n", round * 100000, privateMB());
    }
    return 0;
}

virtual デストラクタ: なし
作って消した数 プロセスのメモリ(MB)
0              0.7
100000         103.8
200000         206.6
300000         309.4
400000         412.2

virtual デストラクタ: あり
作って消した数 プロセスのメモリ(MB)
0              0.7
100000         0.7
200000         0.7
300000         0.7
400000         0.7

▼v2_smart.cpp
#include <cstdio>
#include <memory>

// virtual デストラクタが、無い基底クラス
class Enemy
{
public:
    ~Enemy() { std::printf("    ~Enemy()\n"); }
    virtual void Update() {}
};

class Slime : public Enemy
{
public:
    Slime() : memory_(new char[1024]) {}
    ~Slime() { delete[] memory_; std::printf("    ~Slime()  <- 派生クラスの後始末\n"); }

private:
    char* memory_;
};

int main()
{
    std::printf("[生ポインタ: Enemy* e = new Slime; delete e;]\n");
    {
        Enemy* e = new Slime();
        delete e;
    }
    std::printf("[unique_ptr<Enemy> に、new Slime を入れる]\n");
    {
        std::unique_ptr<Enemy> u(new Slime());
    }
    std::printf("[shared_ptr<Enemy> に、new Slime を入れる]\n");
    {
        std::shared_ptr<Enemy> s(new Slime());
    }
    std::printf("[shared_ptr<Enemy> に、make_shared<Slime> を入れる]\n");
    {
        std::shared_ptr<Enemy> s = std::make_shared<Slime>();
    }
    return 0;
}

[生ポインタ: Enemy* e = new Slime; delete e;]
    ~Enemy()
[unique_ptr<Enemy> に、new Slime を入れる]
    ~Enemy()
[shared_ptr<Enemy> に、new Slime を入れる]
    ~Slime()  <- 派生クラスの後始末
    ~Enemy()
[shared_ptr<Enemy> に、make_shared<Slime> を入れる]
    ~Slime()  <- 派生クラスの後始末
    ~Enemy()

▼直したEnemyクラス
class Enemy
{
public:
    virtual ~Enemy() = default;     // 基底クラスのデストラクタは、virtualにする
    virtual void Update() {}
};