[C++] ポインタのコピーとメモリ管理の注意点

#include <iostream>
int main() {
    int value = 42; // 整数型の変数
    int* pointer = &value; // valueのアドレスをpointerに格納
    std::cout << "valueの値: " << value << std::endl; // 42
    std::cout << "pointerが指す値: " << *pointer << std::endl; // 42
    std::cout << "valueのアドレス: " << &value << std::endl; // valueのアドレス
    std::cout << "pointerの値: " << pointer << std::endl; // valueのアドレス
    return 0;
}

valueの値: 42
pointerが指す値: 42
valueのアドレス: 0x7ffee3b1c8bc (例)
pointerの値: 0x7ffee3b1c8bc (例)

#include <iostream>
int main() {
    int value = 100; // 整数型の変数
    int* originalPointer = &value; // 元のポインタ
    int* copiedPointer = originalPointer; // ポインタのコピー
    std::cout << "originalPointerが指す値: " << *originalPointer << std::endl; // 100
    std::cout << "copiedPointerが指す値: " << *copiedPointer << std::endl; // 100
    // copiedPointerを使ってvalueの値を変更
    *copiedPointer = 200; // valueの値を変更
    std::cout << "originalPointerが指す値: " << *originalPointer << std::endl; // 200
    std::cout << "copiedPointerが指す値: " << *copiedPointer << std::endl; // 200
    return 0;
}

originalPointerが指す値: 100
copiedPointerが指す値: 100
originalPointerが指す値: 200
copiedPointerが指す値: 200

#include <iostream>
int main() {
    int* pointer = new int(42); // 動的メモリの確保
    int* copiedPointer = pointer; // ポインタのコピー
    delete pointer; // メモリを解放
    // copiedPointerはダングリングポインタになる
    // std::cout << *copiedPointer; // 未定義の動作
    return 0;
}

#include <iostream>
int main() {
    int* pointer = new int(100); // 動的メモリの確保
    int* copiedPointer = pointer; // ポインタのコピー
    delete pointer; // メモリを解放
    // copiedPointerは解放されていないため、メモリリークが発生
    return 0;
}

#include <iostream>
#include <thread>
int* sharedPointer; // 共有ポインタ
void threadFunction() {
    *sharedPointer = 200; // 競合状態が発生する可能性
}
int main() {
    sharedPointer = new int(100); // 動的メモリの確保
    std::thread t1(threadFunction);
    std::thread t2(threadFunction);
    t1.join();
    t2.join();
    std::cout << "sharedPointerの値: " << *sharedPointer << std::endl; // 未定義の動作
    delete sharedPointer; // メモリを解放
    return 0;
}

#include <iostream>
class Data {
public:
    int value;
    Data(int v) : value(v) {}
};
int main() {
    Data* originalData = new Data(42); // 動的メモリの確保
    Data* copiedData = new Data(*originalData); // 深いコピー
    copiedData->value = 100; // copiedDataの値を変更
    std::cout << "originalDataの値: " << originalData->value << std::endl; // 42
    std::cout << "copiedDataの値: " << copiedData->value << std::endl; // 100
    delete originalData; // メモリを解放
    delete copiedData; // メモリを解放
    return 0;
}

#include <iostream>
#include <memory> // std::unique_ptrを使用するために必要
int main() {
    std::unique_ptr<int> uniquePtr(new int(42)); // unique_ptrの作成
    std::cout << "uniquePtrが指す値: " << *uniquePtr << std::endl; // 42
    // uniquePtrはスコープを抜けると自動的にメモリを解放
    return 0;
}

uniquePtrが指す値: 42

#include <iostream>
#include <memory> // std::shared_ptrを使用するために必要
int main() {
    std::shared_ptr<int> sharedPtr1(new int(100)); // shared_ptrの作成
    std::shared_ptr<int> sharedPtr2 = sharedPtr1; // 共有
    std::cout << "sharedPtr1が指す値: " << *sharedPtr1 << std::endl; // 100
    std::cout << "sharedPtr2が指す値: " << *sharedPtr2 << std::endl; // 100
    // sharedPtr1とsharedPtr2がスコープを抜けると自動的にメモリを解放
    return 0;
}

sharedPtr1が指す値: 100
sharedPtr2が指す値: 100

#include <iostream>
#include <memory> // std::weak_ptrを使用するために必要
int main() {
    std::shared_ptr<int> sharedPtr(new int(200)); // shared_ptrの作成
    std::weak_ptr<int> weakPtr = sharedPtr; // weak_ptrの作成
    if (auto lockedPtr = weakPtr.lock()) { // weak_ptrからshared_ptrを取得
        std::cout << "weakPtrが指す値: " << *lockedPtr << std::endl; // 200
    } else {
        std::cout << "メモリは解放されています。" << std::endl;
    }
    sharedPtr.reset(); // shared_ptrをリセット
    if (auto lockedPtr = weakPtr.lock()) {
        std::cout << "weakPtrが指す値: " << *lockedPtr << std::endl;
    } else {
        std::cout << "メモリは解放されています。" << std::endl; // メモリは解放されている
    }
    return 0;
}

weakPtrが指す値: 200
メモリは解放されています。

#include <iostream>
class Singleton {
private:
    static Singleton* instance; // インスタンスのポインタ
    Singleton() {} // コンストラクタをプライベートに
public:
    static Singleton* getInstance() {
        if (!instance) {
            instance = new Singleton(); // インスタンスを生成
        }
        return instance;
    }
};
Singleton* Singleton::instance = nullptr; // インスタンスの初期化
int main() {
    Singleton* singleton1 = Singleton::getInstance();
    Singleton* singleton2 = Singleton::getInstance();
    std::cout << "singleton1のアドレス: " << singleton1 << std::endl;
    std::cout << "singleton2のアドレス: " << singleton2 << std::endl; // 同じアドレス
    return 0;
}

singleton1のアドレス: 0x55f8c1e0b0d0 (例)
singleton2のアドレス: 0x55f8c1e0b0d0 (例)

#include <iostream>
class Product {
public:
    virtual void use() = 0; // 純粋仮想関数
};
class ConcreteProduct : public Product {
public:
    void use() override {
        std::cout << "ConcreteProductを使用しています。" << std::endl;
    }
};
class Factory {
public:
    static Product* createProduct() {
        return new ConcreteProduct(); // 新しいオブジェクトを生成
    }
};
int main() {
    Product* product = Factory::createProduct(); // ファクトリーを使用してオブジェクトを生成
    product->use(); // オブジェクトを使用
    delete product; // メモリを解放
    return 0;
}

ConcreteProductを使用しています。

#include <iostream>
#include <vector>
class Observer {
public:
    virtual void update() = 0; // 純粋仮想関数
};
class Subject {
private:
    std::vector<Observer*> observers; // オブザーバーのリスト
public:
    void attach(Observer* observer) {
        observers.push_back(observer); // オブザーバーを追加
    }
    void notify() {
        for (Observer* observer : observers) {
            observer->update(); // オブザーバーに通知
        }
    }
};
class ConcreteObserver : public Observer {
public:
    void update() override {
        std::cout << "状態が更新されました。" << std::endl;
    }
};
int main() {
    Subject subject;
    ConcreteObserver observer;
    subject.attach(&observer); // オブザーバーを登録
    subject.notify(); // 通知を送信
    return 0;
}

状態が更新されました。

#include <iostream>
class MyClass {
private:
    int* data;
public:
    MyClass(int value) {
        data = new int(value); // 動的メモリの確保
    }
    // コピーコンストラクタ
    MyClass(const MyClass& other) {
        data = new int(*other.data); // 深いコピー
    }
    // 代入演算子のオーバーロード
    MyClass& operator=(const MyClass& other) {
        if (this != &other) {
            delete data; // 既存のメモリを解放
            data = new int(*other.data); // 深いコピー
        }
        return *this;
    }
    ~MyClass() {
        delete data; // メモリを解放
    }
    void show() const {
        std::cout << "dataの値: " << *data << std::endl;
    }
};
int main() {
    MyClass obj1(42); // オブジェクトの生成
    MyClass obj2 = obj1; // コピーコンストラクタの呼び出し
    obj1.show(); // 42
    obj2.show(); // 42
    return 0;
}

dataの値: 42
dataの値: 42

#include <iostream>
#include <memory> // スマートポインタを使用するために必要
int main() {
    std::unique_ptr<int> smartPtr(new int(42)); // unique_ptrの作成
    std::cout << "smartPtrが指す値: " << *smartPtr << std::endl; // 42
    // スコープを抜けると自動的にメモリが解放される
    return 0;
}

smartPtrが指す値: 42

#include <iostream>
int main() {
    int* ptr = new int(100); // 動的メモリの確保
    std::cout << "ptrが指す値: " << *ptr << std::endl; // 100
    delete ptr; // メモリを解放
    return 0;
}

ptrが指す値: 100

#include <iostream>
class MyClass {
private:
    int* data;
public:
    MyClass(int value) {
        data = new int(value); // 動的メモリの確保
    }
    // コピーコンストラクタ
    MyClass(const MyClass& other) {
        data = new int(*other.data); // 深いコピー
    }
    // 代入演算子のオーバーロード
    MyClass& operator=(const MyClass& other) {
        if (this != &other) {
            delete data; // 既存のメモリを解放
            data = new int(*other.data); // 深いコピー
        }
        return *this;
    }
    ~MyClass() {
        delete data; // メモリを解放
    }
    void show() const {
        std::cout << "dataの値: " << *data << std::endl;
    }
};
int main() {
    MyClass obj1(42); // オブジェクトの生成
    MyClass obj2 = obj1; // コピーコンストラクタの呼び出し
    obj1.show(); // 42
    obj2.show(); // 42
    return 0;
}

dataの値: 42
dataの値: 42

#include <iostream>
#include <memory> // スマートポインタを使用するために必要
class Resource {
public:
    Resource() {
        std::cout << "リソースを取得しました。" << std::endl;
    }
    ~Resource() {
        std::cout << "リソースを解放しました。" << std::endl;
    }
};
void function() {
    std::unique_ptr<Resource> res(new Resource()); // RAIIを使用
    throw std::runtime_error("例外が発生しました。"); // 例外を発生させる
}
int main() {
    try {
        function();
    } catch (const std::exception& e) {
        std::cout << e.what() << std::endl; // 例外メッセージを表示
    }
    return 0;
}

リソースを取得しました。
例外が発生しました。
リソースを解放しました。