[C++] ラムダ式を使ったコールバック関数の実装方法

#include <iostream>
// コールバック関数の型を定義
typedef void (*CallbackFunction)(int);
// コールバック関数を呼び出す関数
void processData(int data, CallbackFunction callback) {
    // データを処理
    int processedData = data * 2;
    // コールバック関数を呼び出す
    callback(processedData);
}
// コールバック関数の実装
void myCallback(int result) {
    std::cout << "処理結果: " << result << std::endl;
}
int main() {
    int data = 5;
    // コールバック関数を渡して呼び出し
    processData(data, myCallback);
    return 0;
}

処理結果: 10

#include <iostream>
#include <functional>
// コールバック関数を呼び出す関数
void processData(int data, std::function<void(int)> callback) {
    // データを処理
    int processedData = data * 2;
    // コールバック関数を呼び出す
    callback(processedData);
}
int main() {
    int data = 5;
    // ラムダ式を使ってコールバック関数を定義
    processData(data, [](int result) {
        std::cout << "処理結果: " << result << std::endl;
    });
    return 0;
}

処理結果: 10

#include <iostream>
#include <functional>
void processData(int data, std::function<void(int)> callback) {
    int processedData = data * 2;
    callback(processedData);
}
int main() {
    int data = 5;
    int multiplier = 3;
    // 外部変数をキャプチャして使用
    processData(data, [multiplier](int result) {
        std::cout << "処理結果: " << result * multiplier << std::endl;
    });
    return 0;
}

処理結果: 30

#include <iostream>
#include <functional>
void processData(int data, std::function<void(int)> callback) {
    int processedData = data * 2;
    callback(processedData);
}
int main() {
    int data = 5;
    // 型推論を活用したラムダ式
    processData(data, [](auto result) {
        std::cout << "処理結果: " << result << std::endl;
    });
    return 0;
}

処理結果: 10

#include <iostream>
#include <thread>
#include <functional>
// スレッドで実行する関数
void threadFunction(int data, std::function<void(int)> callback) {
    // データを処理
    int processedData = data * 2;
    // コールバック関数を呼び出す
    callback(processedData);
}
int main() {
    int data = 5;
    // スレッドを作成し、ラムダ式をコールバックとして渡す
    std::thread t(threadFunction, data, [](int result) {
        std::cout << "スレッド処理結果: " << result << std::endl;
    });
    t.join(); // スレッドの終了を待つ
    return 0;
}

スレッド処理結果: 10

#include <iostream>
#include <functional>
#include <map>
#include <string>
// イベントを管理するクラス
class EventManager {
public:
    void subscribe(const std::string& eventName, std::function<void()> callback) {
        callbacks[eventName] = callback;
    }
    void trigger(const std::string& eventName) {
        if (callbacks.find(eventName) != callbacks.end()) {
            callbacks[eventName]();
        }
    }
private:
    std::map<std::string, std::function<void()>> callbacks;
};
int main() {
    EventManager manager;
    // イベントにコールバックを登録
    manager.subscribe("onClick", []() {
        std::cout << "ボタンがクリックされました。" << std::endl;
    });
    // イベントをトリガー
    manager.trigger("onClick");
    return 0;
}

ボタンがクリックされました。

#include <iostream>
#include <functional>
// 仮想的なボタンクラス
class Button {
public:
    void setOnClickListener(std::function<void()> callback) {
        onClick = callback;
    }
    void click() {
        if (onClick) {
            onClick();
        }
    }
private:
    std::function<void()> onClick;
};
int main() {
    Button button;
    // ボタンにクリックイベントを設定
    button.setOnClickListener([]() {
        std::cout << "ボタンがクリックされました。" << std::endl;
    });
    // ボタンをクリック
    button.click();
    return 0;
}

ボタンがクリックされました。

#include <functional>
#include <future>
#include <iostream>
#include <thread> // std::this_thread::sleep_forに必要

// 非同期処理を行う関数
void asyncProcess(int data, std::function<void(int)> callback) {
    // std::asyncの戻り値を受け取る
    std::future<void> future = std::async(std::launch::async, [=]() {
        int processedData = data * 2;
        callback(processedData);
    });

    // 非同期タスクの完了を待つ
    future.get();
}

int main() {
    int data = 5;
    // 非同期処理を開始し、コールバックを設定
    asyncProcess(data, [](int result) {
        std::cout << "非同期処理結果: " << result << std::endl;
    });

    // メインスレッドでの処理
    std::cout << "メインスレッドでの処理中..." << std::endl;
    std::this_thread::sleep_for(
        std::chrono::seconds(1)); // 非同期処理の完了を待つ
    return 0;
}

メインスレッドでの処理中...
非同期処理結果: 10

#include <iostream>
#include <vector>
#include <functional>
// 観察者インターフェース
class Observer {
public:
    virtual void update(int data) = 0;
};
// 被観察者クラス
class Subject {
public:
    void addObserver(Observer* observer) {
        observers.push_back(observer);
    }
    void notifyObservers(int data) {
        for (auto observer : observers) {
            observer->update(data);
        }
    }
private:
    std::vector<Observer*> observers;
};
// 具体的な観察者クラス
class ConcreteObserver : public Observer {
public:
    void update(int data) override {
        std::cout << "Observerが通知を受け取りました: " << data << std::endl;
    }
};
int main() {
    Subject subject;
    ConcreteObserver observer;
    subject.addObserver(&observer);
    // 被観察者が状態を変更し、観察者に通知
    subject.notifyObservers(42);
    return 0;
}

Observerが通知を受け取りました: 42