関数ポインタとラムダ式 | Programming Place Plus　新C++編

このページの概要

このページでは、関数に関数を渡しておくことによって、適切なタイミングで、関数内から関数を呼び返す（コールバック）方法を取り上げます。その実現のために、オブジェクトではなく関数を指し示す、関数ポインタという機能を紹介します。また、もう１つの手段として使えるラムダ式について、これまでのページよりも詳しい解説を行います。

以下は目次です。要点だけをさっと確認したい方は、「まとめ」をご覧ください。

• コールバック関数
• 関数ポインタ
• ラムダ式
  • キャプチャ
    • コピーキャプチャ
    • 参照キャプチャ
    • デフォルトキャプチャ
    • 初期化キャプチャ
• std::function
• まとめ
• 参考リンク
• 練習問題
• 更新履歴

コールバック関数

「スコープと名前空間」のページの練習問題では、コマンドライン引数の解析をおこなうコードを、バイナリエディタ以外のプログラムでも使えるようにする目的で、いったんソースコードの分離だけ行いました。次にしなければならないのは、コマンドライン引数の中に、有効なオプション指定を発見したとき、それに応じた処理を実行できるようにすることです。しかし、その処理をコマンドライン引数を解析する関数の中に書くと、ほかのプログラムで再利用できないことになります。このページでは、この問題を解決する方法を取り上げます。

やりたいことはこうです。

// コマンドライン引数を解析する
void analysis_cmdline_args(const std::vector<std::string>& cmdline_args, ????)
{
    // cmdline_args から、有効なオプション指定を探す。
    // 見つかったら、それに応じた処理を実行する。
}

すでにバイナリエディタには –lowerオプションが実装されていますが、これはバイナリエディタでは意味があっても、ほかのプログラムでは意味がないかもしれません。反対に、ほかのプログラムでは必要なオプションが、バイナリエディタのプログラムにはないかもしれません。あったとしても、おそらく実行したい処理は違うものでしょう。そのため、「どんなオプションが存在するのか」という情報と、「各オプションで実行すべき処理」は、呼び出し側に書かなければなりません。

そこで、オプション名とそれに対応する関数のリストを用意して渡せるようにします。

struct Option {
    std::string  name;  // オプション名
    ????         func;  // 発見時に実行する関数
};
const std::vector<Option> options { /* オプション名と、対応する関数のリスト */};

// コマンドライン引数を解析する
void analysis_cmdline_args(const std::vector<std::string>& cmdline_args, const std::vector<Option> options)
{
    // cmdline_args に options の name に一致する指定があるか探す。
    // 見つかったら、それに応じた func を実行する。
}

analysis_cmdline_args(cmdline_args, options);

func を関数にしたいわけですが、その型をどう書けばいいのかが問題です。これができれば、オプションの指定を発見したときに、その関数を呼び出してやればいいことになります。「適切なタイミングが来たとき、事前に渡しておいた関数を呼び出してもらう」ということです。このような処理はコールバック (callback) といい、呼び出される関数をコールバック関数 (callback function) といいます。ここでは func がコールバック関数です。

実際のところ、C++ では関数型 (function type) の変数やデータメンバ、仮引数を作ることはできません。しかし、代わりにとれる手段はあります。このページではその手段をいくつか紹介します。

関数ポインタ

まずは、関数ポインタ (function pointer)（あるいは、関数へのポインタ (pointer to function)）です。これまでのページで使ってきたポインタは、メモリ上のオブジェクトを指し示すものでしたが、関数ポインタはメモリ上の関数を指し示します。

「メモリ上の関数」というのが不思議な感じがしたかもしれません。実は、プログラムの実行を開始するとき、関数の本体（のコードをコンパイルしたもの）がメモリ上に展開されています。そのため、関数には関数ごとに固有のメモリアドレスがあります。関数ポインタはこれを記憶することで、任意の関数を指し示します。

通常、単に「ポインタ」といったときは、オブジェクトを指し示すポインタを意味しますが、明確にするため、オブジェクトポインタ (object pointer) と呼ぶ場合があります。void* で表されるポインタもオブジェクトポインタに含みます¹。

関数ポインタの変数は、次のように宣言します。

戻り値の型 (*変数名)(仮引数の並び) 初期化子;
戻り値の型 (*変数名)(仮引数の並び);

指し示したい関数の仮引数と戻り値に一致するように宣言しなければなりません。「仮引数の並び」は型名だけ書けばよく、引数名は省略しても構いません。

void f(int x, int y)
{
}

void (*pf1)(int, int) {f};  // 関数f を指し示す
void (*pf2)(int) {};        // ヌルポインタ
void (*pf3)(int);           // 自動ストレージ期間を持つ場合は未初期化
                            // 静的ストレージ期間を持つ場合はヌルポインタ

いつものように、{} で初期化した場合は値初期化（「構造体」のページを参照）、初期化子がない場合はストレージ期間に応じて結果が異なります。

関数ポインタにもヌルポインタという状態があり、関数を指し示していない状態です。ヌルポインタを表現する方法はオブジェクトポインタと同様なので（「構造体とポインタ」のページを参照）、明示的に書くなら nullptr を使うのがいいです。

上のコード例で、f という関数名を渡せていますが、f 自体は関数そのものです。関数ポインタに渡すべきものは関数そのものではありませんが、関数型は暗黙的に関数ポインタに変換できるため問題ありません。&演算子を使って書くこともできますが、意味はまったく同じになります。

void (*pf1)(int, int) {&f};  // f も &f も同じこと

関数ポインタ変数を const にするときは、* と関数ポインタ名のあいだに割り込ませます。先頭に置くと、戻り値型に const が付いていることになってしまいます。

void (* const pf)(int, int) {f};  // pf は書き換え不可

オブジェクトポインタと違って、関数ポインタには constポインタのようなものはありません。

型名の記述は、型推論に任せることもできます。

double f(int x)
{
    // ...
}

auto pf = f;  // double (*pf)(int)

関数ポインタ型に別名を付けるには次のようにします。

using 別名 = 戻り値の型 (*)(仮引数の並び);
typedef 戻り値の型 (*別名)(仮引数の並び);

どちらの方法を使っても結果は同じです。具体的なコードで書くとこうなります。

int double_to_int(double x)
{
    // ...
}

using converter_t = int (*)(double);
// あるいは、typedef int (*converter_t)(double);

converter_t converter {double_to_int}; 

関数ポインタが指し示している関数は、次のようにして呼び出せます。もちろん、戻り値があれば返されてきます。

関数ポインタ(実引数の並び);
(*関数ポインタ)(実引数の並び);

２つの書き方はまったく同じ意味なので、簡潔な１つ目の方法を使えばいいです。「関数ポインタ」が有効な関数を指し示していなければ、未定義の動作です。

関数ポインタが指し示す関数を変えることで、実行時に処理を切り替えられます。次のプログラムでは、op(10, 1) という記述が、２つの異なる処理を実行していることが確認できます。

#include <iostream>

int plus(int x, int y)
{
    return x + y;
}
int minus(int x, int y)
{
    return x - y;
}

int main()
{
    int (*op)(int, int) {plus};
    std::cout << op(10, 1) << "\n";

    op = minus;
    std::cout << op(10, 1) << "\n";
}

実行結果：

11
9

引数に関数ポインタを渡すことで、コールバック関数を実現できます。

#include <cassert>
#include <iostream>
#include <vector>

using converter_t = int (*)(int);

void print_convert_values(const std::vector<int>& values, converter_t converter)
{
    assert(converter);

    for (std::vector<int>::size_type i {0}; i < values.size(); ++i) {
        std::cout << converter(values.at(i));  // コールバック
        if (i < values.size() - 1) {
            std::cout << ", ";
        }
    }
    std::cout << "\n";
}

int change_sign(int v)
{
    return -v;
}

int double_number(int v)
{
    return v * 2;
}

int main()
{
    std::vector<int> values {7, -5, 10, -1, 2};

    print_convert_values(values, change_sign);
    print_convert_values(values, double_number);
}

実行結果：

-7, 5, -10, 1, -2
14, -10, 20, -2, 4

渡されてきた関数ポインタがヌルポインタである可能性に注意してください。このサンプルでは assert でチェックしています。関数ポインタは bool型に暗黙的に変換できるので、assert(converter != nullptr) のように書く必要はありません。

当初の目的に戻って、関数ポインタを使ってオプションの一覧表を実現してみます。

// --- 汎用的なコード ---

using option_callback_t = void (*)();

struct Option {
    std::string        name;
    option_callback_t  func;
};


// --- バイナリエディタ固有のコード ---

void on_option_lower()
{
    // --lower発見時の処理
}

const std::vector<Option> options {
    { "--lower", on_option_lower },
};

これで、“–lower” のような具体的なオプション名や、そうしたオプションを発見したときに実行する処理を、汎用的なコードの側から取り除くことができます。

ラムダ式

コールバック関数を実現する方法として、ラムダ式を使うこともできます。

ラムダ式はすでに何度も使っていますが、じつはそのほとんどがコールバック関数そのものといえる使い方をしています。たとえば、条件に合う要素の個数を調べる std::count_if関数は、第３引数にラムダ式を指定できます（「要素を探索する」のページを参照）。

std::vector<int> v {8, 11, -10, 0, -5, 13};
auto count = std::count_if(std::cbegin(v), std::cend(v), [](int e){ return e < 0; });

std::count_if関数内では v の要素を１つ１つ順番に辿りながら、そのつど第３引数に指定したラムダ式（の本体のコード）をコールバックしています。

このプログラムは、次のように関数オブジェクト（「シャッフルと乱数」のページを参照）を使って書き換えられます。

struct IsNegative {
    bool operator()(int value)
    {
        return value < 0;
    }
};

std::vector<int> v {8, 11, -10, 0, -5, 13};
auto count = std::count_if(std::cbegin(v), std::cend(v), IsNegative());

ラムダ式が導入された C++11 よりも前の時代には、実際にこのようなコードを書いていました（普通の関数でもいいですが）。これは少々面倒ですし、実際に使いたい箇所から離れたところにコードを書くことになるのもデメリットでした。ラムダ式は、必要なことを必要になるその場所に、埋め込むような感じで記述できることが１つの利点であるといえます。

実際のところ、ラムダ式は関数オブジェクトを簡単に記述する構文です。ラムダ式が行っていることは、関数オブジェクト（これはクラスなので型）と、そのオブジェクトの生成です。作られるクラスをクロージャ型 (closure type) と呼び、その型のオブジェクトをクロージャオブジェクト (closure object) と呼びます。

ラムダ式の基本的な構文は次のようになっています。

[](仮引数の並び) -> 戻り値の型 {本体}

「-> 戻り値の型」は省略できます。その場合の戻り値の型は、「本体」のコードから型推論によって決定します。あえて auto を記述できるほか、auto& と書けば、参照型に型推論させられます（「関数から値を返す」のページを参照）。

クロージャ型は次のようなクラスです。「戻り値の型」「仮引数の並び」「本体」にはそれぞれ、ラムダ式に記述したものが入ります。クラス名はコンパイラが決めるため、ここでは ???? としています。

class ???? {
public:
    戻り値の型 operator()(仮引数の並び) const
    {
        本体
    }
};

operator() の末尾に const がありますが、メンバ関数の宣言の末尾に const があると、そのメンバ関数内からデータメンバの値を書き換えられなくなります。このようなメンバ関数は、constメンバ関数 (const member function) と呼ばれます。

メンバ関数や constメンバ関数については「クラス」のページで改めて取り上げます。

あとで取り上げる mutable を使うと、この const を解除できます。

【上級】ラムダ式の仮引数の型を auto にすることでジェネリックラムダになります²。この場合、生成される operator() が関数テンプレートなり、任意の型の引数を受け付けるようになります。

ラムダ式を評価した結果はクロージャオブジェクトです。変数に受け取れますが、クロージャ型の名前はコンパイラが決めるため、型名をソースコードに記述できません。方法の１つとして auto で型推論させることで、型名の記述を避ける手があります。

auto is_negative = [](int e){ return e < 0; };
// is_negative の型名は処理系定義

しかし、仮引数や、構造体のデータメンバなど、auto が使えない場面もあります。そうした場面では、あとで取り上げる std::function を使う方法があります。

また、クロージャオブジェクトは、仮引数や戻り値がラムダ式の記述と一致する関数ポインタに変換できるため（ただし、あとで取り上げるキャプチャを使っている場合を除く）、関数ポインタ型で受け取る方法もあります。

bool (*is_negative)(int) = [](int e){ return e < 0; };

クロージャオブジェクトに () を使えば、ラムダ式の本体を呼び出せます。

bool result {is_negative(x)};

ラムダ式を記述した流れで呼び出すことも可能です。

bool result {[](int e){ return e < 0; }(x)};

ラムダ式から関数ポインタに変換できるので、関数ポインタのところで書いたオプションの一覧表はそのまま利用できます。

// --- 汎用的なコード ---

using option_callback_t = void (*)();

struct Option {
    std::string        name;
    option_callback_t  func;
};


// --- バイナリエディタ固有のコード ---

const std::vector<Option> options {
    { "--lower", [](){ /* --lower発見時の処理 */ } },
};

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

int main()
{
    std::vector<int> v {8, 11, -10, 0, -5, 13};

    int min {};
    std::cin >> min;

    std::cout << std::count_if(std::cbegin(v), std::cend(v), [](int e){ return e >= min; }) << "\n";
}

[キャプチャ](仮引数の並び) -> 戻り値の型 {本体}

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

int main()
{
    std::vector<int> v {8, 11, -10, 0, -5, 13};

    int min {};
    std::cin >> min;

    std::cout << std::count_if(std::cbegin(v), std::cend(v), [min](int e){ return e >= min; }) << "\n";
}

5  <-- 入力された値
3

class ???? {
    int min;  // 値は、キャプチャされた変数からコピーされてくる

public:
    bool operator()(int e) const
    {
        return e >= min;
    }
};

std::count_if(std::cbegin(v), std::cend(v), [min](int e){
    min *= 2;  // エラー
    return e >= min;
});

std::count_if(std::cbegin(v), std::cend(v), [min](int e) mutable {
    min *= 2;  // データメンバを書き換える。キャプチャされた変数には影響なし
    return e >= min;
});

[&変数名](仮引数の並び) -> 戻り値の型 {本体}

std::count_if(std::cbegin(v), std::cend(v), [&min](int e) mutable {
    min *= 2;  // キャプチャされた min を書き換えている
    return e >= min;
});

[&a, b, &c](){};  // a と c は参照キャプチャ、b はコピーキャプチャ

class ???? {
    int& min;  // キャプチャされた変数の参照

public:
    bool operator()(int e) const
    {
        min *= 2;
        return e >= min;
    }
};

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

int main()
{
    std::vector<int> v {8, 11, -10, 0, -5, 13};
    int min {0};

    auto greater_min = [&min](int e){ return e >= min; };  // この時点では min は 0
    min = 10;
    std::cout << std::count_if(std::cbegin(v), std::cend(v), greater_min) << "\n";  // 本体を実行するときには 10 になっている
}

2

#include <iostream>

auto f()
{
    int x {2};
    return [&x](int a){ x *= a; return x; };  // x を参照キャプチャ
}  // x の寿命が終わる

int main()
{
    auto mul = f();
    std::cout << mul(10) << "\n";  // 寿命が終わっている x を使ってしまう（未定義動作）
}

[=](仮引数の並び) -> 戻り値の型 {本体}
[&](仮引数の並び) -> 戻り値の型 {本体}

#include <iostream>

int main()
{
    int a {10};
    int b {20};
    int c {30};

    [&](){
        std::cout << a + b + c << "\n";
        c = 0;
    }();

    [=](){ std::cout << a + b + c << "\n"; }();
}

60
30

[=, &変数名（, &変数名・・・）](仮引数の並び) -> 戻り値の型 {本体}
[&, 変数名（, 変数名・・・）](仮引数の並び) -> 戻り値の型 {本体}

#include <iostream>

int main()
{
    int a {10};
    int b {20};
    int c {30};

    [=, &c](){
        std::cout << a + b + c << "\n";
        c = 0;
    }();

    [&, c](){
        std::cout << a + b + c << "\n";
        a = 0;
        b = 0;
    }();

    std::cout << a << ", " << b << ", " << c << "\n";
}

60
30
0, 0, 0

#include <iostream>

int main()
{
    int a {10};
    int b {20};
    static int c {30};

    [=](){
        std::cout << a + b + c << "\n";
        c = 0;  // ???
    }();

    std::cout << a << ", " << b << ", " << c << "\n";
}

60
10, 20, 0

[識別子 初期化子](仮引数の並び) -> 戻り値の型 {本体}
[&識別子 初期化子](仮引数の並び) -> 戻り値の型 {本体}

#include <iostream>

int f()
{
    static int value {1};
    return value++;
}

int main()
{
    for (int i {0}; i < 5; ++i) {
        [v = f()](){ std::cout << v << "\n"; }();
    }
}

1
2
3
4
5

std::function

クロージャオブジェクトを受け取るために、auto や関数ポインタ型を使う方法を取り上げましたが、auto は仮引数やデータメンバには使えませんし、キャプチャを使っているラムダ式は関数ポインタに変換できません。

そこで、汎用的に使える方法として std::function⁶ があります。std::function を使うには、<functional> をインクルードする必要があります。

std::function は、呼び出し可能オブジェクト (callable object)を保持するための型です。呼び出し可能オブジェクトとは、() を使った呼び出しができる型（呼び出し可能型 (callable type)）のオブジェクトのことです⁷。具体的には、関数ポインタや関数オブジェクトを保持できます。関数は関数ポインタに変換できますし、ラムダ式は関数オブジェクトを生成していますから、これらもそのまま渡せます。

std::function の型名の記述はやや特殊です。

std::function<戻り値の型(仮引数の並び)>

たとえば、void f(int a, double b); という関数を指し示す関数ポインタを保持するには、次のように記述します。

std::function<void(int, double)>;

std::function のデフォルトの初期値は、何も呼び出せるものを保持していない、いわば空の状態です。仮引数の型と順番、戻り値の型が一致すれば、どんな関数ポインタや関数オブジェクトでも保持できます。

void f(int a, double b);

std::function<void(int, double)> func {};

// 関数ポインタ
void (*pf)(int, double) {f};
func = pf;
func = f;  // 関数は関数ポインタに変換できるので、そのまま渡してもいい

// 関数オブジェクト（ラムダ式）
func = [](int a, double b){};

// キャプチャ付きのラムダ式
int x {};
func = [x](int a, double b){};

保持している呼び出し可能オブジェクトを呼び出すには () を使います。

func(100, 2.5);

空の状態で呼び出そうとしてはいけません。空の状態でないことは、次のようにして確認できます。

if (func) {  // 空の状態でなければ true
    func(100, 2.5);
}

【上級】空の状態で呼び出そうとすると、std::bad_function_call 例外が送出されます。

std::function は仮引数やデータメンバとしても使用できるので、オプションの一覧表を次のように書き換えられます。

// --- 汎用的なコード ---

using option_callback_t = std::function<void()>;

struct Option {
    std::string        name;
    option_callback_t  func;
};


// --- バイナリエディタ固有のコード ---

void on_option_lower()
{
    // --lower発見時の処理
}

const std::vector<Option> options {
    // 以下のどちらでも対応できる
    { "--lower", on_option_lower },
    { "--lower", [](){ /* --lower発見時の処理 */ } },
};

実際にバイナリエディタのプログラムを改造する作業は、練習問題で取り組むことにします。

まとめ

• 適切なタイミングになったときに、事前に指定しておいた関数を呼び出してもらうコールバックという方法があり、このとき呼び出される関数をコールバック関数と呼ぶ
  • コールバック関数の実現のために、関数ポインタやラムダ式（関数オブジェクト）を利用できる
• 関数ポインタは関数を指し示す
• ラムダ式は、関数オブジェクトを簡潔に記述する機能であり、必要な処理を、必要になるその場所に埋め込むように記述できる利点がある
  • ラムダ式から作られる関数オブジェクトの型をクロージャ型といい、そのオブジェクトをクロージャオブジェクトと呼ぶ
• ラムダ式の本体からは、ラムダ式の外側で宣言されている（静的ローカル変数を除く）ローカル変数や仮引数は使用できない
  • 必要があれば、変数をキャプチャすることで、クロージャオブジェクトのデータメンバとして取り込むことができる
    • コピーキャプチャでは、変数のコピーが作られる
    • 参照キャプチャでは、変数の参照が作られる
    • デフォルトキャプチャを使うと、すべての（静的ローカル変数を除く）ローカル変数や仮引数をまとめてキャプチャできる
    • 初期化キャプチャを使うと、任意の式の結果をキャプチャできる
    • デフォルトでは、ラムダ式の本体からクロージャオブジェクトのデータメンバは書き換えられないが、mutableキーワードを使うと書き換え可能になる
• キャプチャを使っていないラムダ式は、関数ポインタに変換できる
• std::function は、仮引数や戻り値が一致する呼び出し可能オブジェクトを保持する
  • 呼び出し可能オブジェクトは、() による呼び出しが可能な型（呼び出し可能型）のオブジェクトである

新C++編の【本編】の各ページには、末尾に練習問題があります。ページ内で学んだ知識を確認する簡単な問題から、これまでに学んだ知識を組み合わせなければならない問題、あるいは更なる自力での調査や模索が必要になるような高難易度な問題をいくつか掲載しています。