Je sais appeler par des pointeurs dans lesquels nous passons l’adresse de variables. Quelque chose comme ça:
void swap(int *x, int *y) { int temp; temp = *x; /* save the value at address x */ *x = *y; /* put y into x */ *y = temp; /* put x into y */ return; } swap(&a, &b);
Et aussi, appel par référence , dans ces deux méthodes, les modifications apscopes à la fonction sont reflétées dans la variable des arguments réels.
Mais pourquoi les parameters actuels transmis dans ce cas d’appel ne sont pas modifiés:
#include using namespace std; void foo(int* c){ c=c+1; } int main() { int a=5; int *c=&a; cout<<&c<<endl; //0x7ffe1a74f3b0 foo(c); cout<<*c<<endl;//5 cout<<&c<<endl;//0x7ffe1a74f3b0 }
Ici, c passé à foo () est l’adresse de a.So comment cela est appelé par valeur.
Ici, c devrait avoir la valeur des déchets imprimés selon moi.Veuillez expliquer ce qui s’est passé ici.
Et aussi, appel par référence, dans ces deux méthodes, les modifications apscopes à la fonction sont reflétées dans la variable des arguments réels.
Il existe cependant une différence importante: les modifications sont toujours apscopes à tout ce qui est référencé / pointé, jamais à la référence / au pointeur lui-même (la modification d’une référence est impossible en général).
C’est pourquoi l’affectation de c
une nouvelle valeur dans foo
n’a aucun effet sur c
dehors de foo
: le pointeur transmis à une fonction est copié .
Si vous devez modifier le pointeur, vous devez append un autre niveau de déréférencement en passant une référence de pointeur ou un pointeur à un pointeur.
Suite aux commentaires, la variable c
définie dans la fonction main
est une variable différente du paramètre c
de la fonction foo
. Si vous voulez que foo
puisse modifier le c
de main, c’est-à-dire modifier l’adresse que le type de pointeur de c
détient, vous devez alors passer une référence ou un pointeur à c
à la fonction.
Voici un exemple montrant la différence entre passer c
par valeur (en tant int *
) ou par référence (en tant que int **
ou int *&
). Ne soyez pas dupe du fait que int *
est un type de pointeur, cela signifie qu’il peut recevoir un int
par référence ou un int *
par valeur. Et puisque le c
de main est int *
plutôt int
, c
est passé par valeur.
Notez les différences dans la façon dont les fonctions sont appelées (si c
besoin de l’opérateur d’adresse &
dans l’appel de la fonction) et dans le résultat de chaque fonction.
#include using namespace std; void foo_int_ptr(int* c) { c=c+1; } void foo_int_ptr_ptr(int** c) { *c=*c+1; } void foo_int_ptr_ref(int*& c) { c=c+1; } int main() { int a=5; int *c=&a; cout << "&c=" << &c << ", c=" << c << ", *c=" << (c==&a ? std::to_string(*c) : std::string("INVALID PTR")) << endl; foo_int_ptr(c); cout << "&c=" << &c << ", c=" << c << ", *c=" << (c==&a ? std::to_string(*c) : std::string("INVALID PTR")) << endl; foo_int_ptr_ptr(&c); cout << "&c=" << &c << ", c=" << c << ", *c=" << (c==&a ? std::to_string(*c) : std::string("INVALID PTR")) << endl; foo_int_ptr_ref(c); cout << "&c=" << &c << ", c=" << c << ", *c=" << (c==&a ? std::to_string(*c) : std::string("INVALID PTR")) << endl; }
Sortie:
&c=0x7e02d81808b8, c=0x7e02d81808ac, *c=5 &c=0x7e02d81808b8, c=0x7e02d81808ac, *c=5 &c=0x7e02d81808b8, c=0x7e02d81808b0, *c=INVALID PTR &c=0x7e02d81808b8, c=0x7e02d81808b4, *c=INVALID PTR
il y a une erreur dans votre pensée à ce sujet ..
int *c = &a;
cela ne signifie pas que c “contient” l’adresse d’un, cela signifie que c est un pointeur VERS l’adresse d’un. Passer un pointeur sur foo () ne fera rien.