Étape 4: Utilisation des pointeurs
PASSAGE DES ARGUMENTS D’UNE FONCTIONIl existe deux façons de passer des arguments à une fonction : soit par valeur ou par référence.
PASSAGE DES ARGUMENTS PAR VALEUR
Normalement, les arguments sont passés aux fonctions par valeur, ce qui signifie que c’est la valeur de la variable qui est passée à la fonction et pas la variable elle-même.
Les implications de cette apparu claires dans l’extrait suivant du code :
Sub fn (int nArg1, int nArg2)
{
modifier les valeurs des arguments
nArg1 = 10 ;
nArg2 = 20 ;
}
int main (int nNumberofArgs, char * pszArgs [])
{
initiaize deux variables et afficher leurs valeurs
int nValue1 = 1 ;
int nValue2 = 2 ;
maintenant, essayez et modifiez-les en appelant une fonction
FN (nValue1, nValue2) ;
Quelle est la valeur de nValue1 et nValue2 maintenant ?
cout de cout
System ("PAUSE")
return 0 ;
}
Ce programme déclare deux variables, nValue1 et nValue2, les initialise à une valeur connue et passe ensuite leurs valeurs à une fonction (fn). Cette fonction modifie la valeur de ses arguments et retourne simplement.
Question : Quelle est la valeur de nValue1 et de nValue2 en main () après que le contrôle est retourné de fn () ?
Réponse : La valeur de nValue1 et nValue2 demeure inchangée à 1 et 2, respectivement.
Pour comprendre pourquoi, examiner soigneusement comment C++ gère la mémoire dans l’appel à fn (). C++ stocke les variables locales (comme nValue1 et nValue2) dans une zone spéciale de mémoire appelée la pile. Dès l’entrée en fonction, les figures de C++ comment beaucoup la fonction de mémoire de pile, il faudra et puis réserve ce montant. Disons, pour du raisonnement, que, dans cet exemple, la mémoire de pile taillée pour main () commence à l’emplacement 0 x 1000 et s’étend jusqu'à 0x101F. Dans ce cas, nValue1 est peut-être à l’emplacement 0 x 1000, et le nValue2 pourrait être à l’emplacement 0x1004.
(REMARQUE : SI VOUS UTILISEZ CODE::BLOCKS, UN INT OCCUPE 4 OCTETS.)
Dans le cadre de l’appel à (fn), C++, tout d’abord stocke les valeurs de chaque argument dans la pile à partir de l’argument de l’extrême droite et son chemin vers la gauche.
La dernière chose que C++ stocke dans le cadre de l’appel est l’adresse de retour afin que la fonction sait où une fois que c’est terminé.
Pour des raisons qui doivent faire davantage avec le fonctionnement interne du processeur, la pile « pousse vers le bas », ce qui signifie que la mémoire utilisée par fn () aura adresses plus petit que 0 x 1000.
N’oubliez pas qu’il s’agit d’une possible mise en page de mémoire. Je ne sais pas (ou soins) que l’un d'entre eux sont en fait les adresses réelles utilisées par C++ dans ceci ou n’importe quel autre appel de fonction.
La fonction fn (int, int) contient deux instructions :
nArg1 = 10 ;
nArg2 = 20 ;
Le point principal de dire c’est de démontrer le fait que la modification des valeurs de nArg1 et nArg2 n’a aucun effet sur les variables d’originales retour à nValue1 et nValue2.
PASSAGE DES ARGUMENTS PAR RÉFÉRENCE
Je voulais donc que se passe-t-il si les modifications apportées par la fn () permanente ? Je pourrais le faire en passant pas la valeur des variables mais leur adresse. Cela est démontré par l’extrait suivant du code :
Sub fn (int * pnArg1, int * pnArg2)
{
modifier la valeur des arguments
* pnArg1 = 10 ;
* pnArg2 = 20 ;
}
int main (int nNumberofArgs, char * pszArgs [])
{
initialiser les deux variables et afficher leurs valeurs
int nValue1 = 1 ;
int nValue2 = 2 ;
FN (& nValue1, & nValue2) ;
System ("PAUSE")
return 0 ;
}
Notez tout d’abord que les arguments de fn () sont maintenant déclarées non entiers, mais des pointeurs vers des entiers. L’appel à la fn (int *, int *) ne passe pas la valeur des adresses variables nValue1 et nValue2 mais theie.
En utilisant les pointeurs, les modifications apportées aux deux variables deviennent permanentes. Sans utiliser les pointeurs, les modifications sont uniquement apportées aux valeurs copiées sur (fn).
