Comment changer l'adresse du pointeur en langage C

Si vous souhaitez modifier l'adresse d'un pointeur à l'intérieur d'une fonction , plutôt que de modifier la valeur de la variable pointée par le pointeur, vous pouvez transmettre un pointeur vers le pointeur (c'est-à-dire un pointeur secondaire) vers la fonction. De cette façon, vous pouvez modifier l'adresse du pointeur à l'intérieur de la fonction, changeant ainsi la variable pointée par le pointeur. Voici un exemple:

#include <stdio.h>

// 函数原型，接受一个指针的指针作为参数
void changePointer(int **ptrPtr) {
    int newNumber = 42;
    // 修改指针的地址，使其指向新的变量
    *ptrPtr = &newNumber;
}

int main() {
    int number = 10;
    int *ptr = &number;

    printf("Before function call: %d\n", *ptr);

    // 将指针的地址传递给函数，并在函数内部修改指针的地址
    changePointer(&ptr);

    printf("After function call: %d\n", *ptr); // 输出 42

    return 0;
}

Dans cet exemple, la fonction `changePointer` accepte un pointeur vers un pointeur comme argument. À l'intérieur de la fonction, elle crée une nouvelle variable entière « newNumber », puis attribue l'adresse de la variable au pointeur passé « *ptrPtr ». De cette façon, l'adresse de `ptr` dans la fonction `main` est modifiée en l'adresse de `newNumber`. Par conséquent, `*ptr` pointe désormais vers `newNumber`, et cette valeur est accessible en dehors de la fonction. Veuillez noter que le cycle de vie de « newNumber » se termine à la fin de la fonction « changePointer », les problèmes de cycle de vie doivent donc être traités avec soin dans les applications pratiques.

Vous pouvez exécuter le code suivant et je pense que vous obtiendrez de nouvelles informations.

#include "stdio.h"

struct Stud{     //定义结构体类型
    int no;
    char name[10];
    struct Stud *next;
};

void fun(struct Stud *s) //一个修改结构体地址的函数
{
    s=s->next;
}


int main(){  //主函数
    struct Stud s[2]={
   
   {1,"Mary"},{2,"Smith"}}; //初始化
    s[0].next=&s[1];

    fun(&s[0]);         //进入函数

    for(int i=0;i<2;i++){                  //打印
        printf("%s(%d)",s[i].name,s[i].no);
    }
    printf("\n");
}

En langage C, si vous souhaitez changer la valeur d'une variable via une fonction, vous pouvez transmettre l'adresse (pointeur) de la variable à la fonction, puis modifier la valeur de la variable via le pointeur à l'intérieur de la fonction. De cette façon, vous pouvez voir la modification de la variable en dehors de la fonction. Voici un exemple:

#include <stdio.h>

// Prototype de fonction, accepte un pointeur comme paramètre
void changeValue(int *ptr) {     // Modifier la valeur de la variable via le pointeur     *ptr = 42; }

int main() {     nombre int = 10 ;

    printf("Avant l'appel de la fonction : %d\n", nombre);

    // Passe l'adresse de la variable à la fonction
    changeValue(&number);

    printf("Après l'appel de fonction : %d\n", nombre); // Sortie 42

    renvoie 0 ;
}

Dans l'exemple ci-dessus, la fonction `changeValue` accepte un pointeur entier comme paramètre puis modifie la valeur de la variable via le pointeur. Dans la fonction `main`, nous déclarons une variable entière `number` puis transmettons son adresse à la fonction `changeValue`. À l'intérieur de la fonction, la valeur de `number` est modifiée à 42 via le pointeur `*ptr`. Cette modification est également visible en dehors de la fonction.