【C++】shared_ptrの循環参照でデストラクタが呼ばれない？｜メモリが増え続ける様子を実測して、weak_ptrで解放できる形に直す

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

static int g_alive = 0;

struct Node
{
    const char* name;
    std::shared_ptr<Node> next;
    std::shared_ptr<Node> prev;         // お互いを、shared_ptrで持ち合う

    explicit Node(const char* n) : name(n) { ++g_alive; std::printf("  生成: %s\n", name); }
    ~Node() { --g_alive; std::printf("  破棄: %s\n", name); }
};

int main()
{
    {
        auto a = std::make_shared<Node>("A");
        auto b = std::make_shared<Node>("B");
        a->next = b;
        b->prev = a;
        std::printf("スコープを出る直前: A.use_count=%ld, B.use_count=%ld\n", a.use_count(), b.use_count());
    }
    std::printf("スコープを出たあと: 生き残っているNode = %d\n", g_alive);
    return 0;
}

  生成: A
  生成: B
スコープを出る直前: A.use_count=2, B.use_count=2
スコープを出たあと: 生き残っているNode = 2

▼s2_weak.cpp(prevだけをweak_ptrに変えた)
#include <cstdio>
#include <memory>

static int g_alive = 0;

struct Node
{
    const char* name;
    std::shared_ptr<Node> next;
    std::weak_ptr<Node> prev;           // 戻る側は、weak_ptrにする

    explicit Node(const char* n) : name(n) { ++g_alive; std::printf("  生成: %s\n", name); }
    ~Node() { --g_alive; std::printf("  破棄: %s\n", name); }
};

int main()
{
    {
        auto a = std::make_shared<Node>("A");
        auto b = std::make_shared<Node>("B");
        a->next = b;
        b->prev = a;
        std::printf("スコープを出る直前: A.use_count=%ld, B.use_count=%ld\n", a.use_count(), b.use_count());
    }
    std::printf("スコープを出たあと: 生き残っているNode = %d\n", g_alive);
    return 0;
}

  生成: A
  生成: B
スコープを出る直前: A.use_count=1, B.use_count=2
  破棄: A
  破棄: B
スコープを出たあと: 生き残っているNode = 0

▼s4_mem.cpp
#include <windows.h>
#include <psapi.h>
#include <cstdio>
#include <cstring>
#include <memory>
#include <vector>

struct NodeStrong
{
    std::shared_ptr<NodeStrong> other;
    char payload[1024];
};

struct NodeWeak
{
    std::weak_ptr<NodeWeak> other;
    char payload[1024];
};

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(int argc, char** argv)
{
    const bool weak = argc > 1 && std::strcmp(argv[1], "weak") == 0;
    std::printf("%s版\n", weak ? "weak_ptr" : "shared_ptr(循環)");
    std::printf("%-12s %s\n", "作った組数", "プロセスのメモリ(MB)");
    std::printf("%-12d %.1f\n", 0, privateMB());
    for (int round = 1; round <= 4; ++round)
    {
        for (int i = 0; i < 25000; ++i)
        {
            if (weak)
            {
                auto a = std::make_shared<NodeWeak>();
                auto b = std::make_shared<NodeWeak>();
                a->other = b;
                b->other = a;
            }
            else
            {
                auto a = std::make_shared<NodeStrong>();
                auto b = std::make_shared<NodeStrong>();
                a->other = b;
                b->other = a;
            }
        }
        std::printf("%-12d %.1f\n", round * 25000, privateMB());
    }
    return 0;
}

shared_ptr(循環)版
作った組数 プロセスのメモリ(MB)
0            0.7
25000        55.3
50000        109.6
75000        164.1
100000       218.4

weak_ptr版
作った組数 プロセスのメモリ(MB)
0            0.7
25000        0.7
50000        0.7
75000        0.7
100000       0.7

▼s3_lambda.cpp
#include <cstdio>
#include <functional>
#include <memory>

static int g_alive = 0;

struct Enemy
{
    const char* name;
    std::function<void()> onDead;       // 倒されたときに呼ぶ処理

    explicit Enemy(const char* n) : name(n) { ++g_alive; }
    ~Enemy() { --g_alive; std::printf("  破棄: %s\n", name); }
};

int main()
{
    {
        auto e = std::make_shared<Enemy>("スライム");
        e->onDead = [e]() { std::printf("%sが倒された\n", e->name); };   // 自分自身をキャプチャ
        std::printf("use_count = %ld\n", e.use_count());
    }
    std::printf("スコープを出たあと: 生き残っているEnemy = %d\n", g_alive);
    return 0;
}

use_count = 2
スコープを出たあと: 生き残っているEnemy = 1

▼s3_lambda_fix.cpp
#include <cstdio>
#include <functional>
#include <memory>

static int g_alive = 0;

struct Enemy
{
    const char* name;
    std::function<void()> onDead;

    explicit Enemy(const char* n) : name(n) { ++g_alive; }
    ~Enemy() { --g_alive; std::printf("  破棄: %s\n", name); }
};

int main()
{
    {
        auto e = std::make_shared<Enemy>("スライム");
        std::weak_ptr<Enemy> w = e;                     // 弱い参照を作って、それをキャプチャ
        e->onDead = [w]()
        {
            if (auto self = w.lock())                   // 生きているときだけ使う
            {
                std::printf("%sが倒された\n", self->name);
            }
        };
        e->onDead();
        std::printf("use_count = %ld\n", e.use_count());
    }
    std::printf("スコープを出たあと: 生き残っているEnemy = %d\n", g_alive);
    return 0;
}

スライムが倒された
use_count = 1
  破棄: スライム
スコープを出たあと: 生き残っているEnemy = 0

▼s5_leakreport.cpp
#include <crtdbg.h>
#include <cstdio>
#include <memory>

struct Node
{
    std::shared_ptr<Node> other;
    int id = 0;
};

int main()
{
    // 終了時にリークを報告させて、報告先を標準エラー出力にする
    _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
    _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE);
    _CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR);

    auto a = std::make_shared<Node>();
    auto b = std::make_shared<Node>();
    a->id = 1;
    b->id = 2;
    a->other = b;
    b->other = a;                       // 循環
    std::printf("main終了\n");
    return 0;
}

main終了
Detected memory leaks!
Dumping objects ->
{120} normal block at 0x000002031FEA1110, 40 bytes long.
 Data: <xB              > 78 42 B0 82 F7 7F 00 00 01 00 00 00 01 00 00 00 
{119} normal block at 0x000002031FEA11F0, 40 bytes long.
 Data: <xB              > 78 42 B0 82 F7 7F 00 00 01 00 00 00 01 00 00 00 
Object dump complete.