関数

[C++] ラムダ式とautoの使い方

2025-04-15更新日: 2025-04-15

C++のラムダ式は、無名関数を定義するための構文で、簡潔に関数オブジェクトを作成できます。

基本構文は[キャプチャ](引数リスト) -> 戻り値型 {関数本体 }です。

キャプチャは外部変数をラムダ内で使用する際に指定します。

autoは型推論を行うキーワードで、ラムダ式の戻り値や変数の型を簡潔に記述できます。

例えば、auto func = [](int x) { return x * 2; };のようにラムダ式をautoで受け取ることで、型を明示せずに利用可能です。

目次から探す

autoとラムダ式の関係

C++11以降、autoキーワードとラムダ式は、プログラミングの効率を大幅に向上させる機能として注目されています。

autoは変数の型を自動的に推論するため、コードの可読性が向上し、ラムダ式は無名関数を簡単に定義できるため、特にコールバックや一時的な関数が必要な場面で非常に便利です。

autoの基本

autoを使うことで、変数の型を明示的に指定する必要がなくなります。

これにより、特に複雑な型を扱う際に、コードがすっきりします。

以下は、autoの基本的な使い方の例です。

#include <iostream>
#include <vector>
int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};
    
    // autoを使って型を推論
    for (auto number : numbers) {
        std::cout << number << std::endl; // 各要素を出力
    }
    
    return 0;
}

ラムダ式の基本

ラムダ式は、関数をその場で定義できる機能です。

これにより、関数を引数として渡す際に、別途関数を定義する必要がなくなります。

以下は、ラムダ式の基本的な使い方の例です。

#include <iostream>
#include <vector>
#include <algorithm>
int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};
    
    // ラムダ式を使って偶数を出力
    std::for_each(numbers.begin(), numbers.end(), [](int number) {
        if (number % 2 == 0) {
            std::cout << number << std::endl; // 偶数を出力
        }
    });
    
    return 0;
}

2
4

autoとラムダ式の組み合わせ

autoとラムダ式を組み合わせることで、より柔軟で可読性の高いコードを書くことができます。

以下は、ラムダ式をautoで型推論しながら使用する例です。

#include <iostream>
#include <vector>
#include <algorithm>
int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};
    
    // autoを使ってラムダ式の型を推論
    auto printEven = [](int number) {
        if (number % 2 == 0) {
            std::cout << number << std::endl; // 偶数を出力
        }
    };
    
    std::for_each(numbers.begin(), numbers.end(), printEven);
    
    return 0;
}

2
4

このように、autoとラムダ式を組み合わせることで、コードの可読性と保守性が向上します。

特に、コレクションの操作やイベント処理など、関数を一時的に定義する必要がある場面で非常に役立ちます。

ラムダ式の実践的な使い方

ラムダ式は、C++において非常に強力な機能であり、さまざまな場面で活用できます。

ここでは、ラムダ式の実践的な使い方をいくつか紹介します。

特に、コレクションの操作やカスタムソート、非同期処理などでの利用が一般的です。

コレクションの操作

ラムダ式は、std::for_eachやstd::remove_ifなどのアルゴリズムと組み合わせて使用することができます。

以下は、リスト内の特定の条件に基づいて要素を削除する例です。

#include <iostream>
#include <vector>
#include <algorithm>
int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    
    // ラムダ式を使って偶数を削除
    numbers.erase(std::remove_if(numbers.begin(), numbers.end(), [](int number) {
        return number % 2 == 0; // 偶数を削除する条件
    }), numbers.end());
    
    // 残った要素を出力
    for (const auto& number : numbers) {
        std::cout << number << std::endl; // 残った要素を出力
    }
    
    return 0;
}

カスタムソート

ラムダ式を使用することで、カスタムなソート条件を簡単に指定できます。

以下は、構造体のベクターを特定の条件でソートする例です。

#include <iostream>
#include <vector>
#include <algorithm>
struct Person {
    std::string name;
    int age;
};
int main() {
    std::vector<Person> people = {{"Alice", 30}, {"Bob", 25}, {"Charlie", 35}};
    
    // ラムダ式を使って年齢でソート
    std::sort(people.begin(), people.end(), [](const Person& a, const Person& b) {
        return a.age < b.age; // 年齢で昇順にソート
    });
    
    // ソート結果を出力
    for (const auto& person : people) {
        std::cout << person.name << ": " << person.age << "歳" << std::endl; // 名前と年齢を出力
    }
    
    return 0;
}

Bob: 25歳
Alice: 30歳
Charlie: 35歳

非同期処理

ラムダ式は、非同期処理やスレッド処理でも非常に便利です。

以下は、スレッドを使用して非同期に処理を行う例です。

#include <iostream>
#include <thread>
#include <chrono>
int main() {
    // ラムダ式を使って非同期処理を実行
    std::thread asyncTask([]() {
        std::this_thread::sleep_for(std::chrono::seconds(2)); // 2秒待機
        std::cout << "非同期処理が完了しました。" << std::endl; // 完了メッセージを出力
    });
    
    // メインスレッドでの処理
    std::cout << "メインスレッドでの処理を実行中..." << std::endl;
    
    // 非同期処理が完了するのを待つ
    asyncTask.join();
    
    return 0;
}

メインスレッドでの処理を実行中...
非同期処理が完了しました。

これらの例からもわかるように、ラムダ式はさまざまな場面で活用でき、コードの可読性や保守性を向上させることができます。

特に、関数を一時的に定義する必要がある場合や、コレクションの操作を簡潔に行いたい場合に非常に役立ちます。

ラムダ式の応用テクニック

ラムダ式は、C++プログラミングにおいて非常に柔軟で強力な機能です。

ここでは、ラムダ式の応用テクニックをいくつか紹介します。

これにより、より効率的で可読性の高いコードを書くことができます。

キャプチャリストの活用

ラムダ式では、外部の変数をキャプチャすることができます。

これにより、ラムダ式内で外部の変数を使用することが可能になります。

キャプチャリストを使うことで、必要な変数だけをラムダ式に渡すことができます。

以下は、キャプチャリストの使用例です。

#include <iostream>
int main() {
    int x = 10;
    int y = 20;
    
    // キャプチャリストを使ってxとyをキャプチャ
    auto add = [x, y]() {
        return x + y; // xとyを加算
    };
    
    std::cout << "合計: " << add() << std::endl; // 合計を出力
    
    return 0;
}

合計: 30

参照キャプチャ

ラムダ式では、変数を参照でキャプチャすることもできます。

これにより、外部の変数を変更することが可能になります。

以下は、参照キャプチャの例です。

#include <iostream>
int main() {
    int value = 5;
    
    // 参照キャプチャを使ってvalueをキャプチャ
    auto increment = [&value]() {
        value++; // valueをインクリメント
    };
    
    increment(); // インクリメントを実行
    std::cout << "新しい値: " << value << std::endl; // 新しい値を出力
    
    return 0;
}

新しい値: 6

ラムダ式の戻り値の型指定

ラムダ式では、戻り値の型を明示的に指定することもできます。

これにより、複雑な戻り値の型を扱う際に役立ちます。

以下は、戻り値の型を指定する例です。

#include <iostream>
int main() {
    // 戻り値の型を指定したラムダ式
    auto multiply = [](double a, double b) -> double {
        return a * b; // aとbを掛け算
    };
    
    std::cout << "積: " << multiply(3.5, 2.0) << std::endl; // 積を出力
    
    return 0;
}

積: 7

高階関数としてのラムダ式

ラムダ式は、高階関数としても使用できます。

つまり、ラムダ式を引数として他の関数に渡すことができます。

以下は、高階関数としてのラムダ式の例です。

#include <algorithm>
#include <functional>
#include <iostream>
#include <vector>
void applyFunction(const std::vector<int>& numbers,
                   const std::function<void(int)>& func) {
    for (const auto& number : numbers) {
        func(number); // 引数として渡された関数を実行
    }
}
int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};

    // ラムダ式を使ってapplyFunctionに渡す
    applyFunction(numbers, [](int number) {
        std::cout << number * 2 << std::endl; // 各要素を2倍して出力
    });

    return 0;
}

これらの応用テクニックを活用することで、ラムダ式をより効果的に使用し、コードの可読性や保守性を向上させることができます。

特に、キャプチャリストや参照キャプチャを使うことで、外部の変数を柔軟に扱うことができ、さまざまな場面での利用が可能になります。

注意点とベストプラクティス

ラムダ式は非常に便利な機能ですが、使用する際にはいくつかの注意点やベストプラクティスがあります。

これらを理解し、適切に活用することで、より安全で効率的なコードを書くことができます。

キャプチャの注意点

ラムダ式で外部変数をキャプチャする際には、変数のスコープに注意が必要です。

特に、参照キャプチャを使用する場合、キャプチャした変数がラムダ式の実行時に有効であることを確認してください。

以下は、キャプチャの注意点を示す例です。

#include <iostream>
int main() {
    int value = 10;
    auto lambda = [&value]() {
        std::cout << value << std::endl; // valueを出力
    };
    
    value = 20; // valueを変更
    lambda(); // 変更後のvalueを出力
    
    return 0;
}

この例では、valueが変更された後にラムダ式が実行され、変更後の値が出力されます。

キャプチャした変数が変更される可能性がある場合は、意図しない動作を避けるために注意が必要です。

不要なコピーを避ける

ラムダ式内で大きなオブジェクトをキャプチャする場合、コピーが発生することがあります。

これを避けるために、参照キャプチャを使用することを検討してください。

ただし、参照キャプチャを使用する際は、スコープに注意が必要です。

#include <iostream>
#include <vector>
int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};
    
    // 参照キャプチャを使用
    auto printNumbers = [&numbers]() {
        for (const auto& number : numbers) {
            std::cout << number << std::endl; // 各要素を出力
        }
    };
    
    printNumbers(); // 出力を実行
    
    return 0;
}

明示的な戻り値の型指定

ラムダ式の戻り値の型が複雑な場合、明示的に戻り値の型を指定することが推奨されます。

これにより、コードの可読性が向上し、意図しない型変換を防ぐことができます。

#include <iostream>
int main() {
    // 明示的な戻り値の型指定
    auto divide = [](double a, double b) -> double {
        return b != 0 ? a / b : 0; // ゼロ除算を防ぐ
    };
    
    std::cout << "結果: " << divide(10.0, 2.0) << std::endl; // 結果を出力
    
    return 0;
}

結果: 5

適切な名前付け

ラムダ式を使用する際は、適切な名前を付けることが重要です。

特に、ラムダ式を変数に代入する場合、関数の目的を明確に示す名前を付けることで、コードの可読性が向上します。

#include <iostream>
#include <vector>
#include <algorithm>
int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};
    
    // 適切な名前を付けたラムダ式
    auto isEven = [](int number) {
        return number % 2 == 0; // 偶数かどうかを判定
    };
    
    // 偶数をフィルタリング
    numbers.erase(std::remove_if(numbers.begin(), numbers.end(), isEven), numbers.end());
    
    for (const auto& number : numbers) {
        std::cout << number << std::endl; // 残った要素を出力
    }
    
    return 0;
}