C++でスマートポインタを使用した安全なコールバックの実装方法

std::unique_ptr<int> ptr = std::make_unique<int>(10);

std::shared_ptr<int> ptr1 = std::make_shared<int>(10);
std::shared_ptr<int> ptr2 = ptr1; // ptr1とptr2は同じリソースを共有する

std::shared_ptr<int> sharedPtr = std::make_shared<int>(10);
std::weak_ptr<int> weakPtr = sharedPtr; // sharedPtrの弱い参照

int* ptr = new int(10);
// メモリを使用
delete ptr; // メモリを解放

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

#include <iostream>

// コールバック関数
void onEvent(int result) {
    std::cout << "Event result: " << result << std::endl;
}

// 関数の引数としてコールバックを受け取る
void performAction(void(*callback)(int)) {
    // 何らかの処理
    int result = 42; // 仮の結果
    callback(result); // コールバックを呼び出す
}

int main() {
    performAction(onEvent);
    return 0;
}

#include <iostream>
#include <memory>
#include <functional>

// クラス定義
class MyClass {
public:
    void memberFunction(int result) {
        std::cout << "Member function called with result: " << result << std::endl;
    }
};

// コールバック関数を呼び出す関数
void performAction(const std::function<void(int)>& callback) {
    int result = 42; // 仮の結果
    callback(result); // コールバックを呼び出す
}

int main() {
    std::shared_ptr<MyClass> obj = std::make_shared<MyClass>();

    // std::shared_ptrを使ったコールバック
    performAction([obj](int result) {
        obj->memberFunction(result);
    });

    return 0;
}

#include <iostream>
#include <memory>
#include <functional>

class MyClass {
public:
    void memberFunction(int result) {
        std::cout << "Member function called with result: " << result << std::endl;
    }
};

void performAction(const std::function<void(int)>& callback) {
    int result = 42; // 仮の結果
    callback(result); // コールバックを呼び出す
}

int main() {
    std::shared_ptr<MyClass> obj = std::make_shared<MyClass>();
    std::weak_ptr<MyClass> weakObj = obj;

    performAction([weakObj](int result) {
        if (auto sharedObj = weakObj.lock()) {
            sharedObj->memberFunction(result);
        } else {
            std::cout << "Object no longer exists." << std::endl;
        }
    });

    return 0;
}

#include <iostream>
#include <memory>
#include <functional>

// ファイル読み込みをシミュレートするクラス
class FileLoader {
public:
    void loadFile(const std::function<void(int)>& callback) {
        // ファイル読み込み処理のシミュレーション
        int result = 100; // ファイルサイズ（仮）
        callback(result); // コールバックを呼び出す
    }
};

// コールバックを持つクラス
class MyClass : public std::enable_shared_from_this<MyClass> {
public:
    void startLoading() {
        loader = std::make_shared<FileLoader>();
        loader->loadFile(std::bind(&MyClass::onFileLoaded, shared_from_this(), std::placeholders::_1));
    }

    void onFileLoaded(int fileSize) {
        std::cout << "File loaded with size: " << fileSize << std::endl;
    }

private:
    std::shared_ptr<FileLoader> loader;
};

int main() {
    std::shared_ptr<MyClass> obj = std::make_shared<MyClass>();
    obj->startLoading();

    // objがここでスコープを抜けると自動的に破棄される
    return 0;
}

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

// イベント管理クラス
class EventManager {
public:
    void addListener(const std::function<void(int)>& listener) {
        listeners.push_back(listener);
    }

    void triggerEvent(int eventCode) {
        for (const auto& listener : listeners) {
            listener(eventCode);
        }
    }

private:
    std::vector<std::function<void(int)>> listeners;
};

// コールバックを持つクラス
class MyClass : public std::enable_shared_from_this<MyClass> {
public:
    MyClass(const std::shared_ptr<EventManager>& eventManager) : eventManager(eventManager) {}

    void startListening() {
        eventManager->addListener(std::bind(&MyClass::onEventTriggered, shared_from_this(), std::placeholders::_1));
    }

    void onEventTriggered(int eventCode) {
        std::cout << "Event triggered with code: " << eventCode << std::endl;
    }

private:
    std::shared_ptr<EventManager> eventManager;
};

int main() {
    std::shared_ptr<EventManager> eventManager = std::make_shared<EventManager>();
    std::shared_ptr<MyClass> obj1 = std::make_shared<MyClass>(eventManager);
    std::shared_ptr<MyClass> obj2 = std::make_shared<MyClass>(eventManager);

    obj1->startListening();
    obj2->startListening();

    eventManager->triggerEvent(42);

    return 0;
}

#include <iostream>
#include <memory>

class B; // 前方宣言

class A {
public:
    std::shared_ptr<B> b;
    ~A() { std::cout << "A destroyed\n"; }
};

class B {
public:
    std::shared_ptr<A> a;
    ~B() { std::cout << "B destroyed\n"; }
};

int main() {
    {
        std::shared_ptr<A> a = std::make_shared<A>();
        std::shared_ptr<B> b = std::make_shared<B>();
        a->b = b;
        b->a = a; // 循環参照が発生する
    } // ここではaとbは破棄されない

    std::cout << "End of scope\n";
    return 0;
}

#include <iostream>
#include <memory>
#include <functional>

class MyClass;

class EventManager {
public:
    void addListener(const std::function<void(int)>& listener) {
        listeners.push_back(listener);
    }

    void triggerEvent(int eventCode) {
        for (const auto& listener : listeners) {
            listener(eventCode);
        }
    }

private:
    std::vector<std::function<void(int)>> listeners;
};

class MyClass : public std::enable_shared_from_this<MyClass> {
public:
    MyClass(const std::shared_ptr<EventManager>& eventManager) : eventManager(eventManager) {}

    void startListening() {
        std::weak_ptr<MyClass> weakSelf = shared_from_this();
        eventManager->addListener([weakSelf](int eventCode) {
            if (auto sharedSelf = weakSelf.lock()) {
                sharedSelf->onEventTriggered(eventCode);
            } else {
                std::cout << "Object no longer exists." << std::endl;
            }
        });
    }

    void onEventTriggered(int eventCode) {
        std::cout << "Event triggered with code: " << eventCode << std::endl;
    }

private:
    std::shared_ptr<EventManager> eventManager;
};

int main() {
    std::shared_ptr<EventManager> eventManager = std::make_shared<EventManager>();
    std::shared_ptr<MyClass> obj = std::make_shared<MyClass>(eventManager);

    obj->startListening();
    eventManager->triggerEvent(42);

    obj.reset(); // objを手動で破棄する

    eventManager->triggerEvent(43);

    return 0;
}

#include <iostream>
#include <memory>

class Node {
public:
    std::shared_ptr<Node> next;
    ~Node() { std::cout << "Node destroyed\n"; }
};

int main() {
    auto node1 = std::make_shared<Node>();
    auto node2 = std::make_shared<Node>();
    node1->next = node2;
    node2->next = node1; // 循環参照が発生する

    return 0;
    // ここでnode1とnode2は破棄されない
}

#include <iostream>
#include <memory>

class Node {
public:
    std::shared_ptr<Node> next;
    std::weak_ptr<Node> prev;
    ~Node() { std::cout << "Node destroyed\n"; }
};

int main() {
    auto node1 = std::make_shared<Node>();
    auto node2 = std::make_shared<Node>();
    node1->next = node2;
    node2->prev = node1; // 循環参照を防ぐためにweak_ptrを使用

    return 0;
    // ここでnode1とnode2は正しく破棄される
}

#include <iostream>
#include <memory>

void useResource(std::shared_ptr<int> ptr) {
    std::cout << "Using resource: " << *ptr << std::endl;
}

int main() {
    auto ptr = std::make_shared<int>(42);
    useResource(ptr); // 正しく所有権を共有
    return 0;
}

#include <iostream>
#include <memory>
#include <cstdio>

void fileDeleter(std::FILE* file) {
    if (file) {
        std::fclose(file);
        std::cout << "File closed\n";
    }
}

int main() {
    std::shared_ptr<std::FILE> file(std::fopen("example.txt", "r"), fileDeleter);

    if (file) {
        std::cout << "File opened\n";
    }
    // ファイルは自動的に閉じられる
    return 0;
}

#include <iostream>
#include <memory>

void process(std::shared_ptr<int> ptr) {
    // 参照カウントの増減が発生する
}

int main() {
    auto ptr = std::make_shared<int>(42);
    process(ptr);
    return 0;
}

#include <iostream>
#include <memory>

void process(const std::shared_ptr<int>& ptr) {
    // 参照カウントの増減が発生しない
}

int main() {
    auto ptr = std::make_shared<int>(42);
    process(ptr);
    return 0;
}

#include <QApplication>
#include <QPushButton>
#include <memory>
#include <iostream>

// コールバックを持つクラス
class MyClass : public QObject {
    Q_OBJECT

public:
    MyClass() {
        // ボタンの作成
        button = std::make_unique<QPushButton>("Click Me");

        // コールバックの設定
        QObject::connect(button.get(), &QPushButton::clicked, [this]() {
            onButtonClicked();
        });
    }

    void show() {
        button->show();
    }

private slots:
    void onButtonClicked() {
        std::cout << "Button clicked!" << std::endl;
    }

private:
    std::unique_ptr<QPushButton> button;
};

int main(int argc, char* argv[]) {
    QApplication app(argc, argv);

    std::shared_ptr<MyClass> obj = std::make_shared<MyClass>();
    obj->show();

    return app.exec();
}

#include "main.moc"

#include <QApplication>
#include <QWidget>
#include <QPushButton>
#include <memory>
#include <iostream>

class CustomWidget : public QWidget {
    Q_OBJECT

public:
    CustomWidget() {
        button = std::make_unique<QPushButton>("Press Me", this);
        button->setGeometry(50, 50, 100, 30);

        QObject::connect(button.get(), &QPushButton::clicked, [this]() {
            onButtonPressed();
        });
    }

private slots:
    void onButtonPressed() {
        std::cout << "Button pressed in CustomWidget!" << std::endl;
    }

private:
    std::unique_ptr<QPushButton> button;
};

int main(int argc, char* argv[]) {
    QApplication app(argc, argv);

    std::shared_ptr<CustomWidget> widget = std::make_shared<CustomWidget>();
    widget->resize(200, 150);
    widget->show();

    return app.exec();
}

#include "main.moc"

#include <QApplication>
#include <QMainWindow>
#include <QPushButton>
#include <QLabel>
#include <memory>
#include <iostream>

class MainWindow : public QMainWindow {
    Q_OBJECT

public:
    MainWindow() {
        button = std::make_unique<QPushButton>("Click Me", this);
        button->setGeometry(50, 50, 100, 30);

        label = std::make_unique<QLabel>("Hello, World!", this);
        label->setGeometry(50, 100, 100, 30);

        QObject::connect(button.get(), &QPushButton::clicked, [this]() {
            onButtonClicked();
        });
    }

private slots:
    void onButtonClicked() {
        label->setText("Button Clicked!");
        std::cout << "Button clicked in MainWindow!" << std::endl;
    }

private:
    std::unique_ptr<QPushButton> button;
    std::unique_ptr<QLabel> label;
};

int main(int argc, char* argv[]) {
    QApplication app(argc, argv);

    std::shared_ptr<MainWindow> mainWindow = std::make_shared<MainWindow>();
    mainWindow->resize(200, 200);
    mainWindow->show();

    return app.exec();
}

#include "main.moc"

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

// イベントマネージャークラス
class EventManager {
public:
    void addListener(const std::function<void(int)>& listener) {
        listeners.push_back(listener);
    }

    void triggerEvent(int eventCode) {
        for (const auto& listener : listeners) {
            listener(eventCode);
        }
    }

private:
    std::vector<std::function<void(int)>> listeners;
};

// プレイヤークラス
class Player : public std::enable_shared_from_this<Player> {
public:
    Player(const std::shared_ptr<EventManager>& eventManager) : eventManager(eventManager) {}

    void init() {
        eventManager->addListener([weakSelf = weak_from_this()](int eventCode) {
            if (auto self = weakSelf.lock()) {
                self->onEvent(eventCode);
            }
        });
    }

    void onEvent(int eventCode) {
        std::cout << "Player received event: " << eventCode << std::endl;
    }

private:
    std::shared_ptr<EventManager> eventManager;
};

int main() {
    auto eventManager = std::make_shared<EventManager>();
    auto player = std::make_shared<Player>(eventManager);

    player->init();

    eventManager->triggerEvent(1); // プレイヤーがイベントを受け取る
    eventManager->triggerEvent(2);

    return 0;
}

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

// ゲームオブジェクトのベースクラス
class GameObject : public std::enable_shared_from_this<GameObject> {
public:
    virtual ~GameObject() {
        std::cout << "GameObject destroyed\n";
    }

    virtual void update() = 0;
};

// プレイヤークラス
class Player : public GameObject {
public:
    void update() override {
        std::cout << "Player updating\n";
    }
};

// ゲームクラス
class Game {
public:
    void addObject(const std::shared_ptr<GameObject>& object) {
        objects.push_back(object);
    }

    void updateObjects() {
        for (auto& object : objects) {
            object->update();
        }
    }

private:
    std::vector<std::shared_ptr<GameObject>> objects;
};

int main() {
    auto game = std::make_shared<Game>();
    auto player = std::make_shared<Player>();

    game->addObject(player);
    game->updateObjects();

    return 0;
}

#include <iostream>
#include <memory>
#include <functional>
#include <chrono>
#include <thread>

// タイマークラス
class Timer {
public:
    void setCallback(const std::function<void()>& callback) {
        this->callback = callback;
    }

    void start(int interval) {
        std::thread([this, interval]() {
            std::this_thread::sleep_for(std::chrono::milliseconds(interval));
            if (callback) {
                callback();
            }
        }).detach();
    }

private:
    std::function<void()> callback;
};

// ゲームクラス
class Game : public std::enable_shared_from_this<Game> {
public:
    void start() {
        timer.setCallback([weakSelf = weak_from_this()]() {
            if (auto self = weakSelf.lock()) {
                self->onTimer();
            }
        });
        timer.start(1000); // 1秒後にタイマーイベントを発火
    }

    void onTimer() {
        std::cout << "Timer event triggered\n";
    }

private:
    Timer timer;
};

int main() {
    auto game = std::make_shared<Game>();
    game->start();

    std::this_thread::sleep_for(std::chrono::seconds(2)); // メインスレッドを待機

    return 0;
}

#include <iostream>
#include <memory>

int main() {
    // 1. std::unique_ptrを使用
    std::unique_ptr<int> uniquePtr = std::make_unique<int>(42);
    std::cout << "Unique pointer value: " << *uniquePtr << std::endl;

    // 2. std::shared_ptrを使用
    std::shared_ptr<int> sharedPtr1 = std::make_shared<int>(100);
    std::shared_ptr<int> sharedPtr2 = sharedPtr1;
    std::cout << "Shared pointer value: " << *sharedPtr1 << " and " << *sharedPtr2 << std::endl;

    // 3. std::weak_ptrを使用
    std::weak_ptr<int> weakPtr = sharedPtr1;
    if (auto lockedPtr = weakPtr.lock()) {
        std::cout << "Weak pointer value: " << *lockedPtr << std::endl;
    } else {
        std::cout << "Weak pointer is expired." << std::endl;
    }

    return 0;
}

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

// イベントマネージャークラス
class EventManager {
public:
    void addListener(const std::function<void(int)>& listener) {
        listeners.push_back(listener);
    }

    void triggerEvent(int eventCode) {
        for (const auto& listener : listeners) {
            listener(eventCode);
        }
    }

private:
    std::vector<std::function<void(int)>> listeners;
};

// リスナークラス
class MyClass : public std::enable_shared_from_this<MyClass> {
public:
    MyClass(const std::shared_ptr<EventManager>& eventManager) : eventManager(eventManager) {}

    void init() {
        eventManager->addListener([weakSelf = weak_from_this()](int eventCode) {
            if (auto self = weakSelf.lock()) {
                self->onEvent(eventCode);
            }
        });
    }

    void onEvent(int eventCode) {
        std::cout << "Event received with code: " << eventCode << std::endl;
    }

private:
    std::shared_ptr<EventManager> eventManager;
};

int main() {
    auto eventManager = std::make_shared<EventManager>();
    auto myObject = std::make_shared<MyClass>(eventManager);

    myObject->init();

    eventManager->triggerEvent(1); // イベントを発火

    myObject.reset(); // オブジェクトを手動で破棄

    eventManager->triggerEvent(2); // 破棄後のイベント発火

    return 0;
}

#include <QApplication>
#include <QPushButton>
#include <memory>
#include <iostream>

// コールバックを持つクラス
class MyClass : public QObject {
    Q_OBJECT

public:
    MyClass() {
        // ボタンの作成
        button = std::make_unique<QPushButton>("Click Me");

        // コールバックの設定
        QObject::connect(button.get(), &QPushButton::clicked, [this]() {
            onButtonClicked();
        });
    }

    void show() {
        button->show();
    }

private slots:
    void onButtonClicked() {
        std::cout << "Button clicked!" << std::endl;
    }

private:
    std::unique_ptr<QPushButton> button;
};

int main(int argc, char* argv[]) {
    QApplication app(argc, argv);

    std::shared_ptr<MyClass> obj = std::make_shared<MyClass>();
    obj->show();

    return app.exec();
}

#include "main.moc"