Comment passer des pointeurs vers les fonctions en C ++

Une des utilisations de variables de pointeur en C ++ est en passant des arguments aux fonctions. Pour comprendre pourquoi cela est important, vous avez besoin de comprendre comment les arguments sont passés à une fonction.

Passage par valeur en C ++

Par défaut, les arguments sont passés aux fonctions par valeur. Ceci a pour résultat quelque peu surprenant que de modifier la valeur d'une variable dans une fonction normalement ne change pas de valeur dans la fonction appelante. Considérons le segment de code d'exemple suivant:

fn (int Narg) {Narg = 10 - // valeur de Narg à ce stade est de 10} parent void (void) {int n1 = 0-fn (n1) - // valeur de n1 à ce point est toujours 0}

Ici, le parent() fonction initialise la variable entière n1 à 0. La valeur de n1 est ensuite transmise à fn (). En entrant dans la fonction, Narg est égale à 0, la valeur passée. fn () modifie la valeur de Narg à 10 avant de retourner à parent(). À son retour au parent(), la valeur de n1 est toujours 0.

La raison de ce comportement est que C ++ ne passe pas une variable à une fonction. Au lieu de cela, C ++ transmet la valeur contenue dans la variable au moment de l'appel. Autrement dit, l'expression est évaluée, même si elle est juste un nom de variable, et le résultat est passé.

Dans l'exemple, la valeur de n1, qui est 0, a été passé à fn (). Qu'est-ce que la fonction fait avec cette valeur n'a aucun effet sur n1.

Passant valeurs de pointeur en C ++

Comme tout autre type intrinsèque, un pointeur peut être passé comme argument à une fonction:

fn (int * pnArg) {*} pnArg = 10- mère void (void) {int n = 0-fn (n) - // cela passe l'adresse de i // maintenant, la valeur de n est 10}

Dans ce cas, l'adresse de n est transmise à la fonction fn () plutôt que la valeur de n. L'importance de cette différence est évidente si l'on considère l'affectation au sein de fn ().

Supposer n est situé à l'adresse 0x100. Plutôt que de la valeur 10, l'appel fn (n) passe la valeur 0x100. À l'intérieur de fn (), la tâche *pnArg = 10 stocke la valeur 10 dans le int la variable située à l'emplacement 0x100, écrasant ainsi la valeur 0. De retour à parent(), la valeur de n est 10 parce n est juste un autre nom pour le 0x100.

Passage par référence en C ++

C ++ fournit un raccourci pour passer des arguments par adresse - un raccourci qui vous permet d'éviter d'avoir à disputer avec des pointeurs. La déclaration suivante crée une variable n1 et une seconde référence à la même n1 mais avec un nouveau nom, nRef:

int n1 - // déclarer un int variableint nRef = n1 - // déclarer une deuxième référence à n1nRef = 1- // accéder aujourd'hui la référence // a le même effet que n1 accès - // n1 est maintenant égal à 1

Une variable de référence comme nRef doit être initialisé quand il est déclaré parce que chaque moment ultérieur que son nom est utilisé, C ++ suppose que vous voulez dire que la variable nRef fait référence à.

Les variables de référence trouvent leur application principale dans les appels de fonction:

fn (int marg) // déclarer argument de référence = {marg 10 - // modifier la valeur de la variable ...} //...that marg réfère parent tovoid (void) {int n1 = 0-fn (n1) - // passer une référence à // n1 ici la valeur de n1 est 10}

C'est appelé passage par référence. La déclaration int marg déclare marg d'être une référence à un argument entier. La fn () fonction stocke la valeur 10 dans la int emplacement référencé par marg.

Passage par référence est le même que transmettre l'adresse d'une variable. La syntaxe de référence met le fardeau sur C ++ pour appliquer la “ adresse du ” opérateur de la référence au lieu d'exiger le programmeur de le faire.

Vous ne pouvez pas surcharger une passe de la fonction de valeur avec son passe par équivalent de référence. Ainsi, vous ne pouviez pas définir les deux fonctions fn (int) et fn (int) dans le même programme. C ++ ne saurait pas lequel appeler.