Pourquoi le pointeur déclaré dans main () n’est-il pas modifié?

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.