ポインタ⑧（関数ポインタ） | Programming Place Plus　Ｃ言語編　第３８章

関数ポインタ

ポインタは、メモリアドレスを持つものであれば指し示せます。実は、関数の実体（中身のコード）もメモリ上にありますから、関数を指し示すことも可能です。これを、関数ポインタと呼びます。また、これに対して、これまでのようなオブジェクトを指し示すポインタを、オブジェクトポインタと呼ぶことがあります。

【上級】オブジェクトポインタも関数ポインタも同じようなもののようですが、その実際的な表現形式はまったく異なる可能性があります。これは、実行環境によっては、データが格納されるメモリと、関数のようなコードが格納されるメモリとが、大きく異なる領域に分離されている場合があるからです。現実的に起こり得る分かりやすい違いは、sizeof を使ったときに返される大きさです。このため、オブジェクトポインタと関数ポインタとの間で、代入を行うことは不適切です。

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

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

関数ポインタは、仮引数の内容と、戻り値の型が一致する関数のメモリアドレスを保持できます。そこで、戻り値の型と、仮引数の並びを関数宣言のようなかたちで記述し、あいだに関数ポインタ変数の名前を置きます。

変数名の頭に「*」を付けることでポインタであることを示しますが、「*」と変数名全体を ( ) で囲まなければならないことに注意してください。

関数ポインタには、仮引数の型や個数、戻り値の型が異なる関数のメモリアドレスは格納できません。ヌルポインタは格納でき、何も指し示していないことになります。

次のような関数が宣言されていたとします。

int func(const char* str);

この関数を指し示す関数ポインタ変数 func_ptr は、次のように宣言できます。

int (*func_ptr)(const char*) = func;

「= func」は初期値として、func関数のメモリアドレスを渡しているということです。アドレス演算子を使っていませんが、関数の場合、使っても使わなくても同じ意味です。

もちろん、初期値は後から与えても構いません。いつものように、変数宣言時に初期値を与えなかった場合の値は、静的記憶域期間をもっているのでなければ不定値です。静的記憶域期間をもっているのなら、ヌルポインタになります。（第２２章）

int (*func_ptr)(const char*);
func_ptr = func;

関数ポインタ変数を配列にする場合、要素数の指定は、変数名の直後のところに置きます。

int (*func_ptrs[10])(const char*);

関数ポインタ変数の宣言は、少々独特で読みづらいです。また、その型名の表現も難しく、「int (*)(const char*)」のような型名ということになります。

関数ポインタを関数の仮引数として使う場合など、型名を記述しなければならない場面があります。そのため、毎回このような複雑な型名を書かなくてすむように、typedef を使って別名を定義しておく方法があります。

typedef 戻り値の型 (*新しい型名) (仮引数のリスト);

これはこれでまた難解ですが、こういうものなので覚えてしまうしかないです。具体的には次のように使います。

typedef int (*func_ptr_t)(const char*);  // 型名を定義
func_ptr_t func_ptr;                     // 定義した型名を使って、関数ポインタ変数を宣言
func_ptr = func;                         // 関数のメモリアドレスを代入

関数ポインタは、関数を指し示していますから、その使い道は当然、関数を呼び出すことです。関数ポインタを経由して関数を呼び出すには、次のようにします。

int ret = func_ptr( "abcde" );
int ret = (*func_ptr)( "abcde" );

この２つはどちらも同じ意味です。

１つ目の方法は、普通に関数を呼び出すときとまったく同じ見た目です。２つ目の方法は、間接演算子を使って間接参照した上で、関数呼び出しを行っています。この場面では、わざわざ面倒な方法を採る必要はないと思います。１つ目の方法を選べばよいでしょう。

では、実際に使うことを考えていきます。たとえば、何らかの条件で処理内容を切り替えるようなプログラムを考えてみます。まず、関数ポインタを使わずに書いてみます。

#include <stdio.h>

void mainProcForEasy(void);
void mainProcForNormal(void);
void mainProcForHard(void);

int main(void)
{
    puts( "難易度を選んでください。" );
    puts( "0～2 で大きいほど難しくなります。" );

    char str[40];
    int level;
    fgets( str, sizeof(str), stdin );
    sscanf( str, "%d", &level );

    // 難易度に応じたメインの処理を実行する
    switch( level ){
    case 0:
        mainProcForEasy();
        break;
    case 1:
        mainProcForNormal();
        break;
    case 2:
        mainProcForHard();
        break;
    default:
        puts( "入力が正しくありません。" );
        return 0;
    }

    return 0;
}

void mainProcForEasy(void)
{
    puts( "簡単なモードで実行。" );
}

void mainProcForNormal(void)
{
    puts( "標準的な難易度のモードで実行。" );
}

void mainProcForHard(void)
{
    puts( "難しいモードで実行。" );
}

実行結果：

難易度を選んでください。
0～2 で大きいほど難しくなります。
1
標準的な難易度のモードで実行。

何のプログラムか不明ですが、ともかく、標準入力から入力された難易度に応じて、処理を分けるものだと考えてください。多分、mainProcXXXX という名前の関数の中では、問題が表示されてそれに答えるような処理があり、難易度によって、出題される問題の難しさが変わるとしましょう。

この実装方法の問題の１つは、switch文（または if文の連続）で分岐を行う必要があるため、後から、難易度の種類が増えると、忘れずに case句なり else句なりを増やさねばならないことです。今回のように、分岐処理を書く場所が１カ所だけならまだいいのですが、ソースファイルが複数あり、いろいろなところで同様の意味合いの分岐処理が書いてあると大変なのです。

次に同じプログラムを、関数ポインタを駆使して書いてみます。

#include <stdio.h>

#define SIZE_OF_ARRAY(array)    (sizeof(array)/sizeof(array[0]))

void mainProcForEasy(void);
void mainProcForNormal(void);
void mainProcForHard(void);

int main(void)
{
    typedef void (*mainProc_t)(void);  // メイン処理の関数ポインタ型

    static const mainProc_t mainProcArray[] = {  // メイン処理の関数テーブル
        mainProcForEasy,
        mainProcForNormal,
        mainProcForHard,
    };


    puts( "難易度を選んでください。" );
    puts( "0～2 で大きいほど難しくなります。" );

    char str[40];
    int level;
    fgets( str, sizeof(str), stdin );
    sscanf( str, "%d", &level );

    if( level < 0 || SIZE_OF_ARRAY(mainProcArray) <= level ){
        puts( "入力が正しくありません。" );
        return 0;
    }

    // 難易度に応じたメインの処理を実行する
    mainProcArray[level]();

    return 0;
}

void mainProcForEasy(void)
{
    puts( "簡単なモードで実行。" );
}

void mainProcForNormal(void)
{
    puts( "標準的な難易度のモードで実行。" );
}

void mainProcForHard(void)
{
    puts( "難しいモードで実行。" );
}

実行結果：

難易度を選んでください。
0～2 で大きいほど難しくなります。
1
標準的な難易度のモードで実行。

こちらは、呼び出すべき関数を配列で管理してあり、難易度と添字を一致させてあります。そのため、分岐構造は必要なくなります（エラーチェックのためには必要ですが）。

もし、後から難易度が増えたら、配列の中身を変えて、新しい関数を作るだけで済みます。つまり、変更すべき箇所が激減し、しかも見つけやすい場所にあります。

qsort関数

標準ライブラリ関数の中には、関数ポインタを利用した関数あります。たとえば、qsort関数と、bsearch関数が代表的です。まずは qsort関数を取り上げ、この後の項で bsearch関数を取り上げます。

qsort関数は、ソート（整列）という操作を行う関数です。ソートとは、複数のデータを、大きい値から小さい値の順序（降順）になるように並び変える、あるいは反対に、小さい値から大きい値の順序（昇順）になるように並び変える操作のことです。

ソートには、さまざまな実装手段があります。具体的な実装方法については、アルゴリズムとデータ構造編【整列】を参照してください。ともかく、qsort関数を使うと、具体的な実装方法を知らなくても、ソートを行えます。

【上級】一般的に、クイックソート（アルゴリズムとデータ構造編【整列】第６章）という方法が使われることから qsort という名前になっていますが、他の方法が使われている可能性もあります。

qsort関数は、<stdlib.h> で、次のように宣言されています。

void qsort(void* base, size_t count, size_t size, int (*compar)(const void* elem1, const void* elem2));

第１引数base は、ソート対象の配列を指すポインタです。第２引数count には、その配列に含まれる要素数を、第３引数size には、要素１つ分の大きさを指定します。第４引数compar は、ソートの条件を指定するための関数ポインタを指定します。

まずは実際に使ってみましょう。

#include <stdio.h>
#include <stdlib.h>

#define SIZE_OF_ARRAY(array)    (sizeof(array)/sizeof(array[0]))

void printTable(const int* array, size_t size);
int compareInt(const void* a, const void* b);

int main(void)
{
    int table[] = { 66, 85, 70, 92, 61, 89 };

    puts( "ソート前" );
    printTable( table, SIZE_OF_ARRAY(table) );

    qsort( table, SIZE_OF_ARRAY(table), sizeof(int), compareInt );

    puts( "ソート後" );
    printTable( table, SIZE_OF_ARRAY(table) );

    return 0;
}

/*
    int型配列の要素を出力。
*/
void printTable(const int* array, size_t size)
{
    for( size_ t i = 0; i < size; ++i ){
        printf( "%d ", array[i] );
    }
    printf( "\n" );
}

/*
    int型による順序比較。

    引数：
        a:  比較する要素。
        b:  比較する要素。
    戻り値：
        a の方が小さいとき負数、
        b の方が小さいとき 0 より大きい値、
        a と b が同じときは 0、
        　が返される。
*/
int compareInt(const void* a, const void* b)
{
    int aNum = *(const int*)a;
    int bNum = *(const int*)b;

    if( aNum < bNum ){
        return -1;
    }
    else if( aNum > bNum ){
        return 1;
    }
    return 0;
}

実行結果：

ソート前
66 85 70 92 61 89
ソート後
61 66 70 85 89 92

qsort関数を使う際の肝となるのは、第４引数に渡す関数ポインタです。この関数ポインタが指し示す関数は、２つの要素の値の大小関係を比較して返すように実装しておきます。qsort関数は、このような比較用の関数を何度も繰り返し呼び出して、要素同士がどう並ぶべきなのかを判断して、ソートを行います。

なお、このように、関数ポインタを渡しておいて、必要なタイミングで呼び出させるような手法を、コールバックと呼びます。

比較用の関数は決まったルールで実装しなければなりません。まず、仮引数は const付きの汎用ポインタが２つで、戻り値は int型です。関数ポインタ型は、仮引数の並びと戻り値の型がきちんと一致していなければならないので、この形に従う必要があります。

２つの引数には、比較する２つの要素を指すポインタが渡されてきます。「どの要素？」と思うかもしれませんが、それは予測できません。この辺りは、ソートのアルゴリズムを学んだ経験がないとイメージしづらいですが、ソートの処理の最中に、何度も何度も、ある要素とほかの要素との比較を行います。ともかく、２つの要素の値の大小関係を知りたいだけなので、どの要素なのかは気にせずに実装します。

比較用の関数の戻り値は、第１引数のポインタが指す要素の値の方が大きいなら 0 より大きい値を、同じなら 0 を、小さいなら 0 より小さい値を返すようにします。このルールは、strcmp関数のものと同じです。

サンプルプログラムでは、compareInt関数が比較用の関数です。引数で渡されてきたポインタから、要素の値を知らなければなりませんから、間接参照をしたいのですが、汎用ポインタで渡されてくるため、まずキャストが必要です。こうして、要素の本来の型を指し示せるポインタ型を得てから、間接参照を行います。

要素の比較を、qsort関数が内部で自身で行わずに、コールバックを利用する理由は、大きく２つあります。

１つには、対象の要素の型が分からないからです。要素は文字列かもしれないし、浮動小数点数かもしれないし、構造体かもしれません。どのような型であっても扱えるように、比較用の関数の仮引数は void*型になっています。

もう１つの理由は、順序関係の定義がいつも同じとは限らないということです。単純な話、昇順に並べたいのか、降順に並べたいのか、というだけでも比較用の関数の実装を変えなければなりません。

先ほどのサンプルプログラムだと昇順に並びますが、これを降順にしたければ比較関数を、以下のようにします。

/*
    int型による順序比較。

    引数：
        a:  比較する要素。
        b:  比較する要素。
    戻り値：
        b の方が小さいとき負数、
        a の方が小さいとき 0 より大きい値、
        a と b が同じときは 0、
        　が返される。
*/
int compareInt(const void* a, const void* b)
{
    int aNum = *(const int*)a;
    int bNum = *(const int*)b;

    if( aNum < bNum ){
        return 1;
    }
    else if( aNum > bNum ){
        return -1;
    }
    return 0;
}

bsearch関数

bsearch関数は、サーチ（探索）という操作を行う関数です。サーチとは、複数のデータの中から、特定の値を見つけ出す操作のことです。

サーチにも、さまざまな実装手段があります。具体的な実装方法については、アルゴリズムとデータ構造編【探索】を参照してください。bsearch関数を使うと、具体的な実装方法を知らなくても、サーチを行えます。

ただし、bsearch関数は、その実装手段の制約のため、対象となるデータ列が事前に昇順にソートされた状態でないと正しく動作しません。もし対象のデータがソート済みであることが保証できるなら問題ありませんが、そうでないのなら、先に qsort関数を使って、ソートを行っておくと良いでしょう。

bsearch関数は、<stdlib.h> に、次のように宣言されています。

void* bsearch(const void* key, void* base, size_t count, size_t size, int (*compar)(const void* key, const void* value));

第１引数 key は、探し出したい値を指すポインタです。素直に値を渡せないのは嫌らしいところですが、これも、対象の型を固定できないので void*型で扱わざるを得ないことが理由です。

第２引数以降は、qsort関数と同様のものが並んでいます。順番に、対象の配列のメモリアドレス、配列の要素数、要素１個分の大きさ、比較用関数を指し示す関数ポインタです。

戻り値は、目的の値が発見できた場合は、その要素を指し示すポインタが返されます。発見できなかった場合は、ヌルポインタが返されます。

比較用関数は、qsort関数のときと同様に、２つの要素を指すポインタを受け取る const void* の仮引数と、int型の戻り値を持ちます。しかし、仮引数の意味は異なります。

サーチの処理の最中には何度も、「この要素は目的の要素か？」を調べる場面があり、その都度、比較用関数がコールバックされます。第１引数は、探し出したいと思っている値を指すポインタ、すなわち、bsearch関数を呼び出すときに第１引数 key に与えたポインタが渡されてきます。

第２引数には、比較を行う対象の要素を指すポインタが渡されてきます。

比較用関数の戻り値は、第１引数のポインタが指す要素の値の方が大きいなら 0 より大きい値を、同じなら 0 を、小さいなら 0 より小さい値を返すようにします。

このように、比較用関数の仕様は qsort関数と bsearch関数とで異なっているので、別個に関数を用意した方が安全なのですが、実際には同じ関数でもうまく動作することもあります。たとえば、次のプログラムでは、同じ関数でまかなっています。

#include <stdio.h>
#include <stdlib.h>

#define SIZE_OF_ARRAY(array)    (sizeof(array)/sizeof(array[0]))

int compareInt(const void* a, const void* b);

int main(void)
{
    int table[] = { 66, 85, 70, 92, 61, 89 };


    // bsearch関数を使う前には、対象データがソート済みでなければならないので、
    // 事前に qsort関数でソートしておく
    qsort( table, SIZE_OF_ARRAY(table), sizeof(int), compareInt );


    puts( "サーチする値を入力してください。" );
    char str[40];
    int target;
    fgets( str, sizeof(str), stdin );
    sscanf( str, "%d", &target );

    // サーチ
    int* search_result = bsearch( &target, table, SIZE_OF_ARRAY(table), sizeof(int), compareInt );
    if( search_result == NULL ){
        printf( "%d は存在しません。\n", target );
    }
    else{
        printf( "%d を発見しました。\n", target );
    }

    return 0;
}

/*
    int型による順序比較。

    引数：
        a:  比較する要素。
        b:  比較する要素。
    戻り値：
        a の方が小さいとき負数、
        b の方が小さいとき 0 より大きい値、
        a と b が同じときは 0、
        　が返される。
*/
int compareInt(const void* a, const void* b)
{
    int aNum = *(const int*)a;
    int bNum = *(const int*)b;

    if( aNum < bNum ){
        return -1;
    }
    else if( aNum > bNum ){
        return 1;
    }
    return 0;
}

実行結果：

サーチする値を入力してください。
70
70 を発見しました。

compareInt関数を qsort関数のために使うときには、仮引数 a と b は、比較する２つの要素を指し示しています。一方、bsearch関数のために使うときには、a は目的の値を指し示し、b は比較対象の要素を指し示しています。どちらのつもりで実装しても、結局コードはまったく同じになるので、このケースでは同じ関数を使いまわせます。

しかし、たとえば要素が文字列の場合を考えてみると、そうはいかないことが分かります。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define SIZE_OF_ARRAY(array)    (sizeof(array)/sizeof(array[0]))

int compareStringFor_qsort(const void* a, const void* b);
int compareStringFor_bsearch(const void* a, const void* b);

int main(void)
{
    char* table[] = {
        "Japan",
        "America",
        "Italy",
        "Thailand",
        "Mexico",
        "Russia"
    };


    // bsearch関数を使う前には、対象データがソート済みでなければならないので、
    // 事前に qsort関数でソートしておく
    qsort( table, SIZE_OF_ARRAY(table), sizeof(char*), compareStringFor_qsort );

#if 0
    // 正しくソートできていることを確認
    for( size_t i = 0; i < SIZE_OF_ARRAY(table); ++i ){
        puts( table[i] );
    }
#endif


    puts( "サーチする文字列を入力してください。" );
    char str[40];
    char target[40];
    fgets( str, sizeof(str), stdin );
    sscanf( str, "%s", target );

    // サーチ
    char** search_result = bsearch( target, table, SIZE_OF_ARRAY(table), sizeof(char*), compareStringFor_bsearch );
    if( search_result == NULL ){
        printf( "%s は存在しません。\n", target );
    }
    else{
        printf( "%s を発見しました。\n", target );
    }

    return 0;
}

/*
    char*型による順序比較 (qsort用)

    引数：
        a:  比較する要素。
        b:  比較する要素。
    戻り値：
        a の方が小さいとき負数、
        b の方が小さいとき 0 より大きい値、
        a と b が同じときは 0、
        　が返される。
*/
int compareStringFor_qsort(const void* a, const void* b)
{
    const char* s1 = *(const char**)a;
    const char* s2 = *(const char**)b;

    return strcmp( s1, s2 );
}

/*
    char*型による順序比較 (bsearch用)

    引数：
        a:  探索キー。
        b:  比較する要素。
    戻り値：
        a の方が小さいとき負数、
        b の方が小さいとき 0 より大きい値、
        a と b が同じときは 0、
        　が返される。
*/
int compareStringFor_bsearch(const void* a, const void* b)
{
    const char* s1 = (const char*)a;
    const char* s2 = *(const char**)b;

    return strcmp( s1, s2 );
}

実行結果：

サーチする文字列を入力してください。
Italy
Italy を発見しました。

ソートおよびサーチを行う配列 table の要素は、char*型です。

qsort関数を呼び出す際、第１引数に table を渡しています。いつものように、これは式の中で配列が現れており、ポインタ型に暗黙的に変換されます。元の型は char*[6] ですから、char** に変換されるのですが、qsort関数の第１引数は void* です。汎用ポインタである void* は、レベルの違いすら気にせずに受け取ってしまうのでした（第３６章）。

なお、qsort関数側が void* であるため、配列 table の要素型を const char* にしていると、const を取り除こうとして、コンパイラが警告を出すかもしれません。この辺りの都合上、Ｃ言語の const の利用は中途半端にならざるを得ません。

qsort関数のための比較用関数は、compareStringFor_qsort関数です。比較用関数の仮引数は const void* です。qsort関数の場合、これらの引数の意味は、比較する要素を指すポインタです。

今回、要素の型は char* なので、それを指すポインタの型は char** です。つまり、本来なら char** で表現されるべきポインタが、比較用関数の仕様の都合上、const char* で渡されてきているという状況です。ここでもやはり、汎用ポインタであるが故に、レベルの情報が失われているのです。

そこで、compareStringFor_qsort関数の中では、まず、本来のポインタ型に戻すキャストを行います。つまり、const char* を const char** に変換すればよいです（配列 table の要素には const は付いていませんが、付いた状態で渡されてくるのなら、それに従っておけば良いでしょう）。

その後、間接参照によって、要素の値そのものを得ます。比較は、文字列同士なので strcmp関数を使えば簡単です。

次に、bsearch関数の呼び出しを見てみましょう。今度も qsort関数のときと同じで、本来、char** で渡されるべき第２引数ですが、bsearch関数の第２引数は void* なので、レベルが失われて void* に変換されています。

また、第１引数に、サーチしたい目的の値を指すポインタを渡しています。これは本来、char[40] ですが、暗黙的に char* に変換されます。bsearch関数の第１引数は const void* なので、こちらはレベルはそのまま保たれて const void* として渡されます。

bsearch関数のための比較用関数は、compareStringFor_bsearch関数です。bsearch関数の場合、１つ目の仮引数は、目的の値を指すポインタです。これは、もともと char* だったものが const void* として渡されてきています。

一方、２つ目の仮引数は、比較対象の要素を指すポインタです。要素の型は char* なので、それを指すポインタは char** です。

この２つの引数の違いが問題です。つまり、１つ目の引数は const void* を char* に戻してやるのが正しく、２つ目の引数は const void* を char** に戻してやるのが正しいのです。このような違いは、qsort関数の比較用関数にはありませんから、比較用関数は別個に実装したものが必要です。

練習問題

問題①　関数ポインタのところで登場した、難易度に応じて処理を分岐させるサンプルプログラムに、結果を出力するような関数を追加してください。この関数は、引数で得点を受け取り、難易度ごとに異なる方法で合格・不合格を決定するものとします。たとえば、簡単なモードなら 60点で合格ですが、難しいと 80点必要という感じです。得点は、mainProcXXXX関数が戻り値で返すようにするなど、元のプログラムを一部修正して構いません。
なお、関数ポインタを使う方法と、使わない方法の両方で、プログラムを作成してください。

問題②　qsort関数や bsearch関数に渡す関数ポインタにおいて、指し示す先の関数の引数が void*型ではなく、const void*型である理由はなぜでしょうか。

解答ページはこちら。

参考リンク

『Ｃ言語ポインタ完全制覇』
- ポインタの基礎から応用まで、徹底的に解説
Programming Place Plus　Ｃ言語編　参考書籍
　– 当サイトの参考書籍一覧ページ。Ｃ言語に関する書籍を多数紹介。
Programming Place Plus　Ｃ言語編　リンク集
　– 当サイトの参考Webサイト集。Ｃ言語の全般的な学習に有益なサイトを紹介。

更新履歴

’2019/10/18
- 「関数ポインタ」の項に、関数ポインタの配列を宣言するときの構文について追記。周辺の文章も修正
’2019/7/23
- 解説のベースを C99 に上げる対応
  - ローカル変数の宣言を、ブロックの先頭以外の位置でも行う
’2019/7/18
- 解説のベースを C99 に上げる対応
  - コメントを // 形式で統一

’2018/6/1　第３７章の内容をそのままの形で移動して上書き。

’2018/4/20　「NULL」よりも「ヌルポインタ」が適切な箇所について、「ヌルポインタ」に修正。

≪さらに古い更新履歴を展開する≫

前の章へ　（第３７章　ポインタ⑦（構造体とポインタ））

次の章へ　（第３９章　ファイルの利用）

Ｃ言語編のトップページへ

Programming Place Plus のトップページへ

はてなブックマークに保存	Pocket に保存	Facebook でシェア
Twitter でツイート	Twitter をフォロー	LINE で送る
RSS	管理者情報	プライバシーポリシー

この章の概要

関数ポインタ

qsort関数

bsearch関数

練習問題

参考リンク

更新履歴