[C++] スマートポインタの基本的な使い方と活用法

#include <iostream>
#include <memory> // std::unique_ptrを使用するために必要
class MyClass {
public:
    MyClass() { std::cout << "MyClassのコンストラクタ" << std::endl; }
    ~MyClass() { std::cout << "MyClassのデストラクタ" << std::endl; }
};
int main() {
    std::unique_ptr<MyClass> ptr(new MyClass()); // MyClassのインスタンスを管理
    return 0; // ptrがスコープを抜けると自動的にメモリが解放される
}

MyClassのコンストラクタ
MyClassのデストラクタ

#include <iostream>
#include <memory> // std::shared_ptrを使用するために必要
class MyClass {
public:
    MyClass() { std::cout << "MyClassのコンストラクタ" << std::endl; }
    ~MyClass() { std::cout << "MyClassのデストラクタ" << std::endl; }
};
int main() {
    std::shared_ptr<MyClass> ptr1(new MyClass()); // MyClassのインスタンスを管理
    {
        std::shared_ptr<MyClass> ptr2 = ptr1; // ptr1とptr2が同じリソースを共有
        std::cout << "ptr2がスコープ内にあります" << std::endl;
    } // ptr2がスコープを抜けるが、ptr1がまだ存在するためメモリは解放されない
    return 0; // ptr1がスコープを抜けるとメモリが解放される
}

MyClassのコンストラクタ
ptr2がスコープ内にあります
MyClassのデストラクタ

#include <iostream>
#include <memory> // std::weak_ptrを使用するために必要
class MyClass {
public:
    MyClass() { std::cout << "MyClassのコンストラクタ" << std::endl; }
    ~MyClass() { std::cout << "MyClassのデストラクタ" << std::endl; }
};
int main() {
    std::shared_ptr<MyClass> sharedPtr(new MyClass()); // MyClassのインスタンスを管理
    std::weak_ptr<MyClass> weakPtr = sharedPtr; // weak_ptrがshared_ptrを参照
    if (auto tempPtr = weakPtr.lock()) { // weak_ptrからshared_ptrを取得
        std::cout << "リソースはまだ存在します" << std::endl;
    } else {
        std::cout << "リソースは解放されています" << std::endl;
    }
    sharedPtr.reset(); // shared_ptrをリセット
    if (auto tempPtr = weakPtr.lock()) {
        std::cout << "リソースはまだ存在します" << std::endl;
    } else {
        std::cout << "リソースは解放されています" << std::endl;
    }
    return 0;
}

MyClassのコンストラクタ
リソースはまだ存在します
リソースは解放されています
MyClassのデストラクタ

#include <iostream>
#include <memory> // std::unique_ptrを使用するために必要
class MyClass {
public:
    MyClass() { std::cout << "MyClassのコンストラクタ" << std::endl; }
    ~MyClass() { std::cout << "MyClassのデストラクタ" << std::endl; }
};
int main() {
    std::unique_ptr<MyClass> ptr(new MyClass()); // MyClassのインスタンスを管理
    // ptrがスコープを抜けると自動的にメモリが解放される
    return 0;
}

MyClassのコンストラクタ
MyClassのデストラクタ

#include <iostream>
#include <memory> // std::shared_ptrを使用するために必要
class MyClass {
public:
    MyClass() { std::cout << "MyClassのコンストラクタ" << std::endl; }
    ~MyClass() { std::cout << "MyClassのデストラクタ" << std::endl; }
};
int main() {
    std::shared_ptr<MyClass> ptr1(new MyClass()); // MyClassのインスタンスを管理
    {
        std::shared_ptr<MyClass> ptr2 = ptr1; // ptr1とptr2が同じリソースを共有
        std::cout << "ptr2がスコープ内にあります" << std::endl;
    } // ptr2がスコープを抜けるが、ptr1がまだ存在するためメモリは解放されない
    return 0; // ptr1がスコープを抜けるとメモリが解放される
}

MyClassのコンストラクタ
ptr2がスコープ内にあります
MyClassのデストラクタ

#include <iostream>
#include <memory> // std::weak_ptrを使用するために必要
class MyClass {
public:
    MyClass() { std::cout << "MyClassのコンストラクタ" << std::endl; }
    ~MyClass() { std::cout << "MyClassのデストラクタ" << std::endl; }
};
int main() {
    std::shared_ptr<MyClass> sharedPtr(new MyClass()); // MyClassのインスタンスを管理
    std::weak_ptr<MyClass> weakPtr = sharedPtr; // weak_ptrがshared_ptrを参照
    if (auto tempPtr = weakPtr.lock()) { // weak_ptrからshared_ptrを取得
        std::cout << "リソースはまだ存在します" << std::endl;
    } else {
        std::cout << "リソースは解放されています" << std::endl;
    }
    sharedPtr.reset(); // shared_ptrをリセット
    if (auto tempPtr = weakPtr.lock()) {
        std::cout << "リソースはまだ存在します" << std::endl;
    } else {
        std::cout << "リソースは解放されています" << std::endl;
    }
    return 0;
}

MyClassのコンストラクタ
リソースはまだ存在します
リソースは解放されています
MyClassのデストラクタ

#include <iostream>
#include <memory> // std::unique_ptrを使用するために必要
class Resource {
public:
    Resource() { std::cout << "リソースの取得" << std::endl; }
    ~Resource() { std::cout << "リソースの解放" << std::endl; }
};
void useResource() {
    std::unique_ptr<Resource> resPtr(new Resource()); // リソースを管理
    // ここでリソースを使用する処理
} // resPtrがスコープを抜けると自動的に解放される
int main() {
    useResource(); // リソースを使用
    return 0;
}

リソースの取得
リソースの解放

#include <iostream>
#include <memory> // std::shared_ptrを使用するために必要
#include <thread> // スレッドを使用するために必要
class SharedResource {
public:
    SharedResource() { std::cout << "共有リソースの取得" << std::endl; }
    ~SharedResource() { std::cout << "共有リソースの解放" << std::endl; }
};
void threadFunction(std::shared_ptr<SharedResource> resPtr) {
    // 共有リソースを使用する処理
    std::cout << "スレッドでリソースを使用中" << std::endl;
}
int main() {
    std::shared_ptr<SharedResource> resPtr(new SharedResource()); // 共有リソースを管理
    std::thread t1(threadFunction, resPtr); // スレッドを作成
    std::thread t2(threadFunction, resPtr); // 別のスレッドを作成
    t1.join(); // スレッドの終了を待つ
    t2.join(); // スレッドの終了を待つ
    return 0; // resPtrがスコープを抜けるとメモリが解放される
}

共有リソースの取得
スレッドでリソースを使用中
スレッドでリソースを使用中
共有リソースの解放

#include <iostream>
#include <memory> // std::weak_ptrを使用するために必要
class Parent; // 前方宣言
class Child {
public:
    std::weak_ptr<Parent> parentPtr; // weak_ptrを使用
    Child() { std::cout << "子オブジェクトの生成" << std::endl; }
    ~Child() { std::cout << "子オブジェクトの破棄" << std::endl; }
};
class Parent {
public:
    std::shared_ptr<Child> childPtr; // shared_ptrを使用
    Parent() { std::cout << "親オブジェクトの生成" << std::endl; }
    ~Parent() { std::cout << "親オブジェクトの破棄" << std::endl; }
};
int main() {
    std::shared_ptr<Parent> parentPtr(new Parent()); // 親オブジェクトを管理
    parentPtr->childPtr = std::shared_ptr<Child>(new Child()); // 子オブジェクトを管理
    parentPtr->childPtr->parentPtr = parentPtr; // weak_ptrで親を参照
    return 0; // 親と子のオブジェクトがスコープを抜けると自動的に解放される
}

親オブジェクトの生成
子オブジェクトの生成
親オブジェクトの破棄
子オブジェクトの破棄

#include <iostream>
#include <memory> // std::shared_ptrを使用するために必要
class MyClass {
public:
    MyClass() { std::cout << "MyClassのコンストラクタ" << std::endl; }
    ~MyClass() { std::cout << "MyClassのデストラクタ" << std::endl; }
};
void processResource(const std::shared_ptr<MyClass>& ptr) { // 参照渡しを使用
    std::cout << "リソースを処理中" << std::endl;
}
int main() {
    std::shared_ptr<MyClass> myPtr(new MyClass()); // MyClassのインスタンスを管理
    processResource(myPtr); // 参照を渡す
    return 0; // myPtrがスコープを抜けるとメモリが解放される
}

MyClassのコンストラクタ
リソースを処理中
MyClassのデストラクタ

#include <iostream>
#include <memory> // スマートポインタを使用するために必要
#include <vector> // std::vectorを使用するために必要
#include <string> // std::stringを使用するために必要
class Book {
public:
    Book(const std::string& title) : title(title) {
        std::cout << "本の作成: " << title << std::endl;
    }
    ~Book() {
        std::cout << "本の破棄: " << title << std::endl;
    }
    void display() const {
        std::cout << "タイトル: " << title << std::endl;
    }
private:
    std::string title; // 本のタイトル
};
class Library {
public:
    void addBook(const std::shared_ptr<Book>& book) {
        books.push_back(book); // 本を追加
    }
    void lendBook(const std::string& title) {
        for (const auto& book : books) {
            if (book) {
                book->display(); // 本の情報を表示
            }
        }
    }
private:
    std::vector<std::shared_ptr<Book>> books; // 本のリスト
};
int main() {
    Library library; // 図書館のインスタンスを作成
    // 本を作成し、図書館に追加
    std::shared_ptr<Book> book1 = std::make_shared<Book>("C++プログラミング入門");
    std::shared_ptr<Book> book2 = std::make_shared<Book>("デザインパターン");
    
    library.addBook(book1); // 図書館に本を追加
    library.addBook(book2); // 図書館に本を追加
    // 本を貸出
    std::cout << "貸出中の本:" << std::endl;
    library.lendBook("C++プログラミング入門");
    return 0; // スコープを抜けると自動的にメモリが解放される
}

本の作成: C++プログラミング入門
本の作成: デザインパターン
貸出中の本:
タイトル: C++プログラミング入門
本の破棄: C++プログラミング入門
本の破棄: デザインパターン