第13章: モダンC++の流儀：RAIIとスマートポインタ

#include <iostream>
#include <stdexcept> // std::runtime_error のために必要

// 0で割ろうとしたら例外を投げる関数
double divide(int a, int b) {
    if (b == 0) {
        // エラー内容を示す文字列を渡して例外オブジェクトを作成し、投げる
        throw std::runtime_error("Division by zero!");
    }
    return static_cast<double>(a) / b;
}

int main() {
    int a = 10;
    int b = 0;

    try {
        // 例外が発生する可能性のあるコード
        std::cout << "Trying to divide..." << std::endl;
        double result = divide(a, b);
        std::cout << "Result: " << result << std::endl; // この行は実行されない
    } catch (const std::runtime_error& e) {
        // std::runtime_error 型の例外をここで捕まえる
        std::cerr << "Caught an exception: " << e.what() << std::endl;
    }

    std::cout << "Program finished." << std::endl;
    return 0;
}

#include <iostream>
#include <stdexcept>

void process_data() {
    int* data = new int[100]; // リソース確保
    std::cout << "Data allocated." << std::endl;

    // 何らかの処理...
    bool something_wrong = true;
    if (something_wrong) {
        throw std::runtime_error("Something went wrong during processing!");
    }

    // 例外が投げられると、この行には到達しない
    std::cout << "Deleting data..." << std::endl;
    delete[] data; // リソース解放
}

int main() {
    try {
        process_data();
    } catch (const std::runtime_error& e) {
        std::cerr << "Error: " << e.what() << std::endl;
    }
    // process_data内で確保されたメモリは解放されないままである！
    return 0;
}

#include <iostream>

class ResourceWrapper {
private:
    int* m_data;

public:
    // コンストラクタでリソースを確保
    ResourceWrapper() {
        m_data = new int[10];
        std::cout << "Resource acquired." << std::endl;
    }

    // デストラクタでリソースを解放
    ~ResourceWrapper() {
        delete[] m_data;
        std::cout << "Resource released." << std::endl;
    }
};

void use_resource() {
    ResourceWrapper rw; // オブジェクトが生成され、コンストラクタでリソースが確保される
    std::cout << "Using resource..." << std::endl;

    // この関数が終了するとき (正常終了でも例外でも)、
    // rwのデストラクタが自動的に呼ばれ、リソースが解放される
}

int main() {
    std::cout << "Entering main." << std::endl;
    use_resource();
    std::cout << "Exiting main." << std::endl;
    return 0;
}

#include <iostream>
#include <memory> // スマートポインタのために必要
#include <utility> // std::moveのために必要

struct MyData {
    MyData() { std::cout << "MyData constructor" << std::endl; }
    ~MyData() { std::cout << "MyData destructor" << std::endl; }
    void greet() { std::cout << "Hello from MyData!" << std::endl; }
};

void process_ptr(std::unique_ptr<MyData> ptr) {
    std::cout << "Inside process_ptr" << std::endl;
    ptr->greet();
    // ptrがこの関数のスコープを抜けるときにデストラクタが呼ばれる
}

int main() {
    std::cout << "--- Block 1 ---" << std::endl;
    {
        // std::make_unique を使ってオブジェクトを生成し、unique_ptrで管理
        std::unique_ptr<MyData> u_ptr1 = std::make_unique<MyData>();
        
        // 生ポインタと同じように -> や * でメンバにアクセスできる
        u_ptr1->greet();

        // コピーはコンパイルエラーになる
        // std::unique_ptr<MyData> u_ptr2 = u_ptr1; // ERROR!

        // 所有権を u_ptr3 に移動 (ムーブ)
        std::unique_ptr<MyData> u_ptr3 = std::move(u_ptr1);
        
        // ムーブ後、u_ptr1 は空(nullptr)になる
        if (u_ptr1 == nullptr) {
            std::cout << "u_ptr1 is now empty." << std::endl;
        }

        u_ptr3->greet();
    } // ブロックを抜けると u_ptr3 が破棄され、MyDataのデストラクタが呼ばれる
    
    std::cout << "\n--- Block 2 ---" << std::endl;
    {
        auto u_ptr4 = std::make_unique<MyData>();
        // 関数の引数に渡すことで所有権を譲渡する
        process_ptr(std::move(u_ptr4));
        std::cout << "Returned from process_ptr" << std::endl;
    }
    
    std::cout << "\nProgram finished." << std::endl;
    return 0;
}

#include <iostream>
#include <memory>
#include <vector>

struct MyResource {
    MyResource() { std::cout << "MyResource constructor" << std::endl; }
    ~MyResource() { std::cout << "MyResource destructor" << std::endl; }
};

int main() {
    std::shared_ptr<MyResource> s_ptr1; // 空のshared_ptr

    std::cout << "--- Block 1 ---" << std::endl;
    {
        // std::make_shared を使ってオブジェクトを生成し、shared_ptrで管理
        s_ptr1 = std::make_shared<MyResource>();
        std::cout << "Use count: " << s_ptr1.use_count() << std::endl; // 1

        {
            // s_ptr2 は s_ptr1 と同じオブジェクトを指す
            std::shared_ptr<MyResource> s_ptr2 = s_ptr1;
            std::cout << "Use count: " << s_ptr1.use_count() << std::endl; // 2
            std::cout << "Use count: " << s_ptr2.use_count() << std::endl; // 2
        } // s_ptr2がスコープを抜ける。参照カウンタが1に減る

        std::cout << "Use count after s_ptr2 is gone: " << s_ptr1.use_count() << std::endl; // 1
    } // s_ptr1がスコープを抜ける。参照カウンタが0になり、オブジェクトが破棄される

    std::cout << "\n--- Block 2 ---" << std::endl;
    {
        auto shared_res = std::make_shared<MyResource>();
        std::cout << "Initial use count: " << shared_res.use_count() << std::endl; // 1

        std::vector<std::shared_ptr<MyResource>> ptr_vec;
        ptr_vec.push_back(shared_res); // コピー。参照カウンタは2
        ptr_vec.push_back(shared_res); // コピー。参照カウンタは3
        
        std::cout << "Use count after pushing to vector: " << shared_res.use_count() << std::endl; // 3
    } // shared_resとptr_vecがスコープを抜ける。
      // 全てのshared_ptrが破棄され、最後に参照カウンタが0になり、オブジェクトが破棄される

    std::cout << "\nProgram finished." << std::endl;
    return 0;
}

#include <iostream>
#include <memory>
#include <string>

// ここにEmployeeクラスを定義


int main() {


}

#include <iostream>
#include <memory>
#include <vector>
#include <string>

// ここにProjectクラスを定義


int main() {


}