retour
Bonjour, bonjour, tout le monde, je me réveille en hâte, et je vous retrouve au bout d'un mois. Comme nous le savons tous, l'examen final est un jeu de bataille royale ouvert spécialement développé par le ministère de l'Éducation de Chine pour les étudiants. Les étudiants doivent jouer le rôle d'un être humain désespéré et accomplir la tâche de "Révision finale" avec Xiao Saoshu, échappant constamment à la situation d'échec à l'examen... C'est pourquoi l'auteur n'a pas écrit d'article pendant un mois ( excuse ) .
Eh bien, revenons au sujet, ce que je vais expliquer aujourd'hui est le pointeur avancé, et nous continuerons à discuter du sujet avancé des pointeurs (faire semblant d'être sérieux).
Un bref examen (Introduction aux pointeurs)
Nous savons tous que la mémoire d'un ordinateur est divisée en unités de mémoire, chaque unité a une adresse numérique indépendante et l'adresse s'appelle un pointeur en langage C. Jane : numéro = adresse = pointeur .
Le pointeur (adresse) doit être stocké - stocké dans une variable, qui est une variable de pointeur. La taille de la variable de pointeur est divisée en (4/8) deux tailles selon la plate-forme (32/64) bits.
apprendre de nouveaux contenus
pointeur de caractère
Comme son nom l'indique : un pointeur de caractère est un pointeur vers un caractère, donc son type est char*.
L'utilisation générale est la suivante :
#include<stdio.h>
int main()
{
char ch = 'a';
//定义指针变量p，指向ch的类型为字符类型
char* pc = &ch;
*pc = 'b';
return 0;
}Il existe une autre façon de l'utiliser comme suit:
#include<stdio.h>
int main()
{
//这里是将一个字符串放入到pstr指针变量里面了吗？
char* pstr = "hello";
printf("%s\n", pstr);
return 0;
}Le résultat d'impression de ce code est "hello", donc certaines personnes comprendront à tort que la chaîne entière est placée dans le pointeur pstr, mais en fait, l'adresse du premier caractère de hello est placée dans le pointeur pstr .
La signification du code ci-dessus est de stocker l'adresse du premier caractère h d'une chaîne constante dans la variable de pointeur pstr .
Reprenons cette question :
#include<stdio.h>
int main()
{
char str1[] = "hello";
char str2[] = "hello";
char* str3 = "hello";
char* str4 = "hello";
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;
}Quel est le résultat du morceau de code ci-dessus, voyons la sortie :
Analysons pourquoi un tel résultat se produit :
Rappelez-vous d'abord ces concepts clés :
1. En général
2. La chaîne constante ne peut pas être modifiée.
(1) str1 et str2 : deux tableaux indépendants, str1[ ] et str2[ ], sont créés respectivement, donc leurs adresses de stockage en mémoire doivent être différentes, donc l'adresse du premier caractère doit également être différente, donc on juge qu'elles sont différentes.
(2) str3 et str4 : définissez d'abord une variable de pointeur str3 pointant vers le premier caractère de bonjour, puis à cause du deuxième concept ci-dessus, la définition de la deuxième variable de pointeur str4 doit toujours pointer vers le premier caractère de la même chaîne, donc ils pointent vers le même emplacement.
tableau de pointeurs
Définition : un tableau de pointeurs est un tableau qui stocke des pointeurs et le type de chaque élément du tableau est un type de pointeur .
Les tableaux que nous connaissons déjà incluent les tableaux d'entiers et les tableaux de caractères.
int arr[ ]
car arr[ ]
L'un de leurs types est un type entier int, et l'autre est un type caractère char
L'analogie est donc un tableau de pointeurs entiers et un tableau de pointeurs de caractères
int* arr[ ]
car* arr[ ]
Les pointeurs de tableau peuvent être utilisés pour simuler des tableaux à deux dimensions, par exemple :
#include<stdio.h>
int main()
{
int arr1[] = { 1,2 };
int arr2[] = { 3,4 };
//定义一个指针数组，两个元素分别为前面两个数组的首元素地址
int* arr[] = { arr1,arr2 };
int i = 0;
//循环遍历数组
for (i = 0; i < 2; i++)
{
int j = 0;
for (j = 0; j < 2; j++)
{
//*(*(arr + i) + j) -> *(arr[i] + j) -> arr[i][j]
printf("%d ", *(*(arr + i) + j));
}
printf("\n");
}
return 0;
}pointeur de tableau
Définition : Un pointeur capable de pointer vers un tableau.
Format d'écriture de base : type (*nom du pointeur de tableau) [nombre d'éléments]
ex.：int (*p) [10]
Explication : p est d'abord combiné avec *, indiquant que p est une variable de pointeur, puis il pointe vers un tableau d'entiers avec une taille de tableau de 10, donc p est un pointeur, pointant vers un tableau, appelé pointeur de tableau.
Remarque : la priorité de [ ] est supérieure à *, donc () doit être utilisé en premier pour s'assurer que p et * sont combinés en premier.
Comment le pointeur de tableau est-il utilisé ?
Étant donné que le pointeur de tableau pointe vers un tableau, l'adresse du tableau doit être stockée dans le pointeur de tableau.
L'utilisation d'un pointeur de tableau : prenez toujours l'exemple de la traversée d'un tableau à deux dimensions :
#include <stdio.h>
//注意二维数组传参时，数组指针还是可以省略行，不可以省略列
void print_arr(int (*p)[5],int row, int col)
{
int i = 0;
for (i = 0; i < row; i++)
{
int j = 0;
for (j = 0; j < col; j++)
{
printf("%-3d", p[i][j]);
}
printf("\n");
}
}
int main()
{
int arr[3][5] = { 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15 };
//数组名arr，表示首元素的地址
//但是在二维数组当中，首元素就是第一行
//所以这里传递的arr就是第一行的地址，也就是一维数组的地址
//所以我们可以使用一个数组指针来接收一行的地址
print_arr(arr, 3, 5);
return 0;
}Les résultats imprimés sont les suivants :
Après avoir appris le tableau de pointeurs et le pointeur de tableau, examinons la signification du code suivant :
int arr[5];
//定义一个整型数组，数组中共有五个元素
int *parr1[10];
//定义一个指针数组，每个元素的类型为int*，共有十个元素
int (*parr2)[10];
//定义一个数组指针parr2，其指向一个大小为10的整型数组
int (*parr3[10])[5];
//可以将*parr3[10]看作*p所以总的来说它是一个数组指针，
//指向一个大小为5的整型数组，而*parr3[10]又可以看成一个指针数组
//因此可以将它看成一个10行5列，每个元素为int的二维数组C'est tout pour ce numéro, merci aux téléspectateurs pour votre soutien.