1. Funktionszeiger

Funktionen werden im Codebereich des Speichers gespeichert, und sie haben ebenfalls Adressen. Wenn wir eineint test(int a)Funktion haben, dann ist ihre Adresse der Funktionsname. Das ist genauso wie bei einem Array, bei dem der Arrayname die Startadresse des Arrays ist.

1.1 Definition von Funktionszeigern

data_types (*func_pointer)( data_types arg1, data_types arg2, ...,data_types argn);

Zum Beispiel:

int (*fp)(int a); // 这里就定义了一个指向函数(这个函数参数仅仅为一个 int 类型,函数返回值是 int 类型)的指针 fp。

Beispiel

int test(int a) { return a; } int main(int argc, const char * argv[]) { int (*fp)(int a); fp = test; cout<<fp(2)<<endl; return 0; }

Hinweis:Die Funktion, auf die ein Funktionszeiger zeigt, muss denselben Rückgabetyp, dieselbe Anzahl an Parametern und dieselben Parametertypen haben.

1.2 Mit typedef kann die Definition von Funktionszeigern vereinfacht werden

Beispiel

int test(int a) { return a; } int main(int argc, const char * argv[]) { typedef int (*fp)(int a); fp f = test; cout<<f(2)<<endl; return 0; }

1.3 Funktionszeiger können auch als Argumente an Funktionen übergeben werden

Beispiel

int test(int a) { return a-1; } int test2(int (*fun)(int),int b) { int c = fun(10)+b; return c; } int main(int argc, const char * argv[]) { typedef int (*fp)(int a); fp f = test; cout<<test2(f, 1)<<endl; // Beim Aufruf von test2 wird die Adresse der Funktion test als Argument an test2 übergeben return 0; }

Wenn Sie den obigen Code ausführen, ist die Ausgabe:

10

1.4 Mit Funktionszeigern können wir ein Array von Funktionszeigern konstruieren, genauer gesagt ein Array von Zeigern auf Funktionen

Beispiel

void t1(){cout<<"test1"<<endl;} void t2(){cout<<"test2"<<endl;} void t3(){cout<<"test3"<<endl;} int main(int argc, const char * argv[]) { typedef void (*fp)(void); fp b[] = {t1,t2,t3}; // b[] ist ein Array von Zeigern auf Funktionen b[0](); // Die Verwendung von Indexoperationen auf dem Array von Zeigern auf Funktionen ermöglicht indirekte Aufrufe von Funktionen return 0; }

2. Funktionszeiger, die auf Memberfunktionen einer Klasse zeigen

Definition:Ein Zeiger auf eine Memberfunktion einer Klasse ist ein Zeigerdatentyp in der Sprache C++, der verwendet wird, um Zugriffsinformationen für eine Memberfunktion einer bestimmten Klasse mit einer gegebenen Parameterliste und einem gegebenen Rückgabetyp zu speichern.

Grundsätzlich gibt es zwei Punkte zu beachten:

  • 1. Beim Zuweisen eines Funktionszeigers müssen Sie verwenden&
  • 2. Verwenden Sie.*(Instanzobjekt) oder->*(Instanzobjektzeiger), um die Funktion aufzurufen, auf die der Klassenmember-Funktionszeiger zeigt.

Schauen wir uns unten zwei Beispiele an:

A) Klassenmember-Funktionszeiger, die auf nicht-statische Memberfunktionen in einer Klasse zeigen

Bei einernichtstatischen Memberfunktionerhält man durch die Adressbildung die tatsächliche Adresse der Funktion im Speicher.

Bei einervirtuellen Funktionist ihre Adresse zur Compile-Zeit unbekannt, daher kann bei einer virtuellen Memberfunktion durch die Adressbildung nur ein Indexwert ermittelt werden.

Beispiel

// Funktionszeiger, der auf eine Klassenmember-Funktion zeigt #include <iostream> #include <cstdio> using namespace std; class A { public: A(int aa = 0):a(aa){} ~A(){} void setA(int aa = 1) { a = aa; } virtual void print() { cout << "A: " << a << endl; } virtual void printa() { cout << "A1: " << a << endl; } private: int a; }; class B:public A { public: B():A(), b(0){} B(int aa, int bb):A(aa), b(bb){} ~B(){} virtual void print() { A::print(); cout << "B: " << b << endl; } virtual void printa() { A::printa(); cout << "B: " << b << endl; } private: int b; }; int main(void) { A a; B b; void (A::*ptr)(int) = &A::setA; A* pa = &a; // Für nicht-virtuelle Funktionen wird ihre reale Adresse im Speicher zurückgegeben printf("A::set(): %p\n", &A::setA); // Für virtuelle Funktionen wird ihre Offset-Position in der virtuellen Funktionstabelle zurückgegeben printf("B::print(): %p\n", &A::print); printf("B::print(): %p\n", &A::printa); a.print(); a.setA(10); a.print(); a.setA(100); a.print(); // Für einen Funktionszeiger, der auf eine Memberfunktion einer Klasse zeigt, muss beim Referenzieren der this-Zeiger eines Klassenobjekts übergeben werden, daher muss er von einer Klasseninstanz aufgerufen werden (pa->*ptr)(1000); a.print(); (a.*ptr)(10000); a.print(); return 0; }

Wenn Sie den obigen Code ausführen, ist die Ausgabe:

A::set(): 0x8048a38
B::print(): 0x1
B::print(): 0x5
A: 0
A: 10
A: 100
A: 1000
A: 10000

B) Zeiger auf Klassenmemberfunktionen, die auf statische Memberfunktionen in einer Klasse zeigen

Beispiel

#include <iostream> using namespace std; class A{ public: // p1 ist ein Funktionszeiger, der auf eine nicht-statische Memberfunktion zeigt void (A::*p1)(void); // p2 ist ein Funktionszeiger, der auf eine statische Memberfunktion zeigt void (*p2)(void); A(){ /*Für **Zeiger auf nicht-statische Memberfunktionen **und **Zeiger auf statische Memberfunktionen **ist die Zuweisungsmethode dieselbe, beide in der Form &ClassName::memberVariable **Der Unterschied ist: **p1 kann nur mit nicht-statischen Memberfunktionen zugewiesen werden **p2 kann nur mit statischen Memberfunktionen zugewiesen werden ** **Wenn Sie beim Zuweisen außerdem direkt &memberVariable verwenden, meldet VS "Compiler Error C2276" **Siehe: http://msdn.microsoft.com/zh-cn/library/850cstw1.aspx*/ p1 =&A::funa; // Beim Zuweisen eines Funktionszeigers muss & verwendet werden p2 =&A::funb; //p1 =&A::funb;//Fehler //p2 =&A::funa;//Fehler // p1=&funa;// Fehler, Compiler Error C2276 // p2=&funb;// Fehler, Compiler Error C2276 } void funa(void){ puts("A"); } static void funb(void){ puts("B"); } }; int main() { A a; // p ist ein Funktionszeiger, der auf eine nicht-statische Memberfunktion in A zeigt void (A::*p)(void); (a.*a.p1)(); // Gibt A aus // Verwende .* (Instanzobjekt) oder ->* (Instanzobjektzeiger), um die Funktion aufzurufen, auf die der Klassen-Memberfunktionszeiger zeigt p = a.p1; (a.*p)();// Gibt A aus A *b = &a; (b->*p)(); // Gibt A aus /*Obwohl a.p2 selbst eine nicht-statische Variable ist, ist a.p2 ein Funktionszeiger, der auf eine statische Funktion zeigt, **daher ist der folgende Satz falsch!*/ // p = a.p2;//Fehler void (*pp)(void); pp = &A::funb; pp(); // Gibt B aus return 0; }

Zusammenfassung

Klassen-Memberfunktionszeiger und gewöhnliche Funktionszeiger sind nicht dasselbe. Erstere müssen.*und ->*Operator verwenden, während Letztere*Operator verwenden können (genannt "Dereferenzierung" oder "Indirektion").

Gewöhnliche Funktionszeiger speichern tatsächlich die Startadresse des Funktionskörpers, daher werden sie auch "Codezeiger" genannt, um sie von den am häufigsten verwendeten Datenzeigern in C/C++ zu unterscheiden.

Klassen-Memberfunktionszeiger sind jedoch nicht nur die Startadresse im Speicher der Klassen-Memberfunktion; sie müssen auch das Problem der Anpassung der Klasseninstanzadresse lösen, das durch C++-Mehrfachvererbung und virtuelle Vererbung verursacht wird. Daher muss beim Aufruf eines Klassen-Memberfunktionszeigers ein Klasseninstanzobjekt übergeben werden.

Ursprüngliche Adresse: https://blog.csdn.net/crayondeng/article/details/16868351