Cの関数ポインターはどこのように機能しますか？

Question

私は最近C言語で関数ポインタを使った経験があります。

それで、あなた自身の質問に答える伝統を続けて、私は主題にすぐに飛び込むことを必要とする人々のために、非常に基本の簡単な要約をすることにしました。

Answer 1

Cの関数ポインタ

を指すようになる基本的な関数から始めましょう。

int addInt(int n, int m) {
    return n+m;
}

まず、2つのintを受け取り、intを返す関数へのポインタを定義しましょう。

int (*functionPtr)(int,int);

これで、安全に自分の機能を示すことができます。

functionPtr = &addInt;

関数へのポインタができたので、それを使用しましょう。

int sum = (*functionPtr)(2, 3); // sum == 5

他の関数にポインタを渡すことは基本的に同じです。

int add2to3(int (*functionPtr)(int, int)) {
    return (*functionPtr)(2, 3);
}

戻り値に関数ポインタを使用することもできます（遅れないようにしてください、面倒になります）。

// this is a function called functionFactory which receives parameter n
// and returns a pointer to another function which receives two ints
// and it returns another int
int (*functionFactory(int n))(int, int) {
    printf("Got parameter %d", n);
    int (*functionPtr)(int,int) = &addInt;
    return functionPtr;
}

しかしtypedefを使うほうがずっといいです：

typedef int (*myFuncDef)(int, int);
// note that the typedef name is indeed myFuncDef

myFuncDef functionFactory(int n) {
    printf("Got parameter %d", n);
    myFuncDef functionPtr = &addInt;
    return functionPtr;
}

Answer 2

Cの関数ポインタを使用して、Cでオブジェクト指向プログラミングを実行できます。

たとえば、次の行はCで記述されています。

String s1 = newString();
s1->set(s1, "hello");

はい、->とnew演算子の欠如は無意味ですが、いくつかのStringクラスのテキストを"hello"に設定していることを意味しているようです。

関数ポインタを使用することにより、Cでメソッドをエミュレートすることが可能。

これはどのように達成されますか？

Stringクラスは、実際にはメソッドをシミュレートする方法として機能する関数ポインターの束を持つstructです。以下は、Stringクラスの部分的な宣言です。

typedef struct String_Struct* String;

struct String_Struct
{
    char* (*get)(const void* self);
    void (*set)(const void* self, char* value);
    int (*length)(const void* self);
};

char* getString(const void* self);
void setString(const void* self, char* value);
int lengthString(const void* self);

String newString();

ご覧のとおり、Stringクラスのメソッドは、実際には宣言された関数への関数ポインターです。 Stringのインスタンスを準備する際に、それぞれの関数への関数ポインターをセットアップするためにnewString関数が呼び出されます。

String newString()
{
    String self = (String)malloc(sizeof(struct String_Struct));

    self->get = &getString;
    self->set = &setString;
    self->length = &lengthString;

    self->set(self, "");

    return self;
}

たとえば、getStringメソッドを呼び出して呼び出されるget関数は、次のように定義されます。

char* getString(const void* self_obj)
{
    return ((String)self_obj)->internal->value;
}

注目できることの1つは、オブジェクトのインスタンスの概念がなく、実際にはオブジェクトの一部であるメソッドを持っているため、呼び出しごとに「自己オブジェクト」を渡す必要があるということです。 （また、internalは、以前のコードリストから省略された隠されたstructにすぎません。これは、情報の隠蔽を実行する方法ですが、関数ポインターには関係ありません。）

そのため、s1->set("hello");を実行できるのではなく、s1->set(s1, "hello")でアクションを実行するためにオブジェクトを渡す必要があります。

ささいな説明は自分への参照を邪魔にならないように渡さなければならないので、次の部分であるCの継承に進みます。

Stringのサブクラス、たとえばImmutableStringを作成するとします。文字列を不変にするために、setおよびgetへのアクセスを維持しながら、lengthメソッドにアクセスできず、「コンストラクター」にchar*を強制的に受け入れさせます。

typedef struct ImmutableString_Struct* ImmutableString;

struct ImmutableString_Struct
{
    String base;

    char* (*get)(const void* self);
    int (*length)(const void* self);
};

ImmutableString newImmutableString(const char* value);

基本的に、すべてのサブクラスで利用可能なメソッドは、再び関数ポインターです。今回は、setメソッドの宣言が存在しないため、ImmutableStringで呼び出すことはできません。

ImmutableStringの実装に関しては、関連するコードは「コンストラクター」関数であるnewImmutableStringのみです。

ImmutableString newImmutableString(const char* value)
{
    ImmutableString self = (ImmutableString)malloc(sizeof(struct ImmutableString_Struct));

    self->base = newString();

    self->get = self->base->get;
    self->length = self->base->length;

    self->base->set(self->base, (char*)value);

    return self;
}

ImmutableStringをインスタンス化する際、getおよびlengthメソッドへの関数ポインターは、内部的に保存されているbaseオブジェクトであるString変数を介して、実際にString.getおよびString.lengthメソッドを参照します。

関数ポインターを使用すると、スーパークラスからメソッドを継承できます。

さらに続けることができますCの多型。

たとえば、何らかの理由でlengthメソッドの動作を変更して、ImmutableStringクラスで常に0を返すようにしたい場合は、以下を行う必要があります。

1. オーバーライドするlengthメソッドとして機能する関数を追加します。
2. 「コンストラクター」に移動し、オーバーライドするlengthメソッドに関数ポインターを設定します。

lengthにオーバーライドするImmutableStringメソッドを追加するには、lengthOverrideMethodを追加します。

int lengthOverrideMethod(const void* self)
{
    return 0;
}

次に、コンストラクター内のlengthメソッドの関数ポインターがlengthOverrideMethodに接続されます。

ImmutableString newImmutableString(const char* value)
{
    ImmutableString self = (ImmutableString)malloc(sizeof(struct ImmutableString_Struct));

    self->base = newString();

    self->get = self->base->get;
    self->length = &lengthOverrideMethod;

    self->base->set(self->base, (char*)value);

    return self;
}

これで、lengthクラスのImmutableStringメソッドの動作がStringクラスと同じではなく、lengthメソッドがlengthOverrideMethod関数で定義された動作を参照するようになりました。

私はまだCでオブジェクト指向プログラミングスタイルを使用して書く方法を学んでいるという免責事項を追加する必要があります。 CのOOP。しかし、私の目的は、関数ポインターの多くの使用法の1つを説明することでした。

Cでオブジェクト指向プログラミングを実行する方法の詳細については、次の質問を参照してください。

• Cのオブジェクト指向？
• Cでオブジェクト指向コードを記述できますか？

Answer 3

解雇の手引き：コードを手でコンパイルしてx86マシンのGCCで関数ポインタを悪用する方法：

これらの文字列リテラルは、32ビットx86マシンコードのバイトです。 0xC3は x86のret命令です 。

通常はこれらを手で書くのではなく、アセンブリ言語で書いてからnasmのようなアセンブラを使ってフラットなバイナリに組み立て、それをCの文字列リテラルに16進ダンプします。

1. EAXレジスタの現在の値を返します

   int eax = ((int(*)())("\xc3 <- This returns the value of the EAX register"))();
   

2. スワップ関数を書く

   int a = 10, b = 20;
   ((void(*)(int*,int*))"\x8b\x44\x24\x04\x8b\x5c\x24\x08\x8b\x00\x8b\x1b\x31\xc3\x31\xd8\x31\xc3\x8b\x4c\x24\x04\x89\x01\x8b\x4c\x24\x08\x89\x19\xc3 <- This swaps the values of a and b")(&a,&b);
   

3. 毎回何らかの関数を呼び出して、for-loopカウンタを1000に書きます。

   ((int(*)())"\x66\x31\xc0\x8b\x5c\x24\x04\x66\x40\x50\xff\xd3\x58\x66\x3d\xe8\x03\x75\xf4\xc3")(&function); // calls function with 1->1000
   

4. 100まで数える再帰関数を書くことさえできます

   const char* lol = "\x8b\x5c\x24\x4\x3d\xe8\x3\x0\x0\x7e\x2\x31\xc0\x83\xf8\x64\x7d\x6\x40\x53\xff\xd3\x5b\xc3\xc3 <- Recursively calls the function at address lol.";
   i = ((int(*)())(lol))(lol);
   

コンパイラは.rodataセクション（またはWindowsでは.rdata）に文字列リテラルを配置します。これはテキストセグメントの一部として（関数のコードと共に）リンクされています。

テキストセグメントはRead + Execパーミッションを持っているので、文字列リテラルを関数ポインタにキャストすると、動的に割り当てられたメモリを必要とするようなmprotect()やVirtualProtect()システムコールを必要とせずに動作します。 （またはgcc -z execstackは、プログラムとスタック+データセグメント+ヒープ実行可能ファイルをリンクしています（簡単な方法）。）

---

これらを逆アセンブルするには、これをコンパイルしてバイトにラベルを付け、逆アセンブラを使用します。

// at global scope
const char swap[] = "\x8b\x44\x24\x04\x8b\x5c\x24\x08\x8b\x00\x8b\x1b\x31\xc3\x31\xd8\x31\xc3\x8b\x4c\x24\x04\x89\x01\x8b\x4c\x24\x08\x89\x19\xc3 <- This swaps the values of a and b";

gcc -c -m32 foo.cを使用してコンパイルし、objdump -D -rwC -Mintelを使用して逆アセンブルすると、アセンブリを取得することができます。このコードはEBX（呼び出し保存レジスタ）を乱用することによってABIに違反し、一般に非効率的です。

00000000 <swap>:
   0:   8b 44 24 04             mov    eax,DWORD PTR [esp+0x4]   # load int *a arg from the stack
   4:   8b 5c 24 08             mov    ebx,DWORD PTR [esp+0x8]   # ebx = b
   8:   8b 00                   mov    eax,DWORD PTR [eax]       # dereference: eax = *a
   a:   8b 1b                   mov    ebx,DWORD PTR [ebx]
   c:   31 c3                   xor    ebx,eax                # pointless xor-swap
   e:   31 d8                   xor    eax,ebx                # instead of just storing with opposite registers
  10:   31 c3                   xor    ebx,eax
  12:   8b 4c 24 04             mov    ecx,DWORD PTR [esp+0x4]  # reload a from the stack
  16:   89 01                   mov    DWORD PTR [ecx],eax     # store to *a
  18:   8b 4c 24 08             mov    ecx,DWORD PTR [esp+0x8]
  1c:   89 19                   mov    DWORD PTR [ecx],ebx
  1e:   c3                      ret    

  not shown: the later bytes are ASCII text documentation
  they're not executed by the CPU because the ret instruction sends execution back to the caller

このマシンコードは（おそらく）Windows、Linux、OS Xなどで32ビットコードで動作します。これらすべてのOSのデフォルトの呼び出し規約は、より効率的なレジスタではなくスタックで引数を渡します。しかし、EBXは通常のすべての呼び出し規約で呼び出しが保存されるため、保存や復元を行わずにスクラッチレジスタとして使用すると、呼び出し元がクラッシュすることがあります。

Answer 4

関数ポインタの私のお気に入りの用途の一つは安価で簡単なイテレータです -

#include <stdio.h>
#define MAX_COLORS  256

typedef struct {
    char* name;
    int red;
    int green;
    int blue;
} Color;

Color Colors[MAX_COLORS];


void eachColor (void (*fp)(Color *c)) {
    int i;
    for (i=0; i<MAX_COLORS; i++)
        (*fp)(&Colors[i]);
}

void printColor(Color* c) {
    if (c->name)
        printf("%s = %i,%i,%i\n", c->name, c->red, c->green, c->blue);
}

int main() {
    Colors[0].name="red";
    Colors[0].red=255;
    Colors[1].name="blue";
    Colors[1].blue=255;
    Colors[2].name="black";

    eachColor(printColor);
}

Answer 5

基本的な宣言子ができれば、関数ポインタは宣言しやすくなります。

• id：ID：IDはa
• ポインタ：*D：Dへのポインタ
• 機能：D(<parameters>)：<parameters>を返すD関数

Dは同じ規則を使って作られたもう一つの宣言子です。最後に、どこかで、宣言されたエンティティの名前であるIDで終わります（例については下記を参照）。何もしない関数へのポインタを取ってintを返す関数を構築してみましょう。そしてcharを取ってintを返す関数へのポインタを返します。型定義では、これは次のようになります。

typedef int ReturnFunction(char);
typedef int ParameterFunction(void);
ReturnFunction *f(ParameterFunction *p);

ご覧のとおり、typedefを使用して構築するのはとても簡単です。 typedefがなければ、一貫して適用される上記の宣言子の規則も難しくありません。ご覧のとおり、ポインタが指す部分、および関数が返すものを見逃しています。それが宣言の一番左に表示されるものであり、興味深いものではありません。宣言子をすでに作成している場合は最後に追加されます。それをしましょう。一貫してそれを構築する、最初の言葉で言うと[と]を使って構造を示す：

function taking 
    [pointer to [function taking [void] returning [int]]] 
returning
    [pointer to [function taking [char] returning [int]]]

ご覧のとおり、宣言子を次々に追加することで型を完全に記述できます。建設は2つの方法で行うことができます。 1つはボトムアップです。非常に正しいこと（葉）から始めて、識別子までの道を進みます。もう1つの方法は、トップダウンで、識別子から始めてリーフまでの作業です。両方の方法を紹介します。

一気飲み

構築は右側のものから始まります。返されたもの、つまりcharを取る関数です。宣言子を明確にするために、番号を付けます。

D1(char);

簡単なので、charパラメータを直接挿入しました。 D1を*D2に置き換えることによって、宣言子へのポインタを追加します。 *D2を括弧で囲む必要があることに注意してください。これは*-operatorと関数呼び出し演算子()の優先順位を調べることで知ることができます。括弧がなければ、コンパイラはそれを*(D2(char p))と読みます。しかし、もちろんこれは*D2によるD1の単なる置き換えにはなりません。括弧は、宣言子の周囲では常に許可されています。それで、あまりにも多く追加しても、実際には何も間違っていません。

(*D2)(char);

返品タイプは完了です！それでは、D2を関数宣言子<parameters>が返す関数に置き換えましょう。これは現在のD3(<parameters>)です。

(*D3(<parameters>))(char)

今回はwantD3を関数宣言子にし、ポインタ宣言子にはしないため、括弧は不要です。素晴らしい、残っているのはそのためのパラメータだけです。このパラメータは、charをvoidに置き換えただけで、戻り型と同じように処理されます。だから私はそれをコピーします：

(*D3(   (*ID1)(void)))(char)

D2をID1に置き換えました。これはそのパラメーターで終了したためです（既に関数へのポインターです - 別の宣言子は必要ありません）。 ID1はパラメータの名前になります。さて、最後に上で述べたように、それらすべての宣言子が変更する型を追加します - すべての宣言の一番左に表示されるものです。関数の場合は、それが戻り型になります。ポインターの場合は型を指すなど...型を書き留めておくとおもしろいです。逆の順序で表示されます。右側には表示されます。もちろん両方ともintです。

int (*ID0(int (*ID1)(void)))(char)

この例では、関数の識別子をID0と呼びました。

トップダウン

これは型の説明の左端の識別子から始まり、右側を進むにつれてその宣言子をラップします。 <parameters>を返す関数で始めてください

ID0(<parameters>)

説明の中の次のもの（「戻る」の後）はへのポインタです。組み込みましょう。

*ID0(<parameters>)

それから次のことはfuncton取り<parameters>戻り} _でした。このパラメータは単純な文字です。本当に簡単なので、すぐに入れ直します。

(*ID0(<parameters>))(char)

*が最初にバインドされ、then _ (char)が再びバインドされるようにしたいので、追加した括弧に注意してください。そうでなければ、それは<parameters>が関数を返しています...となります。いいえ、関数を返す関数は許可されていません。

今<parameters>を置くだけです。私はあなたがすでにそれをする方法の考えを既に持っていると思うので、派生の短いバージョンを示すつもりです。

pointer to: *ID1
... function taking void returning: (*ID1)(void)

ボトムアップで行ったようにintを宣言子の前に置くだけで完了です。

int (*ID0(int (*ID1)(void)))(char)

いいこと

ボトムアップまたはトップダウンが良いですか？私はボトムアップに慣れていますが、トップダウンに慣れている人もいます。それは私が思うに好みの問題です。ちなみに、その宣言にすべての演算子を適用すると、intを取得することになります。

int v = (*ID0(some_function_pointer))(some_char);

これは、Cの宣言のNiceプロパティです。宣言は、これらの演算子が識別子を使用した式で使用されている場合、左端の型を生成すると主張しています。配列もそうです。

あなたがこの小さなチュートリアルが好きなことを願っています！関数の奇妙な宣言の構文について人々が疑問に思うとき、今これをリンクすることができます。私はCの内部をできるだけ少なくしようとしました。その中のものを編集/修正してください。

Answer 6

関数ポインタのもう一つの良い使い方は：
バージョンを簡単に切り替える

さまざまな時期やさまざまな開発段階でさまざまな機能が必要な場合に使用すると非常に便利です。たとえば、私はコンソールを持つホストコンピュータ上でアプリケーションを開発していますが、このソフトウェアの最終リリースはAvnet ZedBoard（ディスプレイとコンソール用のポートを持っていますが、これらは必要ではありません）最終リリース）。そのため、開発中はステ​​ータスとエラーメッセージを表示するためにprintfを使用しますが、作業が終わったら何も印刷したくありません。これが私がしたことです：

version.h

// First, undefine all macros associated with version.h
#undef DEBUG_VERSION
#undef RELEASE_VERSION
#undef INVALID_VERSION


// Define which version we want to use
#define DEBUG_VERSION       // The current version
// #define RELEASE_VERSION  // To be uncommented when finished debugging

#ifndef __VERSION_H_      /* prevent circular inclusions */
    #define __VERSION_H_  /* by using protection macros */
    void board_init();
    void noprintf(const char *c, ...); // mimic the printf prototype
#endif

// Mimics the printf function prototype. This is what I'll actually 
// use to print stuff to the screen
void (* zprintf)(const char*, ...); 

// If debug version, use printf
#ifdef DEBUG_VERSION
    #include <stdio.h>
#endif

// If both debug and release version, error
#ifdef DEBUG_VERSION
#ifdef RELEASE_VERSION
    #define INVALID_VERSION
#endif
#endif

// If neither debug or release version, error
#ifndef DEBUG_VERSION
#ifndef RELEASE_VERSION
    #define INVALID_VERSION
#endif
#endif

#ifdef INVALID_VERSION
    // Won't allow compilation without a valid version define
    #error "Invalid version definition"
#endif

version.cでは、version.hにある2つの関数プロトタイプを定義します。

version.c

#include "version.h"

/*****************************************************************************/
/**
* @name board_init
*
* Sets up the application based on the version type defined in version.h.
* Includes allowing or prohibiting printing to STDOUT.
*
* MUST BE CALLED FIRST THING IN MAIN
*
* @return    None
*
*****************************************************************************/
void board_init()
{
    // Assign the print function to the correct function pointer
    #ifdef DEBUG_VERSION
        zprintf = &printf;
    #else
        // Defined below this function
        zprintf = &noprintf;
    #endif
}

/*****************************************************************************/
/**
* @name noprintf
*
* simply returns with no actions performed
*
* @return   None
*
*****************************************************************************/
void noprintf(const char* c, ...)
{
    return;
}

関数ポインタがversion.hで次のようにプロトタイプされていることに注意してください。

void (* zprintf)(const char *, ...);

それがアプリケーションで参照されるとき、それはそれが指し示しているところはどこでも実行を開始するでしょう。

version.cでは、version.hで定義されているバージョンに応じて、zprintfに固有の関数（その関数シグニチャーが一致する）が割り当てられているboard_init()functionに注目してください。

zprintf = &printf; zprintfはデバッグ目的でprintfを呼び出します

または

zprintf = &noprint; zprintfは戻るだけで、不要なコードは実行されません。

コードを実行すると、このようになります。

mainProg.c

#include "version.h"
#include <stdlib.h>
int main()
{
    // Must run board_init(), which assigns the function
    // pointer to an actual function
    board_init();

    void *ptr = malloc(100); // Allocate 100 bytes of memory
    // malloc returns NULL if unable to allocate the memory.

    if (ptr == NULL)
    {
        zprintf("Unable to allocate memory\n");
        return 1;
    }

    // Other things to do...
    return 0;
}

上記のコードは、デバッグモードの場合はprintfを使用し、リリースモードの場合は何もしません。これは、プロジェクト全体を調べてコードをコメントアウトまたは削除するよりもはるかに簡単です。私がする必要があるのはversion.hのバージョンを変更することだけです、そして、コードは残りをするでしょう！

Answer 7

関数ポインタは通常typedefによって定義され、param＆return valueとして使われます。

上記の答えはすでに多くのことを説明しています、私はちょうど完全な例を挙げます：

#include <stdio.h>

#define NUM_A 1
#define NUM_B 2

// define a function pointer type
typedef int (*two_num_operation)(int, int);

// an actual standalone function
static int sum(int a, int b) {
    return a + b;
}

// use function pointer as param,
static int sum_via_pointer(int a, int b, two_num_operation funp) {
    return (*funp)(a, b);
}

// use function pointer as return value,
static two_num_operation get_sum_fun() {
    return &sum;
}

// test - use function pointer as variable,
void test_pointer_as_variable() {
    // create a pointer to function,
    two_num_operation sum_p = &sum;
    // call function via pointer
    printf("pointer as variable:\t %d + %d = %d\n", NUM_A, NUM_B, (*sum_p)(NUM_A, NUM_B));
}

// test - use function pointer as param,
void test_pointer_as_param() {
    printf("pointer as param:\t %d + %d = %d\n", NUM_A, NUM_B, sum_via_pointer(NUM_A, NUM_B, &sum));
}

// test - use function pointer as return value,
void test_pointer_as_return_value() {
    printf("pointer as return value:\t %d + %d = %d\n", NUM_A, NUM_B, (*get_sum_fun())(NUM_A, NUM_B));
}

int main() {
    test_pointer_as_variable();
    test_pointer_as_param();
    test_pointer_as_return_value();

    return 0;
}

Answer 8

Cの関数ポインタの大きな用途の1つは、実行時に選択された関数を呼び出すことです。例えば、Cランタイムライブラリには2つのルーチン qsort と bsearch があり、これらはソートされる2つの項目を比較するために呼び出される関数へのポインタを取ります。これにより、使用する基準に基づいて、それぞれ何でもソートまたは検索できます。

非常に基本的な例として、print(int x, int y)という名前の関数が1つあってその関数を呼び出す必要がある場合（同じ型のadd()またはsub()のどちらか）、次にprint()に1つの関数ポインタ引数を追加します。以下に示すように機能します。

#include <stdio.h>

int add()
{
   return (100+10);
}

int sub()
{
   return (100-10);
}

void print(int x, int y, int (*func)())
{
    printf("value is: %d\n", (x+y+(*func)()));
}

int main()
{
    int x=100, y=200;
    print(x,y,add);
    print(x,y,sub);

    return 0;
}

出力は以下のとおりです。

値は410です。
値は390です。

Answer 9

関数ポインタは、関数のアドレスを含む変数です。それはいくつかの制限された特性を持っているけれどもそれはポインタ変数であるので、あなたはデータ構造における他のポインタ変数と同じようにそれを使うことができます。

私が考えることができる唯一の例外は、単一の値以外の何かを指すものとして関数ポインタを扱うことです。関数ポインタは1つのもの、つまり関数の入り口点を指すだけなので、関数ポインタの増分または減分、または関数ポインタへのオフセットの加減によってポインタ演算を実行することは実際には役に立ちません。

関数ポインタ変数のサイズ、変数によって占められるバイト数は、基礎となるアーキテクチャに応じて変化し得る。 x 32またはx 64または何でも。

関数ポインター変数の宣言は、Cコンパイラーが通常行う種類の検査を実行するために、関数宣言と同じ種類の情報を指定する必要があります。関数ポインタの宣言/定義でパラメータリストを指定しないと、Cコンパイラはパラメータの使用をチェックできません。このチェックの欠如が役に立つ場合がありますが、セーフティネットが削除されたことを忘れないでください。

いくつかの例：

int func (int a, char *pStr);    // declares a function

int (*pFunc)(int a, char *pStr);  // declares or defines a function pointer

int (*pFunc2) ();                 // declares or defines a function pointer, no parameter list specified.

int (*pFunc3) (void);             // declares or defines a function pointer, no arguments.

最初の2つの宣言は、次の点でやや似ています。

• funcは、intとchar *を受け取り、intを返す関数です。
• pFuncは、intおよびchar *を受け取り、intを返す関数のアドレスが割り当てられている関数ポインターです。

したがって、上記から、pFunc = func;のように、関数func()のアドレスが関数ポインタ変数pFuncに割り当てられるソース行を持つことができます。

関数ポインタ宣言/定義で使用されている構文に注意してください。括弧は、自然な演算子の優先順位規則を克服するために使用されています。

int *pfunc(int a, char *pStr);    // declares a function that returns int pointer
int (*pFunc)(int a, char *pStr);  // declares a function pointer that returns an int

いくつかの異なる使用例

関数ポインタの使用例

int (*pFunc) (int a, char *pStr);    // declare a simple function pointer variable
int (*pFunc[55])(int a, char *pStr); // declare an array of 55 function pointers
int (**pFunc)(int a, char *pStr);    // declare a pointer to a function pointer variable
struct {                             // declare a struct that contains a function pointer
    int x22;
    int (*pFunc)(int a, char *pStr);
} thing = {0, func};                 // assign values to the struct variable
char * xF (int x, int (*p)(int a, char *pStr));  // declare a function that has a function pointer as an argument
char * (*pxF) (int x, int (*p)(int a, char *pStr));  // declare a function pointer that points to a function that has a function pointer as an argument

関数ポインタの定義では可変長パラメータリストを使用できます。

int sum (int a, int b, ...);
int (*psum)(int a, int b, ...);

または、パラメータリストをまったく指定できません。これは役に立ちますが、Cコンパイラが提供された引数リストをチェックする機会がなくなります。

int  sum ();      // nothing specified in the argument list so could be anything or nothing
int (*psum)();
int  sum2(void);  // void specified in the argument list so no parameters when calling this function
int (*psum2)(void);

Cスタイルキャスト

関数ポインタを使ってCスタイルのキャストを使用できます。ただし、Cコンパイラはエラーではなくチェックに不安を感じたり、警告を出したりすることがあります。

int sum (int a, char *b);
int (*psplsum) (int a, int b);
psplsum = sum;               // generates a compiler warning
psplsum = (int (*)(int a, int b)) sum;   // no compiler warning, cast to function pointer
psplsum = (int *(int a, int b)) sum;     // compiler error of bad cast generated, parenthesis are required.

等値関数ポインタへの比較

ifステートメントを使用して、関数ポインタが特定の関数アドレスと等しいことを確認できますが、それがどれほど有用であるかはわかりませんが。他の比較演算子では、それほど有用性がありません。

static int func1(int a, int b) {
    return a + b;
}

static int func2(int a, int b, char *c) {
    return c[0] + a + b;
}

static int func3(int a, int b, char *x) {
    return a + b;
}

static char *func4(int a, int b, char *c, int (*p)())
{
    if (p == func1) {
        p(a, b);
    }
    else if (p == func2) {
        p(a, b, c);      // warning C4047: '==': 'int (__cdecl *)()' differs in levels of indirection from 'char *(__cdecl *)(int,int,char *)'
    } else if (p == func3) {
        p(a, b, c);
    }
    return c;
}

関数ポインタの配列

また、引数リストに違いがある各要素の関数ポインタの配列が必要な場合は、引数リストを指定せずに（voidを指定せずに、未指定を指定して）次のような関数ポインタを定義できます。 Cコンパイラから警告が出るかもしれません。これは、関数への関数ポインタパラメータに対しても機能します。

int(*p[])() = {       // an array of function pointers
    func1, func2, func3
};
int(**pp)();          // a pointer to a function pointer


p[0](a, b);
p[1](a, b, 0);
p[2](a, b);      // oops, left off the last argument but it compiles anyway.

func4(a, b, 0, func1);
func4(a, b, 0, func2);  // warning C4047: 'function': 'int (__cdecl *)()' differs in levels of indirection from 'char *(__cdecl *)(int,int,char *)'
func4(a, b, 0, func3);

    // iterate over the array elements using an array index
for (i = 0; i < sizeof(p) / sizeof(p[0]); i++) {
    func4(a, b, 0, p[i]);
}
    // iterate over the array elements using a pointer
for (pp = p; pp < p + sizeof(p)/sizeof(p[0]); pp++) {
    (*pp)(a, b, 0);          // pointer to a function pointer so must dereference it.
    func4(a, b, 0, *pp);     // pointer to a function pointer so must dereference it.
}

Cスタイルnamespace関数ポインタでグローバルstructを使う

staticキーワードを使用して、ファイルスコープという名前の関数を指定し、これをC++のnamespace機能に似たものを提供する方法としてグローバル変数に割り当てることができます。

ヘッダファイルでは、それを使用するグローバル変数とともに、名前空間となる構造体を定義します。

typedef struct {
   int (*func1) (int a, int b);             // pointer to function that returns an int
   char *(*func2) (int a, int b, char *c);  // pointer to function that returns a pointer
} FuncThings;

extern const FuncThings FuncThingsGlobal;

それからCソースファイルで：

#include "header.h"

// the function names used with these static functions do not need to be the
// same as the struct member names. It's just helpful if they are when trying
// to search for them.
// the static keyword ensures these names are file scope only and not visible
// outside of the file.
static int func1 (int a, int b)
{
    return a + b;
}

static char *func2 (int a, int b, char *c)
{
    c[0] = a % 100; c[1] = b % 50;
    return c;
}

const FuncThings FuncThingsGlobal = {func1, func2};

これは、グローバル構造体変数の完全な名前と関数にアクセスするためのメンバ名を指定することによって使用されます。 const修飾子はグローバルで使用されるので、誤って変更することはできません。

int abcd = FuncThingsGlobal.func1 (a, b);

機能ポインタの応用分野

DLLライブラリコンポーネントは、関数ポインタを含むnamespaceの作成をサポートするライブラリインターフェイスのファクトリメソッドから特定のライブラリインターフェイスが要求されるCスタイルのstructアプローチに似たことをすることができます。 interfaceは、要求されたDLL versionをロードし、必要な関数ポインタを持つ構造体を作成してから、その構造体を使用するために要求元の呼び出し側に返します。

typedef struct {
    HMODULE  hModule;
    int (*Func1)();
    int (*Func2)();
    int(*Func3)(int a, int b);
} LibraryFuncStruct;

int  LoadLibraryFunc LPCTSTR  dllFileName, LibraryFuncStruct *pStruct)
{
    int  retStatus = 0;   // default is an error detected

    pStruct->hModule = LoadLibrary (dllFileName);
    if (pStruct->hModule) {
        pStruct->Func1 = (int (*)()) GetProcAddress (pStruct->hModule, "Func1");
        pStruct->Func2 = (int (*)()) GetProcAddress (pStruct->hModule, "Func2");
        pStruct->Func3 = (int (*)(int a, int b)) GetProcAddress(pStruct->hModule, "Func3");
        retStatus = 1;
    }

    return retStatus;
}

void FreeLibraryFunc (LibraryFuncStruct *pStruct)
{
    if (pStruct->hModule) FreeLibrary (pStruct->hModule);
    pStruct->hModule = 0;
}

これは次のように使うことができます。

LibraryFuncStruct myLib = {0};
LoadLibraryFunc (L"library.dll", &myLib);
//  ....
myLib.Func1();
//  ....
FreeLibraryFunc (&myLib);

基本的なハードウェアの特定のモデルを使用するコードのための抽象的なハードウェア層を定義するために同じアプローチを使用することができます。機能ポインタは、ファクトリによってハードウェア固有の機能で埋められ、抽象ハードウェアモデルで指定された機能を実装するハードウェア固有の機能を提供します。これは、特定のハードウェア関数インタフェースを取得するためにファクトリ関数を呼び出すソフトウェアによって使用される抽象ハードウェア層を提供するために使用できます。 。

デリゲート、ハンドラ、およびコールバックを作成するための関数ポインタ

タスクや機能を委任する方法として、関数ポインタを使用できます。 Cの典型的な例は、標準Cライブラリ関数qsort()およびbsearch()とともに使用され、項目リストのソートまたはソートされた項目リストに対するバイナリ検索の照合順序を提供する比較デリゲート関数ポインタです。比較関数デリゲートは、ソートまたはバイナリ検索で使用される照合アルゴリズムを指定します。

もう1つの用途は、C++標準テンプレートライブラリコンテナにアルゴリズムを適用することに似ています。

void * ApplyAlgorithm (void *pArray, size_t sizeItem, size_t nItems, int (*p)(void *)) {
    unsigned char *pList = pArray;
    unsigned char *pListEnd = pList + nItems * sizeItem;
    for ( ; pList < pListEnd; pList += sizeItem) {
        p (pList);
    }

    return pArray;
}

int pIncrement(int *pI) {
    (*pI)++;

    return 1;
}

void * ApplyFold(void *pArray, size_t sizeItem, size_t nItems, void * pResult, int(*p)(void *, void *)) {
    unsigned char *pList = pArray;
    unsigned char *pListEnd = pList + nItems * sizeItem;
    for (; pList < pListEnd; pList += sizeItem) {
        p(pList, pResult);
    }

    return pArray;
}

int pSummation(int *pI, int *pSum) {
    (*pSum) += *pI;

    return 1;
}

// source code and then lets use our function.
int intList[30] = { 0 }, iSum = 0;

ApplyAlgorithm(intList, sizeof(int), sizeof(intList) / sizeof(intList[0]), pIncrement);
ApplyFold(intList, sizeof(int), sizeof(intList) / sizeof(intList[0]), &iSum, pSummation);

もう1つの例は、イベントが発生したときに実際に呼び出される関数ポインタを提供することによって特定のイベントのハンドラが登録されるGUIソースコードです。メッセージマップを含むMicrosoft MFCフレームワークは、ウィンドウまたはスレッドに配信されるWindowsメッセージを処理するのに似たようなものを使用します。

コールバックを必要とする非同期関数はイベントハンドラに似ています。非同期機能のユーザーは、非同期機能を呼び出してアクションを開始し、アクションが完了すると非同期機能が呼び出す関数ポインターを提供します。この場合、イベントはそのタスクを完了する非同期関数です。

Answer 10

最初から始まる関数は、実行を開始する場所からいくつかのメモリアドレスを持っています。アセンブリ言語では、それらは（call "function's memory address"）と呼ばれるようになりました。Cに戻る関数にメモリアドレスがある場合、それらはC.のポインタによって操作することができます。

1.最初に関数へのポインタを宣言する必要があります2.目的の関数のアドレスを渡します

****注 - >関数は同じ型であるべきです****

この簡単なプログラムはあらゆることを説明します。

#include<stdio.h>
void (*print)() ;//Declare a  Function Pointers
void sayhello();//Declare The Function Whose Address is to be passed
                //The Functions should Be of Same Type
int main()
{

 print=sayhello;//Addressof sayhello is assigned to print
 print();//print Does A call To The Function 
 return 0;
}

void sayhello()
{
 printf("\n Hello World");
}

その後は、どのようにしてmachineが上記のプログラムの32ビットアーキテクチャでの機械語命令を理解するのかを理解することができます。

赤いマーク領域は、アドレスがどのように交換され、eaxに格納されているかを示しています。これらはeaxの呼び出し命令です。 eaxは関数の希望するアドレスを含みます

Answer 11

関数ポインタはしばしば型付けされたコールバックなので、 type safe callbacks を見た方がいいかもしれません。コールバックではない関数のエントリポイントなども同様です。

Cはかなり気まぐれで同時に許しています:)