C – pointeurs lorsque de nouvelles fonctions sont appelées

Dis que j’ai quelque chose comme:

function2(int *hello) { //something } function1(int *hello) { function2(&hello); } void main() { int hello = 0; function1(&hello); } 

Comment puis-je faire en sorte que function2 puisse changer la valeur d’origine déclarée dans main ?

Changer ce code:

 function1(int *hello) { function2(&hello); } 

à:

 function1(int *hello) { function2(hello); // <-- no "&" in this call! } 

Ensuite, vous pouvez faire ceci:

 function2(int *hello) { *hello = 123; // <-- dereference pointer hello } 

Vous faites une erreur dans la function1 où vous passez l’adresse du pointeur à votre int hello dans la fonction principale. vous passez le pointeur de travers à la function2 et le déréférencé ici.

 function2(int *hello) { *hello = 123 ; } function1(int *hello) { function2(hello); //pass the pointer on to function2 } int main( void ) { int hello = 0; function1(&hello); return 0 ; } 

Vous déclarez également de manière incorrecte votre fonction principale. Il doit être déclaré comme int main () avec une instruction return.

En tant que réponse de MVP, it is correct answer but i am here just explaining something, which will help you to understand, why your code is not working.


Permettez-moi d’abord d’expliquer à l’opérateur que vous avez utilisé
1] Opérateur d’esperluette (&)
This operator helps you to get reference/address of variable
Dès que nous déclarons une variable, la quantité de mémoire nécessaire lui est affectée à un emplacement spécifique dans la mémoire. En général, nous ne décidons pas activement l’emplacement exact de la variable dans le système d’exploitation au moment de l’exécution, mais un certain temps est nécessaire. connaître l’adresse de notre variable comme ici You want to know the address of variable to assign it's address to pointer L’adresse qui localise une variable avec mémoire est ce que nous appelons une reference à cette variable, que nous pouvons obtenir à l’aide de la variable Référence.

Opérateur de déréférence (*)
Comme nous soaps que le pointeur est la variable qui stockera cette adresse d’une autre variable, il vous permet d’accéder directement à la valeur stockée dans la variable qu’il pointe. To do this we simply have to precede the pointer's identifier with an asterisk (*), which acts as deference operator and that can be literally translated to value pointed by


Revenons maintenant à votre code

 function2(int *hello) { // Here you create function that accept address of variable (You will get address of hello pointer 101 NOT 100 of variable assign in your MAIN) //something } function1(int *hello) {// Here you create function that accept address of variable (Here it will get address of hello which is 100) function2(&hello); // Here you again pass address of your pointer hello (Which may be 101) [BAD] } main { int hello = 0; // Let say it's address is 100 function1(&hello); // Here you pass address of your variable(which is 100) [GOOD] } 

La solution est comme suggéré

  function2(int *hello) { //Change your value here *hello = 123; } function1(int *hello) { function2(hello); // It will pass 100 (address of your variable hello assign in MAIN } main { int hello = 0; function1(&hello); } 

L’opérateur “&” signifiant “adresse de”, votre fonction 1 tente donc d’appeler la fonction2 avec l’adresse “hello” plutôt que l’adresse que hello contient.

Répondant à une question différente, j’ai dit ceci :

Les pointeurs sont des variables qui stockent un nombre comme un autre, mais comme vous dites au compilateur qu’il s’agit d’un pointeur, le compilateur vous permet d’utiliser cette valeur comme adresse des éléments en mémoire et le langage fournit le “déréférencement” comme moyen de “la valeur à l’adresse décrite par cette variable”.

Imaginez que vous alliez à l’aéroport pour prendre un vol. Vous prenez un post-it et écrivez votre numéro de vol, et vous prenez un deuxième post-it avec vous pour votre porte.

Le premier post est un pointeur “flight *” et le second poste est un “gate *” mais pour l’instant, le pointeur gate * est vide.

Lorsque vous arrivez à l’aéroport, vous regardez votre vol sur le tableau et notez le numéro de la porte. “3A”. Maintenant votre porte * post-it est valide.

Mais le post-it lui-même n’est PAS votre porte d’entrée, il l’indique simplement: vous devez toujours “déréférencer” le post-it pour accéder à votre vol – c’est-à-dire traversez l’aéroport pour accéder à la porte 3A 🙂

Lorsque vous avez appelé function1 vous avez pris l’adresse de la variable dans main. Tout ce que vous avez à faire est de le transférer à function2. Ce que votre code essayait de faire était de noter le post-it et non le numéro de la porte, plutôt que de regarder le post-it.

Solution

 #include  void function1(int*); // so the comstackr knows what the function looks like. void function2(int*); int main() { int varInMain = 0; // lets call it something distinct printf("varInMain starts with %d, it's location in memory is %p.\n", varInMain, &varInMain); function1(&varInMain); printf("varInMain is %d after calling function1.\n", varInMain); return 0; } void function1(int* func1ptr) { printf("function1: func1ptr points to memory location %p, which contains %d.\n", func1ptr, *func1ptr); *func1ptr = 1010; function2(func1ptr); } void function2(int* func2ptr) { printf("function2: func2ptr points to memory location %p, which contains %d.\n", func2ptr, *func2ptr); *func2ptr = 123; } 

Vous pouvez voir une démonstration en direct de ce code sur ideone.com ici .

La sortie ressemble à ceci:

 varInMain starts with 0, it's location in memory is 0xbfef2fdc. function1: func1ptr points to memory location 0xbfef2fdc, which contains 0. function2: func2ptr points to memory location 0xbfef2fdc, which contains 1010. varInMain is 123 after calling function1.