Funktionszeiger auf Member-Funktion in C++

1. Implementieren Sie einen Funktionszeiger auf eine Member-Funktion in C++
2. Anfügen eines Zeigers an eine Member-Funktion in C++
3. Aufruf eines Zeigers auf eine Mitgliedsfunktion ohne Verwendung des Zeigersymbols in C++
4. Übergabe einer Methode aus der gleichen Klasse als Funktionszeiger in C++
5. Funktionszeiger auf Member-Funktion mit String-Befehl in C++

Wenn eine Variable in Programmiersprachen erstellt wird, muss die Maschine ihren Wert im Computerspeicher speichern. Die Maschine weist dieser Variablen etwas Speicher zu, ob leer oder nicht.

Der Speicherort wird oft anstelle der Werte einer Variablen benötigt. Während dieser Zeit können diese Werte durch Zeiger abgerufen werden.

Darüber hinaus können Zeiger in C++ auch verwendet werden, um auf ein Stück Code zu zeigen, z. B. eine Funktion, im Vergleich zum Verweis auf eine Speicheradresse. Diese werden als Funktionszeiger bezeichnet und erhöhen die Effizienz des Codes.

Die Beispiele dieses Artikels zeigen deutlich, wie Funktionszeiger innerhalb einer Klasse verwendet werden können, um Zeiger auf eine Mitgliedsfunktion in C++ zeigen zu lassen.

Implementieren Sie einen Funktionszeiger auf eine Member-Funktion in C++

Es gibt zwei Möglichkeiten, wie dies geschehen kann.

1. Es wird ein Funktionszeiger erstellt, der auf eine Member-Funktion zeigt.
2. Aufruf einer Methode nur mit dem Namen des Funktionszeigers.

Anfügen eines Zeigers an eine Member-Funktion in C++

Die folgenden Schritte sind erforderlich, um eine Zeigerfunktion zu verwenden.

1. Eine parametrisierte Funktion mit einem Rückgabetyp – void.
2. Geben Sie Casting the pointer variable ein.
3. Zuordnung der Pointer-Variablen zu einer Methode.
4. Ein Methodenaufruf, der den Zeiger verwendet, um die parametrisierte Funktion innerhalb der Hauptfunktion aufzurufen.

Das Standardpaket stdio wird für Ein-/Ausgabefunktionen innerhalb des Programms importiert. Eine Funktion display wird mit einem Parameter var1 mit einem Integer-Datentyp deklariert.

void display(int var1) { printf("The variable holds value = %d\n", var1); }

Innerhalb der Methode display wird var1 ausgegeben.

Die Variable ptr_method hat innerhalb der main-Funktion einen void-Datentyp. Es muss beachtet werden, dass void als Datentyp in C++ verwendet werden kann, aber als Platzhalter fungiert und keinen echten Datentyp darstellt.

Die deklarierte Zeigervariable wird dann mit einem ganzzahligen Parameter wie folgt versehen:

void (*ptr_method)(int)

Die ptr_method hat einen ganzzahligen Parameter. Dadurch wird beim Aufruf von ptr_method ein Wert an die Member-Methode übergeben.

Da die Verwendung eines anderen Datentyps zu einem falschen Konvertierungsfehler beim Compiler führt, wurde der Zeigerfunktion ptr_method ein ungültiger Datentyp zugewiesen.

Der Funktionszeiger wird mit der folgenden Syntax der beim Programmstart deklarierten Funktion zugewiesen. Verwenden Sie die folgende Syntax, um den Zeiger auf die Funktion display zu zeigen.

ptr_method = &display;

Schließlich wird die Pointer-Funktion mit dem als "65" bereitgestellten Integer-Parameter aufgerufen.

Code:

#include <stdio.h>

// This method has a parameter int and a return type which is void

void display(int var1) { printf("The variable holds value = %d\n", var1); }

int main() {
  void (*ptr_method)(int);
  ptr_method = &display;

  (*ptr_method)(65);

  return 0;
}

Ausgabe:

The variable holds value = 65

Aufruf eines Zeigers auf eine Mitgliedsfunktion ohne Verwendung des Zeigersymbols in C++

Das in diesem Beispiel verwendete Programm ist mit Ausnahme des Funktionsaufrufs dasselbe wie das obige. Hier wird die Zeigervariable mit dem Namen der Variablen ohne das Sternchenzeichen (*) aufgerufen.

Das Programm funktioniert wie beabsichtigt, denn wenn ein Funktionszeiger auf eine Methode zeigt, kann auf die Speicheradresse der darin gespeicherten Methode zugegriffen werden, indem sowohl der Zeiger als auch die Variablenform verwendet werden. Wenn beispielsweise der Funktionszeiger ptr_method definiert ist, erfolgt die Zuweisung der Funktion display durch direkte Verwendung des Variablennamens, anstatt wie im vorherigen Beispiel ein & vor den Variablennamen zu setzen.

Beim Funktionsaufruf wird der Funktionszeiger ptr_method direkt ohne das Zeigersymbol (*) aufgerufen und der Wert 54 übergeben.

void (*ptr_method)(int);
ptr_method = display;

ptr_method(54);

Code:

#include <stdio.h>

void display(int var1) { printf("The variable holds value = %d\n", var1); }

int main() {
  void (*ptr_method)(int);
  ptr_method = display;

  ptr_method(54);

  return 0;
}

Ausgabe:

The variable holds value = 54

Übergabe einer Methode aus der gleichen Klasse als Funktionszeiger in C++

Das in diesem Beispiel verwendete Programm ist den anderen beiden Programmen ähnlich. Aber hier ist der Zeiger eine Methode, während die Arbeit in den anderen beiden Programmen von einfachen Zeigervariablen erledigt wurde.

Eine Konstruktorklasse assgnPtr wird mit zwei öffentlichen Mitgliedern erstellt – einer char-Methode foo und einer anderen char-Methode, die ein Funktionszeiger ptr ist. Die beiden Methoden sind in der folgenden Syntax dargestellt, und aus der letzten Zeile der Syntax geht hervor, dass sie auf die Klasse assgnPtr für den Funktionszeiger zeigt.

public:
char foo();
char (assgnPtr::*ptr)();

Nachdem die öffentlichen Methoden deklariert sind, wird der Funktion foo() eine Rückgabe f bereitgestellt. Das bedeutet, dass das Programm beim Aufruf des Funktionszeigers die Funktion foo aufruft und ausgibt, was auch immer zurückgegeben wird.

Innerhalb der Hauptmethode wird eine Variable namens var1 deklariert. Diese Variable fungiert als Klassenobjekt.

Dies liegt daran, dass Funktionszeiger, die Mitgliedsfunktionen sind, den Nachteil haben, dass sie nicht zugänglich sind, wenn sie ohne ein Objekt derselben Klasse verwendet werden. Die Member-Funktion wird der Zeigervariablen in der folgenden Syntax zugewiesen.

int main() {
  assgnPtr var1;
  var1.ptr = &assgnPtr::foo;

Der Zeiger ptr wird zusammen mit der Objektklasse var1 verwendet und ihm wird die Methode foo zugewiesen. Als Konstruktor muss die Methode mit dem Symbol :: zugewiesen werden, was anzeigt, dass die Funktion die Member-Methode der Klasse assgnPrt ist.

Zuletzt muss das Ergebnis ausgedruckt werden.

printf("%c\n", (var1.*(var1.ptr))());

Es kann für die Leser beunruhigend sein, da es sehr kompliziert zu verstehen ist. Es muss also in Bits zerlegt werden, um es klar zu verstehen.

var1.ptr ist ein Zeiger auf die Mitgliedsfunktion der Klasse assgnPtr. Aber wenn *(var1.ptr) verwendet wird, wird es zu einer Zeigerreferenz, während das Drucken von *(var1.ptr) nicht direkt verwendet werden kann, da ptr nicht im Bereich ist.

Aus diesem Grund muss es mit dem Klassenobjekt var1 als var1.*(var1.ptr) verbunden werden.

Schließlich ruft (var1.*(var1.ptr))() die Methode ohne Argumente auf. Die print-Anweisung druckt den zurückgegebenen Wert, wenn die Methode unter Verwendung des Funktionszeigers aufgerufen wird.

Vollständiger Quellcode:

#include <iostream>

class assgnPtr {
 public:
  char foo();
  char (assgnPtr::*ptr)();
};

char assgnPtr::foo() { return 'f'; }

int main() {
  assgnPtr var1;
  var1.ptr = &assgnPtr::foo;
  printf("%c\n", (var1.*(var1.ptr))());
}

Ausgabe:

f

Funktionszeiger auf Member-Funktion mit String-Befehl in C++

In diesem Beispiel verwendet das Programm Zeichenfolgenbefehle, um Funktionszeiger zuzuweisen. Das Kernkonzept ist ähnlich, außer dass die Member-Methode einen Vergleichsoperator verwendet, um den Zeiger zu prüfen und zuzuweisen.

Das Programm verwendet zwei Importfunktionen, iostream für i/o und string für String-Befehle. Eine Konstruktorklasse assgnPtr2 wird erstellt.

Es gibt zwei private Mitglieder, display und pass_value, und ein öffentliches Mitglied, func_ptr, das der Funktionszeiger sein wird.

Das private Member pass_value hat drei Parameter – die Variablen x und y vom Datentyp string und einen Funktionsprototypen foo. Der Funktionsprototyp besagt, dass der Parameter foo ein Zeiger auf eine Funktion sein wird.

Die Methode display gibt eine Anweisung aus, wenn der Zeiger zugewiesen wird. Die Methode func_ptr ruft die Methode pass_value auf und übergibt die Werte von x & y als Parameter und fügt die Methode display mit dem Symbol & als Argument für den Funktionsprototypen an.

Schließlich werden in der Methode pass_value die übergebenen Werte von x und y mit dem Vergleichsoperator == verglichen. Eine if-Anweisung weist der Methode den Zeiger foo zu, wenn beide Werte von x und y übereinstimmen.

Innerhalb der Hauptfunktion wird ein Klassenobjekt var erstellt. Mit diesem Objekt wird die Methode func_ptr aufgerufen.

Vollständiger Quellcode:

#include <iostream>
#include <string>

class assgnPtr2 {
 public:
  void func_ptr();

 private:
  void display();
  void pass_value(std::string x, std::string y, void (assgnPtr2::*foo)());
};

void assgnPtr2::display() { std::cout << "Pointer Assigned\n"; }

void assgnPtr2::func_ptr() { pass_value("h", "h", &assgnPtr2::display); }

void assgnPtr2::pass_value(std::string x, std::string y,
                           void (assgnPtr2::*foo)()) {
  if (x == y) {
    (this->*foo)();
  }
}

int main() {
  assgnPtr2 var;
  var.func_ptr();
  return 0;
}

Ausgabe:

Pointer Assigned