C++におけるガベージコレクションとオブジェクトライフサイクル管理の徹底解説

int* ptr = new int; // メモリの動的割り当て
*ptr = 5; // 値の設定
delete ptr; // メモリの解放

#include <gc/gc.h>

int main() {
    GC_INIT();
    int* ptr = (int*) GC_MALLOC(sizeof(int));
    *ptr = 42;
    // ガベージコレクタが自動的にメモリを解放
    return 0;
}

#include <memory>

void example() {
    std::shared_ptr<int> sptr = std::make_shared<int>(10);
    // sptrがスコープを抜けると自動的にメモリが解放される
}

#include <iostream>
#include <memory>

class MyClass {
public:
    MyClass() { std::cout << "MyClass Constructor" << std::endl; }
    ~MyClass() { std::cout << "MyClass Destructor" << std::endl; }
};

void useSmartPointer() {
    std::shared_ptr<MyClass> ptr1 = std::make_shared<MyClass>();
    {
        std::shared_ptr<MyClass> ptr2 = ptr1;
        // ptr1とptr2が同じオブジェクトを指している
    } // ptr2がスコープを抜けると参照カウントが減少
    // ptr1がスコープを抜けると参照カウントがゼロになり、メモリが解放される
}

int main() {
    useSmartPointer();
    return 0;
}

#include <iostream>
#include <memory>

class MyClass {
public:
    MyClass() { std::cout << "MyClass Constructor" << std::endl; }
    ~MyClass() { std::cout << "MyClass Destructor" << std::endl; }
};

void useUniquePointer() {
    std::unique_ptr<MyClass> ptr1 = std::make_unique<MyClass>();
    // ptr1が所有権を持っている
    std::unique_ptr<MyClass> ptr2 = std::move(ptr1);
    // ptr2に所有権が移動し、ptr1はnullptrになる
}

int main() {
    useUniquePointer();
    return 0;
}

#include <iostream>
#include <memory>

class MyClass {
public:
    MyClass() { std::cout << "MyClass Constructor" << std::endl; }
    ~MyClass() { std::cout << "MyClass Destructor" << std::endl; }
};

void useSharedPointer() {
    std::shared_ptr<MyClass> ptr1 = std::make_shared<MyClass>();
    {
        std::shared_ptr<MyClass> ptr2 = ptr1;
        // ptr1とptr2が同じオブジェクトを共有している
    } // ptr2がスコープを抜けると参照カウントが減少
    // ptr1がスコープを抜けると参照カウントがゼロになり、メモリが解放される
}

int main() {
    useSharedPointer();
    return 0;
}

#include <iostream>
#include <memory>

class MyClass {
public:
    std::shared_ptr<MyClass> other;
    MyClass() { std::cout << "MyClass Constructor" << std::endl; }
    ~MyClass() { std::cout << "MyClass Destructor" << std::endl; }
};

void useWeakPointer() {
    std::shared_ptr<MyClass> ptr1 = std::make_shared<MyClass>();
    std::shared_ptr<MyClass> ptr2 = std::make_shared<MyClass>();
    ptr1->other = ptr2;
    ptr2->other = ptr1; // 循環参照が発生し、メモリリークが起こる
}

void useWeakPointerToBreakCycle() {
    std::shared_ptr<MyClass> ptr1 = std::make_shared<MyClass>();
    std::shared_ptr<MyClass> ptr2 = std::make_shared<MyClass>();
    ptr1->other = ptr2;
    std::weak_ptr<MyClass> weakPtr = ptr1; // 循環参照を防ぐ
}

int main() {
    useWeakPointer();
    useWeakPointerToBreakCycle();
    return 0;
}

#include <iostream>
#include <fstream>

class FileManager {
private:
    std::ofstream file;
public:
    FileManager(const std::string& filename) {
        file.open(filename);
        if (!file.is_open()) {
            throw std::runtime_error("Unable to open file");
        }
    }
    ~FileManager() {
        if (file.is_open()) {
            file.close();
        }
    }
    void write(const std::string& data) {
        if (file.is_open()) {
            file << data;
        }
    }
};

void useFileManager() {
    try {
        FileManager fileManager("example.txt");
        fileManager.write("Hello, RAII!");
        // ファイルはFileManagerのデストラクタで自動的に閉じられる
    } catch (const std::exception& e) {
        std::cerr << "Error: " << e.what() << std::endl;
    }
}

int main() {
    useFileManager();
    return 0;
}

#include <iostream>
#include <memory>

void useSmartPointerRAII() {
    std::unique_ptr<int> uniquePtr = std::make_unique<int>(42);
    std::shared_ptr<int> sharedPtr = std::make_shared<int>(42);
    // メモリはスコープを抜ける際に自動的に解放される
}

int main() {
    useSmartPointerRAII();
    return 0;
}

#include <iostream>
#include <mutex>
#include <thread>

std::mutex mtx;

void printThreadSafe(const std::string& message) {
    std::lock_guard<std::mutex> lock(mtx);
    std::cout << message << std::endl;
}

int main() {
    std::thread t1(printThreadSafe, "Hello from thread 1");
    std::thread t2(printThreadSafe, "Hello from thread 2");

    t1.join();
    t2.join();

    return 0;
}

# プログラムのコンパイル
g++ -g -o my_program my_program.cpp

# Valgrindでプログラムを実行
valgrind --leak-check=full ./my_program

#include <memory>

void useSmartPointers() {
    std::unique_ptr<int> uniquePtr = std::make_unique<int>(10);
    std::shared_ptr<int> sharedPtr = std::make_shared<int>(20);
}

#include <iostream>

class MyClass {
public:
    MyClass() { std::cout << "MyClass Constructor" << std::endl; }
    ~MyClass() { std::cout << "MyClass Destructor" << std::endl; }
};

void dynamicAllocation() {
    MyClass* obj = new MyClass(); // ヒープ領域に動的割り当て
    delete obj; // 明示的にメモリを解放
}

int main() {
    dynamicAllocation();
    return 0;
}

#include <iostream>

class MyClass {
public:
    MyClass() { std::cout << "MyClass Constructor" << std::endl; }
    ~MyClass() { std::cout << "MyClass Destructor" << std::endl; }
};

void stackAllocation() {
    MyClass obj; // スタック領域に割り当て
    // スコープを抜けると自動的にデストラクタが呼ばれメモリが解放される
}

int main() {
    stackAllocation();
    return 0;
}

#include <iostream>
#include <memory>

class MyClass {
public:
    MyClass() { std::cout << "MyClass Constructor" << std::endl; }
    ~MyClass() { std::cout << "MyClass Destructor" << std::endl; }
};

void ownershipTransfer() {
    std::unique_ptr<MyClass> ptr1 = std::make_unique<MyClass>();
    std::unique_ptr<MyClass> ptr2 = std::move(ptr1); // 所有権の移動
}

int main() {
    ownershipTransfer();
    return 0;
}

#include <iostream>
#include <memory>

class Resource {
public:
    Resource() { std::cout << "Resource Acquired" << std::endl; }
    ~Resource() { std::cout << "Resource Released" << std::endl; }
};

void manageResource() {
    std::unique_ptr<Resource> res = std::make_unique<Resource>();
    // スコープを抜けると自動的にリソースが解放される
}

int main() {
    manageResource();
    return 0;
}

#include <iostream>
#include <memory>

void useSmartPointers() {
    std::unique_ptr<int> uniquePtr = std::make_unique<int>(10);
    std::shared_ptr<int> sharedPtr = std::make_shared<int>(20);
    // スマートポインタがスコープを抜けると自動的にメモリが解放される
}

int main() {
    useSmartPointers();
    return 0;
}

#include <iostream>
#include <fstream>

class FileManager {
public:
    FileManager(const std::string& filename) : file(filename) {
        if (!file.is_open()) {
            throw std::runtime_error("Unable to open file");
        }
    }
    ~FileManager() {
        if (file.is_open()) {
            file.close();
        }
    }
    void write(const std::string& data) {
        if (file.is_open()) {
            file << data;
        }
    }
private:
    std::ofstream file;
};

void useFileManager() {
    try {
        FileManager fileManager("example.txt");
        fileManager.write("Hello, RAII!");
    } catch (const std::exception& e) {
        std::cerr << "Error: " << e.what() << std::endl;
    }
}

int main() {
    useFileManager();
    return 0;
}

#include <iostream>
#include <memory>

class Singleton {
public:
    static Singleton& getInstance() {
        static Singleton instance;
        return instance;
    }
private:
    Singleton() { std::cout << "Singleton Constructor" << std::endl; }
    ~Singleton() { std::cout << "Singleton Destructor" << std::endl; }
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
};

int main() {
    Singleton& s1 = Singleton::getInstance();
    Singleton& s2 = Singleton::getInstance();
    return 0;
}

#include <iostream>

void useRawPointer() {
    int* ptr = new int(42);
    std::cout << "Value: " << *ptr << std::endl;
    delete ptr;
}

int main() {
    useRawPointer();
    return 0;
}

#include <iostream>
#include <memory>

void useSmartPointer() {
    std::unique_ptr<int> ptr = std::make_unique<int>(42);
    std::cout << "Value: " << *ptr << std::endl;
}

int main() {
    useSmartPointer();
    return 0;
}

#include <iostream>
#include <fstream>

class FileManager {
public:
    FileManager(const std::string& filename) : file(filename) {
        if (!file.is_open()) {
            throw std::runtime_error("Unable to open file");
        }
    }
    ~FileManager() {
        if (file.is_open()) {
            file.close();
        }
    }
    void write(const std::string& data) {
        if (file.is_open()) {
            file << data;
        }
    }
private:
    std::ofstream file;
};

void useFileManager() {
    try {
        FileManager fileManager("example.txt");
        fileManager.write("Hello, RAII!");
    } catch (const std::exception& e) {
        std::cerr << "Error: " << e.what() << std::endl;
    }
}

int main() {
    useFileManager();
    return 0;
}

#include <iostream>

class MyClass {
public:
    MyClass() { std::cout << "MyClass Constructor" << std::endl; }
    ~MyClass() { std::cout << "MyClass Destructor" << std::endl; }
};

void createMemoryLeak() {
    MyClass* obj = new MyClass();
    // メモリが解放されない
}

int main() {
    createMemoryLeak();
    return 0;
}

#include <iostream>
#include <memory>

class MyClass {
public:
    MyClass() { std::cout << "MyClass Constructor" << std::endl; }
    ~MyClass() { std::cout << "MyClass Destructor" << std::endl; }
};

void fixMemoryLeak() {
    std::unique_ptr<MyClass> obj = std::make_unique<MyClass>();
    // スマートポインタがスコープを抜けると自動的にメモリが解放される
}

int main() {
    fixMemoryLeak();
    return 0;
}

#include <iostream>
#include <memory>

class B;

class A {
public:
    std::shared_ptr<B> ptr;
    ~A() { std::cout << "A Destructor" << std::endl; }
};

class B {
public:
    std::shared_ptr<A> ptr;
    ~B() { std::cout << "B Destructor" << std::endl; }
};

void createCircularReference() {
    std::shared_ptr<A> a = std::make_shared<A>();
    std::shared_ptr<B> b = std::make_shared<B>();
    a->ptr = b;
    b->ptr = a;
    // メモリリークが発生する
}

int main() {
    createCircularReference();
    return 0;
}

#include <iostream>
#include <memory>

class B;

class A {
public:
    std::shared_ptr<B> ptr;
    ~A() { std::cout << "A Destructor" << std::endl; }
};

class B {
public:
    std::weak_ptr<A> ptr; // weak_ptrを使って循環参照を回避
    ~B() { std::cout << "B Destructor" << std::endl; }
};

void createCircularReference() {
    std::shared_ptr<A> a = std::make_shared<A>();
    std::shared_ptr<B> b = std::make_shared<B>();
    a->ptr = b;
    b->ptr = a;
    // 循環参照を避けることでメモリリークを防ぐ
}

int main() {
    createCircularReference();
    return 0;
}