[C++] スマートポインタとデストラクタの自動メモリ管理

#include <iostream>
class MyClass {
public:
    MyClass() {
        std::cout << "コンストラクタが呼ばれました" << std::endl;
    }
    
    ~MyClass() {
        std::cout << "デストラクタが呼ばれました" << std::endl;
    }
};
int main() {
    MyClass obj; // オブジェクトが生成される
    return 0; // スコープを抜けるとデストラクタが呼ばれる
}

コンストラクタが呼ばれました
デストラクタが呼ばれました

#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()); // unique_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()); // 最初のshared_ptr
    {
        std::shared_ptr<MyClass> ptr2 = ptr1; // ptr1を共有
        std::cout << "ptr1とptr2が同じオブジェクトを指しています" << std::endl;
    } // ptr2がスコープを抜けると参照カウントが減る
    return 0; // ptr1がスコープを抜けるとデストラクタが呼ばれる
}

MyClassのコンストラクタが呼ばれました
ptr1と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()); // shared_ptrを作成
    std::weak_ptr<MyClass> weakPtr = sharedPtr; // weak_ptrを作成
    if (auto tempPtr = weakPtr.lock()) { // weak_ptrからshared_ptrを取得
        std::cout << "weak_ptrからshared_ptrを取得しました" << std::endl;
    } else {
        std::cout << "オブジェクトは既に破棄されています" << std::endl;
    }
    
    return 0; // sharedPtrがスコープを抜けるとデストラクタが呼ばれる
}

MyClassのコンストラクタが呼ばれました
weak_ptrからshared_ptrを取得しました
MyClassのデストラクタが呼ばれました

#include <iostream>
#include <memory> // std::unique_ptrを使用するために必要
int main() {
    std::unique_ptr<int[]> arr(new int[5]); // int型の配列をunique_ptrで管理
    for (int i = 0; i < 5; ++i) {
        arr[i] = i * 10; // 配列に値を代入
    }
    for (int i = 0; i < 5; ++i) {
        std::cout << "arr[" << i << "] = " << arr[i] << std::endl; // 配列の値を表示
    }
    return 0; // スコープを抜けるとデストラクタが呼ばれ、メモリが解放される
}

arr[0] = 0
arr[1] = 10
arr[2] = 20
arr[3] = 30
arr[4] = 40

#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()); // 最初のshared_ptr
    {
        std::shared_ptr<MyClass> ptr2 = ptr1; // ptr1を共有
        std::cout << "ptr1とptr2が同じオブジェクトを指しています" << std::endl;
    } // ptr2がスコープを抜けると参照カウントが減る
    return 0; // ptr1がスコープを抜けるとデストラクタが呼ばれる
}

MyClassのコンストラクタが呼ばれました
ptr1とptr2が同じオブジェクトを指しています
MyClassのデストラクタが呼ばれました

#include <iostream>
#include <memory> // std::weak_ptrを使用するために必要
class Parent; // 前方宣言
class Child {
public:
    std::weak_ptr<Parent> parent; // weak_ptrを使用して親を参照
    Child() {
        std::cout << "Childのコンストラクタが呼ばれました" << std::endl;
    }
    
    ~Child() {
        std::cout << "Childのデストラクタが呼ばれました" << std::endl;
    }
};
class Parent {
public:
    std::shared_ptr<Child> child; // shared_ptrを使用して子を参照
    Parent() {
        std::cout << "Parentのコンストラクタが呼ばれました" << std::endl;
    }
    
    ~Parent() {
        std::cout << "Parentのデストラクタが呼ばれました" << std::endl;
    }
};
int main() {
    std::shared_ptr<Parent> parentPtr(new Parent()); // Parentのインスタンスを作成
    std::shared_ptr<Child> childPtr(new Child()); // Childのインスタンスを作成
    parentPtr->child = childPtr; // ParentがChildを参照
    childPtr->parent = parentPtr; // ChildがParentをweak_ptrで参照
    return 0; // スコープを抜けるとデストラクタが呼ばれる
}

Parentのコンストラクタが呼ばれました
Childのコンストラクタが呼ばれました
Childのデストラクタが呼ばれました
Parentのデストラクタが呼ばれました

#include <iostream>
#include <memory> // std::shared_ptrとstd::weak_ptrを使用するために必要
class A; // 前方宣言
class B {
public:
    std::shared_ptr<A> aPtr; // Aへのshared_ptr
    ~B() {
        std::cout << "Bのデストラクタが呼ばれました" << std::endl;
    }
};
class A {
public:
    std::shared_ptr<B> bPtr; // Bへのshared_ptr
    ~A() {
        std::cout << "Aのデストラクタが呼ばれました" << std::endl;
    }
};
int main() {
    std::shared_ptr<A> a(new A());
    std::shared_ptr<B> b(new B());
    a->bPtr = b; // AがBを参照
    b->aPtr = a; // BがAを参照
    return 0; // 循環参照が発生し、メモリリークが起こる
}

#include <iostream>
#include <memory> // スマートポインタを使用するために必要
void process(std::unique_ptr<int> ptr) { // unique_ptrを引数に取る
    std::cout << "値: " << *ptr << std::endl;
}
int main() {
    std::unique_ptr<int> myPtr(new int(42));
    process(std::move(myPtr)); // 所有権を移動
    // myPtrはここで無効になるため、以下の行はコメントアウトする必要がある
    // std::cout << *myPtr << std::endl; // エラーになる
    return 0;
}

#include <iostream>
#include <memory> // スマートポインタを使用するために必要
void process(const std::shared_ptr<int>& ptr) { // 参照で受け取る
    std::cout << "値: " << *ptr << std::endl;
}
int main() {
    std::shared_ptr<int> myPtr(new int(42));
    process(myPtr); // コピーせずに参照を渡す
    return 0;
}