[C++] テンプレートと組み合わせたラムダ式の使い方

#include <iostream>
// テンプレート関数の定義
template <typename T>
T add(T a, T b) {
    return a + b;
}
int main() {
    std::cout << add(3, 4) << std::endl; // 整数の加算
    std::cout << add(3.5, 4.5) << std::endl; // 浮動小数点数の加算
    return 0;
}

#include <iostream>
int main() {
    // ラムダ式の定義と使用
    auto add = [](int a, int b) -> int {
        return a + b;
    };
    std::cout << add(3, 4) << std::endl; // ラムダ式による加算
    return 0;
}

#include <iostream>
#include <vector>
#include <algorithm>
// テンプレート関数の定義
template <typename T, typename Func>
void applyFunction(std::vector<T>& vec, Func func) {
    for (auto& element : vec) {
        element = func(element);
    }
}
int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};
    // ラムダ式をテンプレート関数に渡す
    applyFunction(numbers, [](int x) { return x * 2; });
    for (const auto& num : numbers) {
        std::cout << num << " "; // 2 4 6 8 10
    }
    return 0;
}

#include <iostream>
#include <vector>
// テンプレートクラスの定義
template <typename T>
class Processor {
public:
    void process(std::vector<T>& vec, std::function<T(T)> func) {
        for (auto& element : vec) {
            element = func(element);
        }
    }
};
int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};
    Processor<int> processor;
    // ラムダ式をテンプレートクラスのメソッドに渡す
    processor.process(numbers, [](int x) { return x + 1; });
    for (const auto& num : numbers) {
        std::cout << num << " "; // 2 3 4 5 6
    }
    return 0;
}

#include <iostream>
// テンプレート関数の定義
template <auto Func>
void execute() {
    std::cout << Func(5) << std::endl;
}
int main() {
    // ラムダ式をテンプレート引数として渡す
    execute<[](int x) { return x * x; }>(); // 25
    return 0;
}

#include <iostream>
#include <vector>
#include <algorithm>
// テンプレート関数の定義
template <typename T, typename Func>
void transformVector(std::vector<T>& vec, Func func) {
    std::transform(vec.begin(), vec.end(), vec.begin(), func);
}
int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};
    // ラムダ式を使ってベクターの要素を2倍にする
    transformVector(numbers, [](int x) { return x * 2; });
    for (const auto& num : numbers) {
        std::cout << num << " "; // 2 4 6 8 10
    }
    return 0;
}

#include <iostream>
#include <functional>
// テンプレート関数の定義
template <typename Callback>
void performOperation(int a, int b, Callback callback) {
    int result = callback(a, b);
    std::cout << "Result: " << result << std::endl;
}
int main() {
    // ラムダ式をコールバック関数として渡す
    performOperation(5, 3, [](int x, int y) { return x + y; }); // Result: 8
    performOperation(5, 3, [](int x, int y) { return x * y; }); // Result: 15
    return 0;
}

#include <iostream>
// コンパイル時に計算を行うラムダ式
constexpr auto square = [](int x) { return x * x; };
int main() {
    constexpr int result = square(5);
    std::cout << "Square of 5: " << result << std::endl; // Square of 5: 25
    return 0;
}

#include <iostream>
#include <tuple>
// テンプレートを用いたメタプログラミング
template <typename Tuple, typename Func, std::size_t... Indices>
void forEachImpl(Tuple&& tuple, Func func, std::index_sequence<Indices...>) {
    (func(std::get<Indices>(tuple)), ...);
}
template <typename... Args, typename Func>
void forEachInTuple(std::tuple<Args...>& tuple, Func func) {
    forEachImpl(tuple, func, std::index_sequence_for<Args...>{});
}
int main() {
    auto myTuple = std::make_tuple(1, 2.5, "Hello");
    // ラムダ式を用いてタプルの各要素を処理
    forEachInTuple(myTuple, [](const auto& element) {
        std::cout << element << " ";
    });
    // 出力: 1 2.5 Hello
    return 0;
}

#include <iostream>
#include <functional>
#include <vector>
// イベントシステムのテンプレートクラス
template <typename... Args>
class Event {
public:
    using HandlerType = std::function<void(Args...)>;
    void subscribe(HandlerType handler) {
        handlers.push_back(handler);
    }
    void notify(Args... args) {
        for (auto& handler : handlers) {
            handler(args...);
        }
    }
private:
    std::vector<HandlerType> handlers;
};
int main() {
    Event<int, const std::string&> onEvent;
    // ラムダ式を用いてイベントハンドラを登録
    onEvent.subscribe([](int id, const std::string& message) {
        std::cout << "Event received: " << id << ", " << message << std::endl;
    });
    // イベントの通知
    onEvent.notify(1, "Hello World");
    // 出力: Event received: 1, Hello World
    return 0;
}

#include <iostream>
#include <vector>
#include <thread>
#include <algorithm>
// 並列処理を行うテンプレート関数
template <typename Iterator, typename Func>
void parallelForEach(Iterator begin, Iterator end, Func func) {
    auto length = std::distance(begin, end);
    auto numThreads = std::thread::hardware_concurrency();
    auto blockSize = length / numThreads;
    std::vector<std::thread> threads;
    for (unsigned i = 0; i < numThreads; ++i) {
        Iterator blockStart = std::next(begin, i * blockSize);
        Iterator blockEnd = (i == numThreads - 1) ? end : std::next(blockStart, blockSize);
        threads.emplace_back([=]() {
            std::for_each(blockStart, blockEnd, func);
        });
    }
    for (auto& thread : threads) {
        thread.join();
    }
}
int main() {
    std::vector<int> numbers(100, 1);
    // ラムダ式を用いて並列処理を実行
    parallelForEach(numbers.begin(), numbers.end(), [](int& x) {
        x *= 2;
    });
    for (const auto& num : numbers) {
        std::cout << num << " "; // 2 2 2 ... 2
    }
    return 0;
}