Les pointeurs sont l'âme du langage C. Je pense que tout le monde devrait être familier avec les pointeurs de premier niveau, et ils sont souvent utilisés: par exemple, le traitement des chaînes, le "transfert de valeur et de résultat" des paramètres de fonction, etc., pour les pointeurs de deuxième niveau ou les pointeurs multi-niveaux. Pointeurs, je pense que c'est plus facile à comprendre. Par exemple, un pointeur de deuxième niveau est un pointeur vers un pointeur ... un pointeur de niveau n est ...
ｐ * ｐ ** ｐ
－－－ －－－ －－－－
｜ ｜ - ＞ ｜ ｜ - ＞ ｜ ｜
－－－ －－－ ｜ ｜
｜ ｜
－－－－
Mais ce qui n'est peut-être pas facile à comprendre pour tout le monde, c'est où sont utilisés les pointeurs secondaires ou les pointeurs à plusieurs niveaux? Comment l'utiliser? Est-il nécessaire de l'utiliser?
Je vais maintenant parler des pointeurs C les plus fréquemment utilisés:
Nous savons tous que dans le langage C, les paramètres de fonction reçoivent des "valeurs", comme suit:
vide amusant (vide)
{
int tmp = 0;
changer (tmp);
printf ("################ tmp =% d / n");
revenir ;
}
changement nul (int tmp_t)
{
tmp_t = 1;
revenir;
}
Pour le moment, la valeur tmp imprimée dans fun () est toujours 0, car nous transmettons la "valeur". Si vous voulez modifier la valeur tmp dans la fonction change () pour qu'elle prenne effet dans fun (), alors vous devez utiliser Le pointeur est passé comme suit:
vide amusant (vide)
{
int tmp = 0;
changer (& tmp);
printf ("################ tmp =% d / n");
revenir ;
}
void change (int * tmp_t)
{
* tmp_t = 1;
revenir;
}
À ce stade, la valeur tmp imprimée dans fun () est 1, car nous passons l'adresse de tmp à ce moment, donc tmp_t est l'adresse de tmp dans change (), et le fonctionnement de * tmp_t est en fait correct Le fonctionnement de tmp.
Lorsque nous arrivons ici, nous pouvons imaginer que nous pouvons modifier une valeur en passant un pointeur. Lorsque vous avez besoin de modifier un pointeur, nous avons besoin du pointeur du pointeur à ce moment, comme suit:
int amusant (vide)
{
int * buf;
int ret;
ret = mem_init (& buf);
return ret;
}
int mem_init (int ** buf_t)
{
* buf_t = malloc (100);
return 1;
}
D'après ce qui précède, nous pouvons constater que la fonction fun () atteint l'objectif d'allouer de l'espace mémoire à buf en appelant la fonction men_init (). Premièrement, buf est un pointeur que nous avons défini, et & buf est un pointeur vers buf (pointeur de deuxième niveau), nous passons à & buf une fonction men_init (), puis le pointeur de deuxième niveau buf_t = & amp; buf, donc buf_t Est un pointeur vers buf, alors l'opération de * buf_t est en fait l'opération de buf, donc fun () peut allouer de la mémoire via men_init ().
(De plus: pour l'int ** buf_t défini, le pointeur de deuxième niveau buf_t = & buf, le pointeur est buf (toujours un pointeur), le pointeur de premier niveau * buf_t = buf, le pointeur est * buf,
值 ** buf_t = * buf)
La même chose est vraie pour l'utilisation de pointeurs de niveau n
C'est ce que je comprends. S'il y a quelque chose qui ne va pas, j'espère que vous pourrez me donner plus de conseils.