C++のラムダ式の使い方とキャプチャリストの完全ガイド

C++のラムダ式は、プログラム内で一時的な関数を定義する便利な手段として広く使われています。ラムダ式を利用すると、コードの可読性を向上させ、関数を定義する手間を省くことができます。本記事では、C++のラムダ式の基本的な構文とその使用方法、さらにキャプチャリストについて詳しく解説します。プログラミングの効率を上げたい方や、コードのモジュール性を高めたい方に向けたガイドです。これから紹介する内容を通じて、C++のラムダ式をマスターし、実践に役立ててください。

ラムダ式の基本構文

C++のラムダ式は、簡潔な匿名関数を定義するための構文です。ラムダ式の基本構文は以下の通りです：

[capture](parameters) -> return_type {
    // 関数の本体
};

構文の要素

capture: 変数のキャプチャ方法を指定します。キャプチャリストとも呼ばれ、[]内に記述します。
parameters: 関数の引数を指定します。通常の関数と同様に、引数の型と名前を記述します。
return_type: 関数の戻り値の型を指定します。省略可能で、省略した場合は戻り値の型が自動推論されます。
関数の本体: 関数の処理内容を記述します。

基本例

以下に、基本的なラムダ式の例を示します：

#include <iostream>

int main() {
    auto add = [](int a, int b) -> int {
        return a + b;
    };

    std::cout << add(3, 4) << std::endl;  // 出力: 7

    return 0;
}

この例では、addというラムダ式を定義し、二つの整数を受け取ってその和を返しています。ラムダ式はautoで型推論され、通常の関数のように呼び出すことができます。

パラメータと戻り値の省略

パラメータの型や戻り値の型は省略可能です。例えば、以下のように書くことができます：

auto multiply = [](int a, int b) {
    return a * b;
};

省略することでコードが簡潔になりますが、必要に応じて明示的に指定することもできます。

ラムダ式は、関数を一時的に定義する際に非常に便利であり、特にSTLのアルゴリズムや並列処理でよく使用されます。次に、キャプチャリストについて詳しく説明します。

キャプチャリストとは

キャプチャリストは、ラムダ式の外部にある変数をラムダ式の内部で使用できるようにするための仕組みです。キャプチャリストは、[]内にキャプチャする変数やその方法を指定します。

キャプチャリストの基本

キャプチャリストは、以下のように記述します：

[capture_list](parameters) -> return_type {
    // 関数の本体
};

キャプチャの種類

キャプチャには主に2つの種類があります：

値キャプチャ（by value）:
外部変数の値をコピーしてラムダ式内部に取り込みます。これにより、ラムダ式内でその変数を変更しても外部の変数には影響を与えません。

   int x = 10;
   auto lambda = [x]() {
       std::cout << x << std::endl;
   };

参照キャプチャ（by reference）:
外部変数の参照を取得し、ラムダ式内部で使用します。これにより、ラムダ式内でその変数を変更すると、外部の変数も変更されます。

   int x = 10;
   auto lambda = [&x]() {
       x = 20;
   };
   lambda();
   std::cout << x << std::endl;  // 出力: 20

特殊なキャプチャ

全ての変数を値でキャプチャ: [=]

  auto lambda = [=]() {
      // 全ての外部変数を値でキャプチャ
  };

全ての変数を参照でキャプチャ: [&]

  auto lambda = [&]() {
      // 全ての外部変数を参照でキャプチャ
  };

特定の変数のみをキャプチャ: [a, &b]

  auto lambda = [a, &b]() {
      // aは値でキャプチャ、bは参照でキャプチャ
  };

キャプチャリストは、ラムダ式が外部の変数をどのように取り扱うかを明示的に指定するために重要です。次に、具体的なキャプチャリストの使用例を見ていきましょう。

キャプチャリストの使用例

キャプチャリストを用いることで、ラムダ式内で外部の変数を柔軟に利用することができます。ここでは、具体的な使用例をいくつか紹介します。

使用例1: 値キャプチャ

以下の例では、外部変数xを値キャプチャしています。ラムダ式内で変数xを変更しても、外部のxには影響を与えません。

#include <iostream>

int main() {
    int x = 10;
    auto lambda = [x]() mutable {
        x = 20;
        std::cout << "内部のx: " << x << std::endl;  // 出力: 内部のx: 20
    };

    lambda();
    std::cout << "外部のx: " << x << std::endl;  // 出力: 外部のx: 10

    return 0;
}

使用例2: 参照キャプチャ

次の例では、外部変数xを参照キャプチャしています。ラムダ式内で変数xを変更すると、外部のxも変更されます。

#include <iostream>

int main() {
    int x = 10;
    auto lambda = [&x]() {
        x = 20;
    };

    lambda();
    std::cout << "外部のx: " << x << std::endl;  // 出力: 外部のx: 20

    return 0;
}

使用例3: 複数の変数をキャプチャ

複数の変数をキャプチャする場合、それぞれの変数をどのようにキャプチャするかを指定できます。

#include <iostream>

int main() {
    int a = 5;
    int b = 10;
    auto lambda = [a, &b]() {
        // aは値キャプチャ、bは参照キャプチャ
        std::cout << "a: " << a << std::endl;  // 出力: a: 5
        b = 20;
    };

    lambda();
    std::cout << "b: " << b << std::endl;  // 出力: b: 20

    return 0;
}

使用例4: 全ての変数をキャプチャ

全ての外部変数をキャプチャする場合、=や&を用いてまとめてキャプチャできます。

#include <iostream>

int main() {
    int a = 5;
    int b = 10;

    // 値キャプチャ
    auto lambda1 = [=]() {
        std::cout << "a: " << a << ", b: " << b << std::endl;
    };

    // 参照キャプチャ
    auto lambda2 = [&]() {
        a = 15;
        b = 20;
    };

    lambda1();  // 出力: a: 5, b: 10
    lambda2();
    std::cout << "a: " << a << ", b: " << b << std::endl;  // 出力: a: 15, b: 20

    return 0;
}

これらの例から、キャプチャリストを使用することでラムダ式が柔軟に外部の変数を取り扱うことができることが分かります。次に、値キャプチャと参照キャプチャの違いと使い分けについて詳しく説明します。

値キャプチャと参照キャプチャ

値キャプチャと参照キャプチャは、ラムダ式が外部の変数をどのように取り扱うかを決定する重要な要素です。それぞれのキャプチャ方法には特有の特徴と使い分けのポイントがあります。

値キャプチャ（by value）

値キャプチャでは、外部変数の値をラムダ式内部にコピーします。これにより、ラムダ式内でその変数を変更しても、外部の変数には影響を与えません。

例：値キャプチャ

#include <iostream>

int main() {
    int x = 10;
    auto lambda = [x]() mutable {
        x = 20;
        std::cout << "内部のx: " << x << std::endl;  // 出力: 内部のx: 20
    };

    lambda();
    std::cout << "外部のx: " << x << std::endl;  // 出力: 外部のx: 10

    return 0;
}

ポイント

外部変数の値がラムダ式内で変更されない場合に有効。
変更したくない変数や安全に扱いたい変数に適用する。

参照キャプチャ（by reference）

参照キャプチャでは、外部変数の参照を取得し、ラムダ式内部でその変数を直接操作します。これにより、ラムダ式内での変更が外部の変数にも反映されます。

例：参照キャプチャ

#include <iostream>

int main() {
    int x = 10;
    auto lambda = [&x]() {
        x = 20;
    };

    lambda();
    std::cout << "外部のx: " << x << std::endl;  // 出力: 外部のx: 20

    return 0;
}

ポイント

外部変数をラムダ式内で変更する必要がある場合に有効。
状態を持つ変数やオブジェクトを操作する場合に適用する。

値キャプチャと参照キャプチャの使い分け

値キャプチャは、外部変数のコピーを作成し、ラムダ式内で安全に使用したい場合に使用します。値の変更がラムダ式の外部に影響を及ぼさないため、安全性が高いです。
参照キャプチャは、ラムダ式内で外部変数を直接操作したい場合に使用します。変数の状態変更が必要な場合や、オブジェクトのメンバ変数にアクセスする必要がある場合に適しています。

混合キャプチャ

値キャプチャと参照キャプチャを同時に使用することも可能です。具体的な変数ごとにキャプチャ方法を指定できます。

例：混合キャプチャ

#include <iostream>

int main() {
    int a = 5;
    int b = 10;
    auto lambda = [a, &b]() {
        // aは値キャプチャ、bは参照キャプチャ
        std::cout << "a: " << a << std::endl;  // 出力: a: 5
        b = 20;
    };

    lambda();
    std::cout << "b: " << b << std::endl;  // 出力: b: 20

    return 0;
}

これにより、変数の用途に応じて最適なキャプチャ方法を選択できます。次に、キャプチャリスト使用時の注意点とベストプラクティスについて説明します。

キャプチャリストの注意点

キャプチャリストを使用する際には、いくつかの注意点とベストプラクティスを守る必要があります。これにより、コードの予期せぬ動作やバグを防ぎ、安全で効率的なラムダ式の利用が可能になります。

注意点

1. 不必要なキャプチャを避ける

キャプチャリストには、本当に必要な変数だけをキャプチャするようにしましょう。不必要なキャプチャはメモリ消費の増加や予期せぬ動作の原因となります。

int x = 10;
int y = 20;
auto lambda = [x]() {
    // y は不要なキャプチャ
    std::cout << x << std::endl;
};

2. 可変性（mutability）の扱い

値キャプチャした変数をラムダ式内で変更したい場合は、mutableキーワードを使用します。mutableを付けないと、キャプチャされた変数は読み取り専用になります。

int x = 10;
auto lambda = [x]() mutable {
    x = 20;  // mutableを指定しないとコンパイルエラー
    std::cout << x << std::endl;
};

3. ライフタイムの管理

参照キャプチャする変数のライフタイムに注意が必要です。ラムダ式が実行されるときに、キャプチャされた変数が有効であることを確認してください。無効な参照を使うと未定義動作となります。

auto lambda;
{
    int x = 10;
    lambda = [&x]() {
        std::cout << x << std::endl;
    };
}  // xのライフタイムが終了
// lambda();  // xは無効なので危険

ベストプラクティス

1. キャプチャの明示的指定

全ての変数を[=]や[&]でキャプチャするのは避け、必要な変数だけを明示的にキャプチャするようにしましょう。これにより、予期せぬ変数のキャプチャを防ぎます。

int a = 10;
int b = 20;
auto lambda = [a, &b]() {
    // 明示的に必要な変数のみキャプチャ
    std::cout << a << " " << b << std::endl;
};

2. 変更可能な変数は参照キャプチャ

ラムダ式内で変更する必要のある変数は、参照キャプチャを使用することで、外部変数への変更を反映させることができます。

int count = 0;
auto increment = [&count]() {
    ++count;
};
increment();
std::cout << count << std::endl;  // 出力: 1

3. 大きなオブジェクトは値キャプチャ

大きなオブジェクトを値キャプチャすることで、ラムダ式が不要なコピーを作成しないようにします。

std::vector<int> data = {1, 2, 3, 4, 5};
auto printData = [data = std::move(data)]() {
    for (int n : data) {
        std::cout << n << " ";
    }
};
printData();  // 出力: 1 2 3 4 5

まとめ

キャプチャリストの使用は強力な機能ですが、適切なキャプチャ方法の選択とライフタイムの管理が重要です。これらの注意点とベストプラクティスを守ることで、安全で効率的なラムダ式の利用が可能になります。次に、高度なラムダ式の使用例を見ていきましょう。

高度なラムダ式の使用例

ラムダ式は、基本的な使用方法だけでなく、高度な機能や複雑なシナリオにも対応できる柔軟な構文です。ここでは、実際の開発で役立つ高度なラムダ式の使用例を紹介します。

使用例1: 標準ライブラリとの組み合わせ

ラムダ式は、C++の標準ライブラリと組み合わせることで非常に強力になります。以下は、std::sort関数にラムダ式を使用してカスタムのソート順序を指定する例です。

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> numbers = {5, 2, 9, 1, 5, 6};

    std::sort(numbers.begin(), numbers.end(), [](int a, int b) {
        return a > b;  // 降順にソート
    });

    for (int n : numbers) {
        std::cout << n << " ";
    }
    // 出力: 9 6 5 5 2 1

    return 0;
}

使用例2: キャプチャによる状態保持

ラムダ式は、キャプチャを使用して状態を保持することができます。以下の例では、ラムダ式を使用してカウントダウンを実装しています。

#include <iostream>
#include <functional>

std::function<void()> createCounter(int start) {
    int count = start;
    return [count]() mutable {
        if (count > 0) {
            std::cout << "カウントダウン: " << count-- << std::endl;
        } else {
            std::cout << "カウントダウン終了" << std::endl;
        }
    };
}

int main() {
    auto counter = createCounter(5);

    for (int i = 0; i < 7; ++i) {
        counter();
    }
    // 出力:
    // カウントダウン: 5
    // カウントダウン: 4
    // カウントダウン: 3
    // カウントダウン: 2
    // カウントダウン: 1
    // カウントダウン終了
    // カウントダウン終了

    return 0;
}

使用例3: マルチスレッドでの使用

ラムダ式は、マルチスレッドプログラミングでも活用できます。以下の例では、ラムダ式を使用してスレッドを生成し、並行処理を行います。

#include <iostream>
#include <thread>

int main() {
    int result = 0;

    std::thread t([&result]() {
        // ラムダ式でスレッドの実行内容を定義
        for (int i = 0; i < 10; ++i) {
            result += i;
        }
    });

    t.join();  // スレッドの終了を待つ

    std::cout << "結果: " << result << std::endl;  // 出力: 結果: 45

    return 0;
}

使用例4: イベントハンドラとしてのラムダ式

GUIプログラミングやイベント駆動型プログラミングにおいて、ラムダ式はイベントハンドラとしても利用できます。以下の例では、ボタンのクリックイベントにラムダ式を使用しています（簡略化された擬似コード）。

#include <iostream>

// 擬似的なボタンとイベントシステム
class Button {
public:
    std::function<void()> onClick;

    void click() {
        if (onClick) {
            onClick();
        }
    }
};

int main() {
    Button button;

    button.onClick = []() {
        std::cout << "ボタンがクリックされました！" << std::endl;
    };

    button.click();  // 出力: ボタンがクリックされました！

    return 0;
}

これらの高度な使用例から、ラムダ式がいかに多様な状況で役立つかが分かります。次に、ラムダ式と関数オブジェクトの違いと共通点について説明します。

ラムダ式と関数オブジェクト

C++におけるラムダ式と関数オブジェクト（ファンクタ）は、どちらも関数のように振る舞うオブジェクトを作成するための手段ですが、それぞれの特徴や利点があります。ここでは、ラムダ式と関数オブジェクトの違いと共通点について説明します。

ラムダ式

ラムダ式は、簡潔に関数オブジェクトを定義するための構文です。ラムダ式を使用すると、関数の定義をその場で行うことができ、匿名関数を作成できます。

例：ラムダ式

#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 n) {
        std::cout << n << " ";
    });
    // 出力: 1 2 3 4 5

    return 0;
}

関数オブジェクト（ファンクタ）

関数オブジェクトは、operator()をオーバーロードしたクラスのインスタンスです。関数オブジェクトは、ラムダ式よりも柔軟で、状態を持つオブジェクトを作成するのに適しています。

例：関数オブジェクト

#include <iostream>
#include <vector>
#include <algorithm>

class Print {
public:
    void operator()(int n) const {
        std::cout << n << " ";
    }
};

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};

    std::for_each(numbers.begin(), numbers.end(), Print());
    // 出力: 1 2 3 4 5

    return 0;
}

違いと使い分け

簡潔さ

ラムダ式: 簡潔に一時的な関数オブジェクトを定義するのに適しています。コードが短く、読みやすいのが特徴です。

  auto add = [](int a, int b) { return a + b; };
  std::cout << add(3, 4) << std::endl;  // 出力: 7

関数オブジェクト: 複雑な状態を持つ場合や、再利用可能な関数オブジェクトを作成する場合に適しています。明確にクラスとして定義することで、より複雑なロジックを持たせることができます。

  class Adder {
  private:
      int value;
  public:
      Adder(int v) : value(v) {}
      int operator()(int n) const { return value + n; }
  };

  Adder addFive(5);
  std::cout << addFive(3) << std::endl;  // 出力: 8

状態の保持

ラムダ式: 状態をキャプチャリストで保持できますが、状態の管理は限定的です。

  int x = 5;
  auto increment = [&x]() { ++x; };
  increment();
  std::cout << x << std::endl;  // 出力: 6

関数オブジェクト: クラスのメンバ変数として状態を保持でき、より複雑な状態管理が可能です。

  class Counter {
  private:
      int count;
  public:
      Counter() : count(0) {}
      void operator()() { ++count; }
      int getCount() const { return count; }
  };

  Counter counter;
  counter();
  counter();
  std::cout << counter.getCount() << std::endl;  // 出力: 2

共通点

関数呼び出し可能: どちらも()を使用して関数のように呼び出すことができます。
STLとの互換性: ラムダ式も関数オブジェクトも、STLのアルゴリズムに渡すことができます。

結論

ラムダ式と関数オブジェクトは、目的に応じて使い分けることでC++のプログラムを効率的に構築できます。簡潔さと一時的な用途にはラムダ式を、複雑な状態管理や再利用可能なロジックには関数オブジェクトを使用するのが一般的です。次に、ラムダ式のパフォーマンスに関する考察を行います。

ラムダ式のパフォーマンス

ラムダ式は、C++のプログラミングにおいて非常に便利なツールですが、そのパフォーマンスについても理解しておくことが重要です。ここでは、ラムダ式がパフォーマンスに与える影響と、効率的に利用するためのポイントを説明します。

パフォーマンスの概要

ラムダ式自体は、コンパイル時に関数オブジェクトとして変換されるため、パフォーマンスのオーバーヘッドはほとんどありません。しかし、ラムダ式の使用方法やキャプチャの方法によっては、パフォーマンスに影響を与える可能性があります。

値キャプチャと参照キャプチャの違い

値キャプチャ

値キャプチャは、ラムダ式が定義された時点で外部変数のコピーを作成します。このため、値キャプチャは参照キャプチャに比べてメモリのオーバーヘッドが発生する可能性があります。

#include <vector>
#include <iostream>

int main() {
    std::vector<int> data(1000, 42);
    auto sum = [=]() {
        int total = 0;
        for (int n : data) {
            total += n;
        }
        return total;
    };

    std::cout << "合計: " << sum() << std::endl;
    return 0;
}

この例では、dataのコピーがラムダ式内に保持されるため、大きなデータ構造の場合、メモリ使用量が増加します。

参照キャプチャ

参照キャプチャは、外部変数の参照を保持するため、コピーによるメモリオーバーヘッドがありません。ただし、参照キャプチャを使用する場合は、外部変数のライフタイムに注意する必要があります。

#include <vector>
#include <iostream>

int main() {
    std::vector<int> data(1000, 42);
    auto sum = [&data]() {
        int total = 0;
        for (int n : data) {
            total += n;
        }
        return total;
    };

    std::cout << "合計: " << sum() << std::endl;
    return 0;
}

この例では、dataが参照キャプチャされるため、メモリのオーバーヘッドはありません。

インライン化の影響

コンパイラは、ラムダ式をインライン化することが多く、これにより関数呼び出しのオーバーヘッドが削減されます。インライン化は、特に小さなラムダ式に対して効果的です。

#include <algorithm>
#include <vector>
#include <iostream>

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};
    std::for_each(numbers.begin(), numbers.end(), [](int &n) {
        n *= 2;
    });

    for (int n : numbers) {
        std::cout << n << " ";
    }
    // 出力: 2 4 6 8 10

    return 0;
}

この例では、ラムダ式がインライン化されるため、関数呼び出しのオーバーヘッドはありません。

ラムダ式の使い方によるパフォーマンス改善

必要なキャプチャのみを行う:
不要な変数をキャプチャしないことで、メモリの無駄遣いを防ぎます。
参照キャプチャを適切に使用する:
大きなデータ構造を扱う場合は、参照キャプチャを使用してメモリのオーバーヘッドを避けます。
ラムダ式のインライン化を促す:
コンパイラの最適化設定を使用し、ラムダ式がインライン化されるようにします。

パフォーマンスの計測

ラムダ式のパフォーマンスを評価するために、実際に計測を行うことが重要です。以下は、ラムダ式を使用したコードの実行時間を計測する例です。

#include <iostream>
#include <vector>
#include <chrono>

int main() {
    std::vector<int> data(1000000, 1);
    auto start = std::chrono::high_resolution_clock::now();

    auto sum = [&data]() {
        long total = 0;
        for (int n : data) {
            total += n;
        }
        return total;
    };

    long result = sum();
    auto end = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double> duration = end - start;

    std::cout << "合計: " << result << std::endl;
    std::cout << "時間: " << duration.count() << "秒" << std::endl;

    return 0;
}

このようにして、ラムダ式のパフォーマンスを定量的に評価することができます。

まとめ

ラムダ式はパフォーマンスに優れた機能ですが、使用方法によってはメモリや実行時間に影響を与えることがあります。適切なキャプチャ方法を選び、インライン化を活用することで、効率的にラムダ式を使用することができます。次に、ラムダ式を使った演習問題を提供します。

ラムダ式を使った演習問題

ラムダ式の理解を深めるために、以下の演習問題を通じて実際にラムダ式を使用してみましょう。各問題には、具体的な課題とヒントが含まれています。

演習問題1: 配列のフィルタリング

課題

整数の配列から、特定の条件を満たす要素だけを抽出するプログラムを作成してください。

条件

配列の要素は0から100までの整数です。
抽出する条件は「偶数」であることです。

ヒント

std::vectorとstd::copy_ifを使用します。
ラムダ式で条件を指定します。

解答例

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    std::vector<int> evenNumbers;

    std::copy_if(numbers.begin(), numbers.end(), std::back_inserter(evenNumbers), [](int n) {
        return n % 2 == 0;
    });

    std::cout << "偶数: ";
    for (int n : evenNumbers) {
        std::cout << n << " ";
    }
    // 出力: 偶数: 2 4 6 8 10

    return 0;
}

演習問題2: カスタムソート

課題

文字列の配列を、文字列の長さに基づいてソートするプログラムを作成してください。

条件

文字列の配列を入力として受け取ります。
長さが短い順にソートします。

ヒント

std::sortとラムダ式を使用します。

解答例

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<std::string> words = {"apple", "banana", "cherry", "date"};

    std::sort(words.begin(), words.end(), [](const std::string &a, const std::string &b) {
        return a.length() < b.length();
    });

    std::cout << "ソートされた文字列: ";
    for (const std::string &word : words) {
        std::cout << word << " ";
    }
    // 出力: ソートされた文字列: date apple banana cherry

    return 0;
}

演習問題3: キャプチャを利用したカウンタ

課題

外部変数をキャプチャして、呼び出されるたびにカウントアップするラムダ式を作成してください。

条件

初期値は0から開始します。
ラムダ式を複数回呼び出し、カウントを表示します。

ヒント

キャプチャリストを使用します。

解答例

#include <iostream>

int main() {
    int count = 0;

    auto counter = [&count]() {
        ++count;
        std::cout << "カウント: " << count << std::endl;
    };

    counter();  // 出力: カウント: 1
    counter();  // 出力: カウント: 2
    counter();  // 出力: カウント: 3

    return 0;
}

演習問題4: 複数の条件でフィルタリング

課題

整数の配列から、複数の条件を満たす要素を抽出するプログラムを作成してください。

条件

条件1: 偶数であること
条件2: 値が5以上であること

ヒント

std::vectorとstd::copy_ifを使用します。
ラムダ式で複数の条件を指定します。

解答例

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    std::vector<int> filteredNumbers;

    std::copy_if(numbers.begin(), numbers.end(), std::back_inserter(filteredNumbers), [](int n) {
        return n % 2 == 0 && n >= 5;
    });

    std::cout << "フィルタリング結果: ";
    for (int n : filteredNumbers) {
        std::cout << n << " ";
    }
    // 出力: フィルタリング結果: 6 8 10

    return 0;
}

まとめ

これらの演習問題を通じて、ラムダ式の基本的な使い方から、キャプチャリストの利用、標準ライブラリとの組み合わせなど、様々な側面を実践的に学ぶことができます。ラムダ式の理解を深めるために、ぜひこれらの問題に挑戦してみてください。次に、この記事の内容をまとめます。

まとめ

本記事では、C++のラムダ式とキャプチャリストについて詳しく解説しました。ラムダ式は匿名関数を簡潔に定義する強力なツールであり、特に一時的な関数を定義する際に非常に便利です。キャプチャリストを使用することで、外部の変数をラムダ式内で柔軟に利用することができます。

ラムダ式の基本構文: [](parameters) -> return_type { // 関数の本体 }
キャプチャリストの種類: 値キャプチャと参照キャプチャ
実用例: 標準ライブラリとの組み合わせ、状態保持、マルチスレッドでの使用、イベントハンドラ
パフォーマンスの考慮: 値キャプチャと参照キャプチャの違い、インライン化の効果
演習問題: 配列のフィルタリング、カスタムソート、カウンタの実装、複数条件でのフィルタリング

ラムダ式とキャプチャリストを活用することで、コードの可読性や効率性を向上させることができます。これらの知識を実際のプログラミングに応用し、C++の高度な機能を使いこなしてください。

本記事が、皆さんのC++プログラミングのスキル向上に役立つことを願っています。