Annuaire d'articles
Préface
1. Tableau de pointeurs de fonction
Un tableau est un espace de stockage qui stocke des données du même type.
Si l'adresse d'une fonction est stockée dans un tableau, alors ce tableau est appelé tableau de pointeurs de fonction.
提示：以下是代码样例，下面案例可供参考
int Add(int x, int y) //加
{
return x + y;
}
int Sub(int x, int y) // 减
{
return x - y;
}
int Mul(int x, int y)//乘
{
return x * y;
}
int Div(int x, int y)//除
{
return x / y;
}
//计算器
void menu()
{
printf("************************\n");
printf("*****1. Add 2. Sub *****\n");
printf("*****3. Mul 4. Div *****\n");
printf("***** 0. exit ********\n");
printf("************************\n");
}
int main()
{
int x = 0;
int y = 0;
int ret = 0;
int input = 0;
//定义一个函数指针数组
int (*pfArr[5])(int, int) = {
NULL,Add,Sub,Mul,Div };
// 0 1 2 3 4
do
{
menu();
printf("请选择:>\n");
scanf("%d", &input);
if (input >= 1 && input <= 4)
{
printf("请输入两个操作数:");
scanf("%d %d", &x, &y);
ret = pfArr[input](x, y);
printf("ret = %d\n", ret);
}
else if (input = 0)
{
printf("退出计算器\n");
}
else
{
printf("选择错误，重新选择\n");
}
} while (input);
return 0;
}
2. Pointeur vers un tableau de pointeurs de fonction
3. Fonction de rappel
Une fonction de rappel est une fonction appelée via un pointeur de fonction. Si vous passez le pointeur de fonction (adresse) en paramètre à une autre fonction, et lorsque ce pointeur est utilisé pour appeler la fonction vers laquelle il pointe, on dit que c'est une fonction de rappel.
La fonction de rappel n'est pas appelée directement par l'implémenteur de la fonction, mais est appelée par une autre partie lorsqu'un événement ou une condition spécifique se produit pour répondre à l'événement ou à la condition.
4. fonction qsort
qsort est une fonction de bibliothèque standard utilisée pour trier rapidement les éléments d'un tableau. Il détermine l'ordre de deux éléments en comparant leurs tailles. Voici la définition de la fonction qsort :
void qsort(void *base, size_t count, size_t size, int (*compare)(const void *, const void *));
Description du paramètre :
base: Pointeur vers le premier élément du tableau à trier.count: Le nombre d'éléments à trier.size: Le nombre d'octets par élément.compare: Une fonction de comparaison utilisée pour comparer la taille de deux éléments. Cette fonction renvoie une valeur entière indiquant la relation d'ordre entre deux éléments. Si un nombre négatif est renvoyé, cela signifie que le premier élément doit être trié avant le deuxième élément ; si un nombre positif est renvoyé, cela signifie que le premier élément doit être trié après le deuxième élément ; si 0 est renvoyé, cela signifie que deux éléments égaux.
Lorsque vous utilisez la fonction qsort, vous devez personnaliser une fonction de comparaison pour comparer les éléments en fonction des besoins réels. Voici un exemple simple :
#include <stdio.h>
#include <stdlib.h>
int compare(const void *a, const void *b) {
return (*(int*)a - *(int*)b);
}
int main() {
int arr[] = {
3, 1, 4, 2, 5};
int n = sizeof(arr) / sizeof(int);
qsort(arr, n, sizeof(int), compare);
for (int i = 0; i < n; i++) {
printf("%d ", arr[i]);
}
printf("\n");
return 0;
}
Le résultat de sortie est :1 2 3 4 5 , indiquant que le tableau a été trié du plus petit au plus grand. qsort est une fonction de bibliothèque standard utilisée pour trier rapidement les éléments d'un tableau. Il détermine l'ordre de deux éléments en comparant leurs tailles. Voici la définition de la fonction qsort :
void qsort(void *base, size_t count, size_t size, int (*compare)(const void *, const void *));
Description du paramètre :
base: Pointeur vers le premier élément du tableau à trier.count: Le nombre d'éléments à trier.size: Le nombre d'octets par élément.compare: Une fonction de comparaison utilisée pour comparer la taille de deux éléments. Cette fonction renvoie une valeur entière indiquant la relation d'ordre entre deux éléments. Si un nombre négatif est renvoyé, cela signifie que le premier élément doit être trié avant le deuxième élément ; si un nombre positif est renvoyé, cela signifie que le premier élément doit être trié après le deuxième élément ; si 0 est renvoyé, cela signifie que deux éléments égaux.
Lorsque vous utilisez la fonction qsort, vous devez personnaliser une fonction de comparaison pour comparer les éléments en fonction des besoins réels. Voici un exemple simple :
#include <stdio.h>
#include <stdlib.h>
int compare(const void *a, const void *b) {
return (*(int*)a - *(int*)b);
}
int main() {
int arr[] = {
3, 1, 4, 2, 5};
int n = sizeof(arr) / sizeof(int);
qsort(arr, n, sizeof(int), compare);
for (int i = 0; i < n; i++) {
printf("%d ", arr[i]);
}
printf("\n");
return 0;
}
Le résultat de sortie est :1 2 3 4 5 , indiquant que le tableau a été trié du plus petit au plus grand. qsort est une fonction de bibliothèque standard utilisée pour trier rapidement les éléments d'un tableau. Il détermine l'ordre de deux éléments en comparant leurs tailles. Voici la définition de la fonction qsort :
void qsort(void *base, size_t count, size_t size, int (*compare)(const void *, const void *));
Description du paramètre :
base: Pointeur vers le premier élément du tableau à trier.count: Le nombre d'éléments à trier.size: Le nombre d'octets par élément.compare: Une fonction de comparaison utilisée pour comparer la taille de deux éléments. Cette fonction renvoie une valeur entière indiquant la relation d'ordre entre deux éléments. Si un nombre négatif est renvoyé, cela signifie que le premier élément doit être trié avant le deuxième élément ; si un nombre positif est renvoyé, cela signifie que le premier élément doit être trié après le deuxième élément ; si 0 est renvoyé, cela signifie que deux éléments égaux.
Lorsque vous utilisez la fonction qsort, vous devez personnaliser une fonction de comparaison pour comparer les éléments en fonction des besoins réels. Voici un exemple simple :
#include <stdio.h>
#include <stdlib.h>
int compare(const void *a, const void *b) {
return (*(int*)a - *(int*)b);
}
int main() {
int arr[] = {
3, 1, 4, 2, 5};
int n = sizeof(arr) / sizeof(int);
qsort(arr, n, sizeof(int), compare);
for (int i = 0; i < n; i++) {
printf("%d ", arr[i]);
}
printf("\n");
return 0;
}
Le résultat de sortie est :1 2 3 4 5 , indiquant que le tableau a été trié du plus petit au plus grand.
5. Comprendre le nom du tableau sizeof
提示：以下是代码样例，下面案例可供参考
char arr[] = "abcdef";//[a b c d e f \0]
printf("%d\n", sizeof(arr));//7
//char [7]
printf("%d\n", sizeof(arr + 0));//arr + 0是首元素的地址 4
printf("%d\n", sizeof(*arr));//*arr其实就是首元素,1个字节
//*arr--> *(arr+0) -- arr[0]
printf("%d\n", sizeof(arr[1]));//arr[1]是第二个元素，1个字节
printf("%d\n", sizeof(&arr));//&arr是数组的地址，是地址就是4/8个字节
printf("%d\n", sizeof(&arr + 1));//&arr + 1是跳过一个数组的地址，4/8
printf("%d\n", sizeof(&arr[0] + 1));//&arr[0] + 1是第二个元素的地址 4/8
printf("%d\n", sizeof(p));//p是一个指针变量 大小就是4/8
printf("%d\n", sizeof(p + 1));//p+1是'b'的地址，是地址大小就是4/8个字节
printf("%d\n", sizeof(*p));//*p 就是'a'，就是1个字节
printf("%d\n", sizeof(p[0]));//p[0]--> *(p+0) --> *p 1个字节
printf("%d\n", sizeof(&p));//4/8 &p -- char**
printf("%d\n", sizeof(&p + 1));//4/8
printf("%d\n", sizeof(&p[0] + 1));//4/8 ， &p[0] + 1得到是'b'的地址
5.1 Comprendre les noms de tableaux (tableau bidimensionnel)
5.1.1 Comprendre les noms de tableaux strlen
Caractéristiques
提示：以下是代码样例，下面案例可供参考
int main()
{
char arr[] = {
'a','b','c','d','e','f' };
printf("%d\n", strlen(arr));//因为字符数组arr中没有\0，所以在求字符串长度的时候，会一直往后找，产生的结构就是随机值
printf("%d\n", strlen(arr + 0));//arr + 0是首元素的地址，和第一个一样，也是随机值
printf("%d\n", strlen(*arr));//err(错误的写法), arr是数组首元素的地址，*arr就是数组首元素，就是'a'-97
//strlen函数参数的部分需要传一个地址，当我们传递的是'a'时，'a'的ASCII码值是97，那就是将97作为地址传参
//strlen就会从97这个地址开始统计字符串长度，这就非法访问内存了
//printf("%d\n", strlen(arr[1]));//err
printf("%d\n", strlen(&arr));//&arr是数组的地址,数组的地址和数组首元素的地址，值是一样的，那么传递给strlen函数后，依然是从数组的第一个元素的位置开始往后统计
printf("%d\n", strlen(&arr + 1));//随机值
printf("%d\n", strlen(&arr[0] + 1));//&arr[0] + 1是第二个元素的地址。结果也是随机值
return 0;
}
char* p = "abcdef";
// 012345
printf("%d\n", strlen(p));//6
printf("%d\n", strlen(p + 1));//5
//printf("%d\n", strlen(*p));//err
//printf("%d\n", strlen(p[0]));//err
printf("%d\n", strlen(&p));//随机值 编译器会随机给他分配地址
printf("%d\n", strlen(&p + 1));//随机值 &p+1 与 &p 没有差异，没啥关系
printf("%d\n", strlen(&p[0] + 1));//5
int a[3][4] = {
0 };
printf("%d\n", sizeof(a));//3*4*4 = 48
printf("%d\n", sizeof(a[0][0]));//4 零行零列的元素
printf("%d\n", sizeof(a[0]));//a[0]是第一行这个一维数组的数组名
//数组名算是单独放在sizeof内部了，计算的是整个数组的大小，大小是16个字节
printf("%d\n", sizeof(a[0] + 1));//?
//a[0]作为第一行的数组名，没有单独放在sizeo内部，没有&
//a[0]表示数组首元素的地址，也就是a[0][0]的地址
//所以a[0]+1是第一行第二个元素的地址，是地址就是4/8个字节
printf("%d\n", sizeof(*(a[0] + 1)));//4
//计算的是就是第一行第2个元素的大小
printf("%d\n", sizeof(a + 1));//4 / 8
//a是数组首元素的地址，是第一行的地址 int(*)[4]
//a+1 就是第二行的地址
printf("%d\n", sizeof(*(a + 1)));//16
//*(a+1) --> a[1] -> sizeof(*(a+1))->sizeof(a[1]) 计算的是第二行的大小
//a+1 --> 是第二行的地址，int(*)[4]
//*(a+1) 访问的第二行的数组
printf("%d\n", sizeof(&a[0] + 1));//4/8
//&a[0]是第一行的地址 int(*)[4]
//&a[0]+1 是第二行的地址 int(*)[4]
printf("%d\n", sizeof(*(&a[0] + 1)));//16 计算的是第二行的大小
printf("%d\n", sizeof(*a));//计算的是第一行的大小-16
//a是数组首元素的地址，就是第一行的地址
//*a 就是第一行
//*a --> *(a+0) --> a[0]
printf("%d\n", sizeof(a[3]));//16
//a[3]--> int [4]
5.1.2 Exemple :
Exemple 1.
Exemple 2.
Troisième exemple.
Exemple 4.
