Table des matières
Comprendre les tableaux de pointeurs par analogie
2.1 Forme générale d'un tableau de pointeurs
2.2 Simulation de tableau de pointeurs pour réaliser un tableau à deux dimensions
Comprendre les pointeurs de tableau par analogie
3.1 Forme générale du pointeur de tableau
3.2& Nom de la baie VS Nom de la baie
3.3 Utilisation des pointeurs de tableau
Quatre, paramètres de tableau, paramètres de pointeur
4.1 Passage de paramètres de tableau unidimensionnel
4.2 Passage de paramètres de tableau à deux dimensions
4.3 Passage de paramètre de pointeur de niveau 1
4.4 Passage de paramètre de pointeur de deuxième niveau
Préface : Dans le pointeur initial, nous avons appris le concept de pointeurs. Un pointeur est une variable utilisée pour stocker une adresse. L'adresse identifie de manière unique un morceau d'espace mémoire. En même temps, le pointeur a un type. Le type du pointeur détermine la taille du pas de l'entier + du pointeur et l'autorité de l'opération de déréférencement du pointeur. Ensuite, laissez-moi vous amener à comprendre les différents types de pointeurs.
1. Pointeur de caractère
La forme générale d'un pointeur de caractère :
char* nom de la variable
Utilisation générale des pointeurs de caractères
int main()
{
char ch = 'w';
char* pc = &ch; //pc就是字符指针
ch='a';
*pc = 'a';
return 0;
}La valeur de la variable ch peut être modifiée directement, ou la valeur de la variable ch peut être modifiée via un pointeur.
int main()
{
char arr[]="abcdef";
//创建一个数组，用字符串来初始化这个数组
const char* p="abcdef"； //常量字符串
//本质是将字符串首元素的地址赋给指针变量p
}L'essentiel est d'attribuer l'adresse du premier élément de la chaîne à la variable de pointeur p. Comme il s'agit d'une chaîne constante, elle ne peut pas être modifiée. Ajoutez donc const pour empêcher *p de modifier la chaîne.
Vérifiez en imprimant que l'adresse du premier élément de la chaîne est stockée dans p
int main()
{
const char* p = "abcedf";
printf("%s\n", p);
printf("%c\n", *p);
}
Exemple d'analyse :
int main()
{
char str1[] = "hello bit.";
char str2[] = "hello bit.";
const char* str3 = "hello bit.";
const char* str4 = "hello bit.";
if (str1 == str2)
printf("str1 and str2 are same\n");
else
printf("str1 and str2 are not same\n");
if (str3 == str4)
printf("str3 and str4 are same\n");
else
printf("str3 and str4 are not same\n");
return 0;
}
str1 et str2 sont deux tableaux créés, chacun avec son propre espace indépendant. Bien que les deux tableaux stockent la même chaîne, leurs adresses sont différentes. str1 et str2 sont des noms de tableau, et le nom du tableau représente l'adresse du premier élément, donc str1 ! =str2
2. Tableau de pointeurs
Comprendre les tableaux de pointeurs par analogie
Tableau d'entiers - un tableau qui stocke des nombres entiers
tableau de caractères -- un nombre pour stocker les caractères
tableau de pointeurs - un tableau de pointeurs
2.1 Forme générale d'un tableau de pointeurs
int* arr1[10] ; // tableau de pointeurs d'entiers
char* arr2[10] ; // Tableau de pointeurs de caractères
2.2 Simulation de tableau de pointeurs pour réaliser un tableau à deux dimensions
#include <stdio.h>
int main()
{
int arr1[] = { 1,2,3,4,5 }; //arr1 - 数组名 - 首元素地址 int*
int arr2[] = { 2,3,4,5,6 }; //arr2 - 数组名 - 首元素地址 int*
int arr3[] = { 3,4,5,6,7 }; //arr3 - 数组名 - 首元素地址 int*
int* arr[] = { arr1,arr2,arr3 };
int i = 0;
for (i = 0; i < 3; i++)
{
int j = 0;
for (j = 0; j < 5; j++)
{
printf("%d ", arr[i][j]);
}
printf("\n");
}
return 0;
}
Les trois tableaux créés ne sont pas contigus dans l'espace mémoire, ce ne sont donc pas vraiment des tableaux à deux dimensions.
3. Pointeur de tableau
Comprendre les pointeurs de tableau par analogie
Pointeur entier - Un pointeur vers une variable entière. C'est-à-dire une variable pointeur qui stocke l'adresse d'une variable entière
Pointeur de caractère -- Un pointeur vers une variable de caractère. C'est-à-dire une variable de pointeur qui stocke l'adresse d'une variable de caractère
Pointeur de tableau -- Un pointeur vers une variable de tableau. C'est-à-dire la variable pointeur qui stocke l'adresse de la variable tableau
3.1 Forme générale du pointeur de tableau
entier (*p)[10] ;
Explication : p est d'abord combiné avec *, indiquant que p est une variable pointeur, puis pointe vers un tableau de 10 entiers (le type pointé est int [10]). Donc p est un pointeur pointant vers un tableau, appelé pointeur de tableau.
Remarque : La priorité de [] est supérieure à celle de *, donc () doit être ajouté pour s'assurer que p est combiné avec * en premier.
3.2& Nom de la baie VS Nom de la baie
Le nom du tableau est généralement l'adresse du premier élément, à deux exceptions près
1. sizeof(nom du tableau) Le nom du tableau est placé à l'intérieur de sizeof() seul, où le nom du tableau représente le tableau entier, et le calcul est la taille du tableau entier
2.&Nom du tableau Le nom du tableau ici représente également l'ensemble du tableau, et l'adresse de l'ensemble du tableau est extraite
3.3 Utilisation des pointeurs de tableau
int main()
{
int arr[10] = {1,2,3,4,5,6,7,8,9,0};
int (*p)[10] = &arr; //把数组arr的地址赋值给数组指针变量p
return 0;
}void Print(int(*arr)[5], int row, int col)
{
int i = 0;
for (i = 0; i < row; i++)
{
int j = 0;
for (j = 0; j < col; j++)
{
printf("%d ", arr[i][j]);
printf("%d ", *(*(arr+i)+j));
}
printf("\n");
}
}
int main()
{
int arr[3][5] = { 1,2,3,4,5,2,3,4,5,6,3,4,5,6,7 };
Print(arr, 3, 5);
return 0;
}
Interprétation du code :
printf("%d ", *(*(arr+i)+j));
*&arr==arr adresse du premier élément
*(arr+i)==arr+i est équivalent à la première adresse d'élément de la ligne i, +j saute j éléments
Chaque ligne d'un tableau à deux dimensions peut être comprise comme un élément d'un tableau à deux dimensions, et chaque ligne est un tableau à une dimension.
Le nom du tableau arr indique l'adresse du premier élément. Le premier élément du tableau à deux dimensions est la première ligne du tableau à deux dimensions, donc le arr passé ici est en fait équivalent à l'adresse de la première ligne, qui est l'adresse du tableau unidimensionnel et peut être reçue par le pointeur de tableau.
Remplir:
Paramètre de tableau unidimensionnel passant, la partie du paramètre formel peut être un tableau ou un pointeur
void test1(int arr[5], int sz)
{}
void test2(int* arr, int sz)
{}
int main()
{
int arr[5] = { 0 };
test1(arr, 5);
test2(arr, 5);
return 0;
}Paramètre de tableau à deux dimensions passant, la partie du paramètre formel peut être un tableau ou un pointeur
void test1(int arr[3][5], int r,int c)
{}
void test2(int (*p)[5], int r,int c)
{}
int main()
{
int arr[3][5] = { 0 };
test1(arr,3, 5);
test2(arr,3, 5);
return 0;
}Remarque : Les paramètres formels sont écrits sous la forme d'un tableau pour faciliter la compréhension, et ce sont essentiellement des pointeurs.
Quatre, paramètres de tableau, paramètres de pointeur
4.1 Passage de paramètres de tableau unidimensionnel
void test(int arr[10])//ok?
{}
void test(int *arr)//ok?
{}
int main()
{
int arr[10] = {0};
test(arr);
}
Le premier est correct, le paramètre tableau est reçu par le tableau, mais l'essence du paramètre formel est un pointeur. Le nombre d'éléments peut être omis.
Le second est correct, le nom du tableau passe l'adresse du premier élément, il peut donc être reçu par un pointeur.
void test(int* arr[20])//ok?
{}
void test(int **arr)//ok?
{}
int main()
{
int *arr2[20] = {0};
test(arr2);
}La première est correcte, un tableau de pointeurs peut être reçu avec un tableau de pointeurs.
La seconde est correcte, le type de la variable est un tableau de pointeurs, l'adresse est stockée dans le tableau, le type de chaque élément est int*, le nom du tableau est l'adresse du premier élément, et la valeur réelle Le paramètre est l'adresse du pointeur, utilisez donc le deuxième niveau Le pointeur est reçu.
4.2 Passage de paramètres de tableau à deux dimensions
void test(int arr[3][5])//ok？
{}
void test(int arr[][])//ok？
{}
void test(int arr[][5])//ok？
{}
void test(int *arr)//ok？
{}
void test(int* arr[5])//ok？
{}
void test(int (*arr)[5])//ok？
{}
void test(int **arr)//ok？
{}
int main()
{
int arr[3][5] = {0};
test(arr);
}
Le premier est correct, les paramètres de passage du tableau sont reçus par des nombres.
Remarque : Pour le passage de paramètres de tableau à deux dimensions, la conception du paramètre de fonction ne peut omettre que le premier nombre [].
Parce que pour un tableau à deux dimensions, vous n'avez pas besoin de savoir combien de lignes il y a, mais vous devez savoir combien d'éléments sont dans une ligne.
Le quatrième est faux.Le nom du tableau du tableau à deux dimensions est l'adresse d'une ligne, et le type est int(*)[], qui ne peut pas être reçu par int* arr.
Le sixième est faux, l'adresse de la variable entière ne peut pas être reçue par le pointeur secondaire.
4.3 Passage de paramètre de pointeur de niveau 1
Lorsque la partie paramètre d'une fonction est un pointeur de premier niveau, les paramètres qui peuvent être passés par le paramètre réel de la fonction
void test(int* p)
{}
int main()
{
int n = 10;
test(&n);
int* p = &n;
test(p);
int arr[5] = { 0 };
test(arr);
return 0;
}4.4 Passage de paramètre de pointeur de deuxième niveau
Lorsque la partie paramètre d'une fonction est un pointeur secondaire, les paramètres qui peuvent être passés par le paramètre réel de la fonction
void test(int** p)
{}
int main()
{
int n = 10;
int* p=&n;
test(&p);
int** pp = &p;
test(pp);
int* arr[5] = { 0 };
test(arr);
return 0;
}Le contenu de ce temps est par ici. J'espère que vous pourrez gagner quelque chose après l'avoir lu, et merci aux lecteurs pour votre soutien. Si vous avez des questions sur l'article, vous pouvez laisser un message dans la zone de commentaire, le blogueur doit le réviser attentivement et écrire de meilleurs articles à l'avenir.