Wie Funktionszeigern in C arbeiten?

Funktionszeigern in C

Beginnen wir mit einem basic-Funktion, die wir Hinweis auf:

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

Erstes definieren wir einen Zeiger auf eine Funktion, die Sie erhält: 2 ints und gibt eine int:

int (*functionPtr)(int,int);

Nun können wir sicher auf unserer Funktion:

functionPtr = &addInt;

Nun haben wir einen Zeiger auf die Funktion, lasst uns es verwenden:

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

Übergeben Sie den Zeiger auf eine andere Funktion ist im Grunde das gleiche:

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

Können wir die Verwendung von Funktionszeigern in return-Werte als auch (versuchen zu halten, wird es unordentlich):

//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;
}

Aber es ist viel schöner zu verwenden, eine 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;
}

InformationsquelleAutor Yuval Adam

Den guide, um gefeuert zu werden: Wie, um Missbrauch zu Funktionszeigern in GCC auf x86-Rechner kompilieren Sie Ihren code von hand:

Diese string-Literale sind bytes der 32-bit-x86-Maschinencode. 0xC3 ist ein x86 ret - Anweisung.

Würden Sie normalerweise nicht schreiben, dies von hand zu machen, würden Sie schreiben in Assembler und dann verwenden Sie einen assembler, wie nasm zur Montage in eine flache binären die Sie hexdump in eine C-string-literal.

1. Gibt den aktuellen Wert auf dem register "EAX"

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

2. Schreiben Sie eine swap-Funktion

   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. Schreiben Sie eine for-Schleife Zähler bis 1000, rief einige Funktion jedes mal

   ((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. Sie können sogar schreiben Sie eine rekursive Funktion, die zählt 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);

Beachten Sie, dass Compiler Ort, string-Literale in die .rodata Abschnitt (oder .rdata auf Windows), die verknüpft ist als Teil des text-segment (zusammen mit dem code für Funktionen).

Text-segment Gelesen hat+Exec-Berechtigung, so casting-string-Literale zu Funktionszeigern arbeitet ohne mprotect() oder VirtualProtect() system-Aufrufe, wie Sie müssten für dynamisch allozierten Speicher. (Oder gcc -z execstack links das Programm mit stack + Daten segment + heap ausführbar, als ein quick-hack.)

---

Zerlegen diese, können Sie kompilieren Sie diese, setzen Sie ein label auf die bytes, und ein disassembler.

//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";

Kompilieren mit gcc -c -m32 foo.c an-und Abbau mit objdump -D -rwC -Mintel können wir die Montage, und finden Sie heraus, dass dieser code verletzt das ABI durch Stress EBX (ein Anruf erhaltene register) und ist in der Regel ineffizient.

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

Dieser Maschinencode wird (wahrscheinlich) 32-bit-code auf Windows, Linux, OS X, und so weiter: die Standard-Aufruf-Konventionen auf allen diesen Betriebssystemen pass Argumente auf dem stack statt effizienter in Registern. Aber EBX call-erhalten Sie in den üblichen Aufruf-Konventionen, also der Einsatz als scratch-register, ohne speichern/wiederherstellen Sie können ganz einfach die Anrufer-crash.

InformationsquelleAutor

Funktion Zeiger werden einfach zu erklären, sobald Sie die basic-declarators:

• id: ID: - ID ist eine
• Zeiger: *D: D Zeiger auf
• Funktion: D(<parameters>): D Funktion, die <Parameter> Rückkehr

Während D eine weitere Feststellung gebaut, mit den gleichen Regeln. Am Ende, irgendwo, es endet mit ID (siehe unten für ein Beispiel), das ist der name der deklarierten Entität. Wir werden versuchen, zu erstellen eine Funktion, die einen Zeiger auf eine Funktion, die nichts und int Rückkehr und für die Rückgabe einen Zeiger auf eine Funktion, die ein char und zurückgeben. int. Mit type-defs, es ist wie das

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

Wie Sie sehen, es ist ziemlich einfach zu bauen, es mit typedefs. Ohne typedefs, es ist nicht schwer, entweder mit der obigen Feststellung Regeln, konsequent angewandt. Wie Sie sehen, ich verpasste den Teil, der Zeiger zeigt, und das, was die Funktion zurückgibt. Das ist das, was erscheint ganz Links in der Erklärung, und ist nicht von Interesse: Es ist am Ende Hinzugefügt, wenn man die Feststellung schon. Lassen Sie uns das tun. Bau es konsequent, zunächst wortreich - zeigt die Struktur mit [ und ]:

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

Wie Sie sehen, kann man beschreiben, eine Art ganz durch Anhängen declarators einer nach dem anderen. Die Konstruktion kann auf zwei Arten erfolgen. Man ist bottom-up, beginnend mit dem sehr richtige (Blätter) und arbeiten den Weg durch bis zu der Kennung. Der andere Weg ist, top-down, beginnend mit der identifier, die den Weg nach unten in die Blätter. Ich zeige beide Möglichkeiten.

Bottom-Up -

Bau beginnt mit der Sache zum Recht: Die Sache zurückgegeben, was ist die Funktion, die char. Halten die declarators deutlich, ich werde Nummer:

D1(char);

Eingefügt die char-parameter direkt auf, denn es ist trivial. Hinzufügen eines pointer auf Feststellung durch den Austausch D1 durch *D2. Beachten Sie, dass wir zu wickeln Klammern um *D2. Das kann man durch einen Blick in die Rangfolge der *-operator und dem Funktions-Aufruf-operator (). Ohne unsere Klammern, der compiler würde es hier Lesen *(D2(char p)). Das würde aber nicht um ein einfaches ersetzen von D1 durch *D2 mehr, natürlich. Klammern sind immer erlaubt, um declarators. So müssen Sie nicht machen nichts falsch, wenn Sie zu viel von Ihnen, eigentlich.

(*D2)(char);

Rückgabetyp ist komplett! Nun, lassen Sie ersetzen D2 von der Funktion Feststellung Funktion, die <parameters> Rückkehr, die D3(<parameters>) was wir jetzt sind.

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

Beachten Sie, dass keine Klammern benötigt werden, da wir wollen D3 eine Funktion-Feststellung und nicht ein Zeiger Nichtigerklärung dieser Zeit. Toll, jetzt müssen Sie nur noch die Parameter für die. Der parameter ist genau das gleiche getan wie wir getan haben, das zurück geben, nur mit char ersetzt durch void. So werde ich es kopieren:

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

Habe ich ersetzt D2 durch ID1, da wir fertig sind mit, dass die parameter (es ist bereits ein Zeiger auf eine Funktion - keine Notwendigkeit für eine weitere Feststellung). ID1 wird der name des Parameters. Nun, ich habe oben schon gesagt, am Ende fügt man die Art, die all jene Feststellung ändern - der eine erscheint ganz Links in jeder Erklärung. Für die Funktionen, das wird der Typ zurückgegeben. Für Hinweise die Spitzen zu geben etc... Es ist interessant, wenn die Schreibweise der Art, erscheint es in umgekehrter Reihenfolge, ganz Recht 🙂 Trotzdem, Sie zu ersetzen-ergibt sich die vollständige Erklärung. Beide Male int natürlich.

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

Ich genannt habe, der Bezeichner der Funktion ID0 in diesem Beispiel.

Top-Down -

Dieser beginnt bei der id ganz Links in der Beschreibung der Art, der Verpackung, der Feststellung, wie wir zu Fuß unseren Weg durch das Recht. Beginnen Sie mit Funktion, die <Parameter> Rückkehr

ID0(<parameters>)

Das nächste, was in der Beschreibung (nach "die Rückkehr") wurde Zeiger auf. Wir übernehmen es:

*ID0(<parameters>)

Dann die nächste Sache war functon unter <Parameter> Rückkehr. Der parameter ist ein einfacher char, so dass wir es sofort wieder, denn es ist wirklich trivial.

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

Hinweis: die Klammern, die wir Hinzugefügt, da wir wollen, dass die * bindet zuerst, und dann die (char). Sonst würde es Lesen Funktion, die <Parameter> Rückkehr-Funktion .... Nein, die Funktionen zurückgeben Funktionen sind auch nicht erlaubt.

Jetzt brauchen wir nur zu setzen <Parameter>. Ich habe eine kurze version des deriveration, da ich denke, dass Sie bereits jetzt auf die Idee, wie es zu tun.

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

Setzen Sie einfach int vor der declarators wie wir es mit bottom-up und wir sind fertig

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

Das schöne

Ist bottom-up oder top-down-besser? Ich bin es gewohnt, von unten nach oben, aber manche Leute können mehr Komfort mit top-down. Es ist eine Frage des Geschmacks, denke ich. Übrigens, wenn Sie sich bewerben, dem Betreiber alle in dieser Erklärung werden Sie am Ende immer ein int:

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

Das ist eine schöne Eigenschaft von Deklarationen in C: Die Erklärung betont, dass, wenn diese Operatoren in einem Ausdruck der Bezeichner, dann bringt es dem Typ ganz Links. So ist es für arrays zu.

Hoffe, Sie mochte dieses kleine tutorial! Jetzt können wir den link zu diesem wenn die Leute Wundern sich über die seltsame Erklärung der syntax von Funktionen. Ich habe versucht, so wenig C-Interna wie möglich. Fühlen Sie sich frei zu Bearbeiten/beheben Dinge.

InformationsquelleAutor

Funktion Zeiger ist in der Regel definiert durch "typedef", und als param & return-Wert,

Obigen Antworten bereits erklärt viel, ich gebe einfach ein komplettes Beispiel:

#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;
}

InformationsquelleAutor

Funktion Zeiger ist eine variable, die enthält die Adresse einer Funktion. Da es eine Zeiger-variable, wenn auch mit etwas eingeschränkten Eigenschaften, die Sie verwenden können, es ist ziemlich viel, wie Sie würde jede andere Zeiger-variable im Daten-Strukturen.

Die einzige Ausnahme, die mir einfällt, ist die Behandlung der Funktionszeiger verweisen auf etwas anderes als ein einzelner Wert. Tut Zeiger-Arithmetik durch Inkrementieren oder Dekrementieren einen Funktionszeiger oder das hinzufügen/subtrahieren eines offset an eine Funktion Zeiger ist nicht wirklich von nutzen als eine Funktion Zeiger verweist nur auf eine einzige Sache, den Eintrittspunkt einer Funktion.

Die Größe einer Funktion, die Zeiger-variable, die die Anzahl der bytes belegt, die durch die variable, kann variieren, abhängig von der zugrunde liegenden Architektur, wie z.B. x32 oder x64 oder was auch immer.

Die Deklaration für eine Funktion pointer-variable braucht, um zu geben Sie die gleiche Art von Informationen als eine Funktion Erklärung, um für den C-compiler zu tun, die Arten von checks, die es normalerweise tut. Wenn Sie nicht geben Sie eine parameter-Liste in der Deklaration/definition der Funktion ein Zeiger, der C-compiler nicht in der Lage zu prüfen, die Verwendung von Parametern. Es gibt Fälle, wenn dieser Mangel an Kontrolle kann nützlich sein, aber denken Sie daran, dass ein Sicherheits-Netz wurde entfernt.

Einige Beispiele:

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.

Den ersten beiden declararations sind etwas ähnlich, dass:

• func ist eine Funktion, die einen int und ein char * und zurück int
• pFunc ist eine Funktion, die Zeiger auf die zugeordnet ist die Adresse einer Funktion, die einen int und ein char * und zurück int

Also von oben konnten wir eine Quell-Zeile, in der die Adresse der Funktion func() zugeordnet ist, um den Funktionszeiger-variable pFunc wie in pFunc = func;.

Beachten Sie die syntax mit einem Funktionszeiger Deklaration/definition in der Klammer sind zu überwinden, die Natürliche Rangfolge der Regeln.

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

Verschiedene Anwendungsbeispiele

Einige Beispiele der Verwendung der Funktion Zeiger:

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

Können Sie variable Länge der Parameterliste in der definition eines funktionszeigers.

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

Oder Sie können nicht geben Sie eine parameter-Liste an alle. Dies kann nützlich sein, aber es entfällt die Möglichkeit der C-compiler Prüfungen an der argument-Liste zur Verfügung gestellt.

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-Stil-Casts

Können Sie die Verwendung von C-Stil-casts mit Funktionszeigern. Beachten Sie jedoch, dass ein C-compiler kann lax über Prüfungen oder geben Warnungen eher als Fehler.

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.

Compare-Funktion Zeiger auf Gleichheit

Können Sie überprüfen, ob eine Funktion Zeiger ist gleich eine bestimmte Funktion Adresse verwenden if Aussage aber ich bin nicht sicher, wie nützlich das wäre. Andere Vergleichsoperatoren scheint noch weniger utility.

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;
}

Ein Array von Funktionszeigern

Und wenn Sie wollen, um ein array von Funktionszeigern jedes der Elemente, aus denen die argument-Liste zu Differenzen, dann können Sie eine Funktion definieren, die Zeiger durch die Liste der Argumente unspezifiziert (nicht void was bedeutet, dass keine Argumente, sondern nur unspezifisch) so etwas wie die folgenden wenn Sie sehen, Warnungen aus der C-compiler. Dies funktioniert auch für eine Funktion Zeiger-parameter einer Funktion:

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-Stil namespace Mit Globalen struct mit Funktionszeigern

Können Sie die static Schlüsselwort, um eine Funktion anzugeben, deren name Datei-Bereich und weisen Sie diese auf eine Globale variable als eine Möglichkeit, etwas ähnliches wie die namespace Funktionalität von C++.

In einer Headerdatei definiert eine struct, werden unsere namespace zusammen mit einer globalen variable, die verwendet wird.

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;

Dann in der C-Quelldatei:

#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};

Dieser würde dann verwendet werden, durch die Angabe der vollständigen Namen der globalen struct-Variablen und member-Namen, um auf die Funktion zuzugreifen. Die const Modifikator verwendet wird, die global auf, so dass es nicht geändert werden können, durch einen Unfall.

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

Anwendungsbereiche von Funktionszeigern

DLL-library-Komponente könnte etwas tun, ähnlich wie die C-Stil namespace Ansatz, in dem eine bestimmte library-Schnittstelle angefordert wird, aus einer factory-Methode in einer Bibliothek-Schnittstelle, die unterstützt die Schaffung eines struct mit Funktionszeigern.. Das library interface lädt die angeforderte DLL-version schafft eine Struktur, die mit den erforderlichen Funktions-Zeiger, und dann wieder die Struktur an den ersuchenden Anrufer für den Einsatz.

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;
}

und dies könnte verwendet werden, wie in:

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

Der gleiche Ansatz kann verwendet werden, definieren Sie eine abstrakte hardware-Ebene für den code, der verwendet ein bestimmtes Modell der zugrunde liegenden hardware. Funktion Zeiger sind gefüllt mit hardware-spezifische Funktionen, indem Sie eine Fabrik, um die hardware-spezifischen Funktionen, die Funktionen angegeben, die in der abstrakten hardware-Modell. Dies kann verwendet werden, um eine abstrakte hardware-layer von der software genutzt, die fordert, eine factory-Funktion, um die spezifische Funktion hardware-Schnittstelle verwendet dann die Funktion Zeiger zur Verfügung gestellt, um Aktionen durchzuführen, die für die zugrunde liegende hardware, ohne zu wissen, Implementierungsdetails zu dem bestimmten Ziel.

Funktionszeiger zu erstellen Delegierten, Handlern und Rückrufe

Können Sie verwenden, function Pointer als eine Möglichkeit zum delegieren Sie einige Aufgaben oder Funktionen. Das klassische Beispiel in C ist der Vergleich delegieren Funktion Zeiger verwendet, mit den Standard-C-library-Funktionen qsort() und bsearch() zu bieten, die Sortierung, die Reihenfolge für die Sortierung einer Liste von Elementen oder das ausführen einer binären Suche über eine sortierte Liste von Elementen. Die Vergleich-Funktion delegieren, gibt die Sortierung Algorithmus in der Art, oder die binäre Suche.

Andere Verwendung ist ähnlich wie die Anwendung eines Algorithmus in einer C++ - Standard Template Library container.

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);

Weiteres Beispiel ist mit dem GUI-Quelltext, in dem Sie einen handler für ein bestimmtes Ereignis registriert wird, indem eine Funktion Zeiger, die tatsächlich aufgerufen wird, wenn das Ereignis Eintritt. Microsoft MFC-framework, mit Ihrer Botschaft maps verwendet etwas ähnliches in der Handhabung von Windows-Nachrichten, die geliefert werden, zu einem Fenster oder thread.

Asynchrone Funktionen, die erfordern, dass eine callback-sind ähnlich wie ein Ereignis-handler. Die Benutzer des asynchronen Funktion ruft die asynchrone Funktion zu starten, eine Aktion, und stellt eine Funktion Zeiger, die die asynchrone Funktion aufrufen, sobald die Aktion abgeschlossen ist. In diesem Fall ist das Ergebnis der asynchronen Funktion der Vollendung seiner Aufgabe.

InformationsquelleAutor

Da Funktionszeiger werden oft eingegeben Rückrufe, möchten Sie vielleicht einen Blick auf typsichere callbacks. Das gleiche gilt für die entry-Punkte, etc. von Funktionen, die nicht callbacks.

C ist ziemlich wankelmütig und versöhnlich zugleich 🙂

InformationsquelleAutor