Pointeur de fonction vers la fonction membre en C++

1. Implémenter le pointeur de fonction vers la fonction membre en C++
2. Fixer un pointeur à une fonction membre en C++
3. Appeler un pointeur vers une fonction membre sans utiliser le symbole du pointeur en C++
4. Donner une méthode de la même classe que le pointeur de fonction en C++
5. Pointeur de fonction vers la fonction membre à l’aide de la commande String en C++

Lorsqu’une variable est créée dans des langages de programmation, la machine doit stocker sa valeur dans la mémoire de l’ordinateur. La machine alloue de la mémoire à cette variable, qu’elle soit vide ou non.

L’emplacement est souvent requis à la place des valeurs d’une variable. Pendant ce temps, ces valeurs peuvent être récupérées via des pointeurs.

De plus, les pointeurs en C++ peuvent également être utilisés pour pointer vers un morceau de code, comme une fonction, par rapport au référencement d’une adresse mémoire. Ceux-ci sont appelés des pointeurs de fonction, augmentant l’efficacité du code.

Les exemples de cet article montreront clairement comment les pointeurs de fonction peuvent être utilisés à l’intérieur d’une classe pour faire pointer des pointeurs vers une fonction membre en C++.

Implémenter le pointeur de fonction vers la fonction membre en C++

Cela peut être fait de deux manières.

1. Un pointeur de fonction est créé qui pointe vers une fonction membre.
2. Appel d’une méthode en utilisant uniquement le nom du pointeur de fonction.

Fixer un pointeur à une fonction membre en C++

Les étapes suivantes sont nécessaires pour utiliser une fonction de pointeur.

1. Une fonction paramétrée avec un type de retour - void.
2. Tapez Conversion de la variable de pointeur.
3. Affectation de la variable de pointeur à une méthode.
4. Un appel de méthode qui utilise le pointeur pour appeler la fonction paramétrée à l’intérieur de la fonction principale.

Le package standard stdio est importé pour les fonctions d’entrée/sortie à l’intérieur du programme. Une fonction display est déclarée avec un paramètre var1, de type entier.

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

A l’intérieur de la méthode display, var1 est imprimé.

La variable ptr_method a un type de données void à l’intérieur de la fonction main. Il convient de noter que void peut être utilisé comme type de données en c++, mais il agit comme un espace réservé et ne représente pas véritablement un type de données.

La variable de pointeur déclarée est alors fournie avec un paramètre entier comme :

void (*ptr_method)(int)

La ptr_method a un paramètre entier. Cela passera une valeur à la méthode membre lors de l’appel de ptr_method.

Étant donné que l’utilisation de tout autre type de données entraîne une erreur de conversion incorrecte avec le compilateur, la fonction de pointeur ptr_method a reçu un type de données void.

Le pointeur de fonction est affecté à la fonction déclarée au démarrage du programme en utilisant la syntaxe ci-dessous. Utilisez la syntaxe suivante pour faire pointer le pointeur vers la fonction display.

ptr_method = &display;

Enfin, la fonction de pointeur est appelée avec le paramètre entier fourni comme "65".

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

Production:

The variable holds value = 65

Appeler un pointeur vers une fonction membre sans utiliser le symbole du pointeur en C++

Le programme utilisé dans cet exemple est le même que celui ci-dessus à l’exception de l’appel de fonction. Ici, la variable de pointeur est appelée en utilisant le nom de la variable, à l’exclusion du signe astérisque (*).

Le programme fonctionne comme prévu car lorsqu’un pointeur de fonction est pointé vers une méthode, l’adresse mémoire de la méthode stockée à l’intérieur est accessible en utilisant à la fois le pointeur et la forme variable. Par exemple, lorsque le pointeur de fonction ptr_method est défini, l’affectation de la fonction display est réalisée en utilisant directement le nom de la variable plutôt que d’ajouter un & devant le nom de la variable comme dans l’exemple précédent.

A l’appel de la fonction, le pointeur de fonction ptr_method est appelé directement sans le symbole de pointeur (*) et passé la valeur 54.

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

Production:

The variable holds value = 54

Donner une méthode de la même classe que le pointeur de fonction en C++

Le programme utilisé dans cet exemple est similaire aux deux autres programmes. Mais ici, le pointeur est une méthode, alors que le travail était géré par de simples variables de pointeur dans les deux autres programmes.

Une classe constructeur assgnPtr est créée avec deux membres publics - une méthode char foo et une autre méthode char qui est un pointeur de fonction ptr. Les deux méthodes sont présentées dans la syntaxe ci-dessous, et il ressort clairement de la dernière ligne de la syntaxe qu’elle pointe vers la classe assgnPtr pour le pointeur de fonction.

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

Une fois les méthodes publiques déclarées, la fonction foo() reçoit un retour f. Cela implique que lorsque le pointeur de fonction est appelé, le programme appelle la fonction foo et imprime tout ce qui est renvoyé.

Une variable nommée var1 est déclarée dans la méthode principale. Cette variable fonctionne comme un objet de classe.

C’est parce que les pointeurs de fonction qui sont des fonctions membres ont l’inconvénient d’être inaccessibles lorsqu’ils sont utilisés sans un objet de la même classe. La fonction membre est affectée à la variable de pointeur dans la syntaxe suivante.

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

Le pointeur ptr est utilisé avec la classe d’objet var1, et on lui attribue la méthode foo. En tant que constructeur, la méthode doit être assignée à l’aide du symbole ::, indiquant que la fonction est la méthode membre de la classe assgnPrt.

Enfin, le résultat doit être imprimé.

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

Il peut être troublant pour les lecteurs car il est très compliqué à comprendre. Il faut donc le décomposer en morceaux pour bien le comprendre.

var1.ptr est un pointeur vers la fonction membre de la classe assgnPtr. Mais lorsque *(var1.ptr) est utilisé, il se transforme en une référence de pointeur tandis que l’impression *(var1.ptr) ne peut pas être utilisée directement car ptr n’est pas dans la portée.

Pour cette raison, il doit être lié à l’objet de classe var1 en tant que var1.*(var1.ptr).

Enfin, (var1.*(var1.ptr))() invoque la méthode sans argument. L’instruction print imprime la valeur renvoyée lorsque la méthode est appelée à l’aide du pointeur de fonction.

Code source complet :

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

Production:

f

Pointeur de fonction vers la fonction membre à l’aide de la commande String en C++

Dans cet exemple, le programme utilise des commandes de chaîne pour affecter des pointeurs de fonction. Le concept de base est similaire, sauf que la méthode membre utilise un opérateur relationnel pour vérifier et affecter le pointeur.

Le programme utilise deux fonctions d’import, iostream pour i/o et string pour les commandes de chaîne. Une classe constructeur assgnPtr2 est créée.

Il y a deux membres privés, display et pass_value et un membre public, func_ptr, qui sera le pointeur de fonction.

Le membre privé pass_value a trois paramètres - les variables x et y de type de données chaîne et un prototype de fonction foo. Le prototype de fonction indique que le paramètre foo sera un pointeur vers une fonction.

La méthode display imprimera une instruction lorsque le pointeur est assigné. La méthode func_ptr appelle la méthode pass_value et passe les valeurs de x et y en tant que paramètre, et attache la méthode display en utilisant le symbole & comme argument pour le prototype de la fonction.

Enfin, à l’intérieur de la méthode pass_value, les valeurs de x et y qui ont été passées sont comparées à l’aide de l’opérateur relationnel ==. Une instruction if affecte le pointeur foo à la méthode si les valeurs de x et y correspondent.

A l’intérieur de la fonction main, un objet de classe var est créé. A l’aide de cet objet, la méthode func_ptr est appelée.

Code source complet :

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

Production:

Pointer Assigned