本次记录我对C语言指针的学习
一.字符指针
1.字符指针为指向字符的指针，指针的大小都为4个字节（32位平台）或8个字节（64位平台）
2.示例代码1：
int main()
{
char* p = "abcde";
//"abcde"为常量字符串
//p存放此字符串首字母a的地址
printf("%c\n", *p);//输出 a
printf("%s\n", p);//输出 abcde
return 0;
}示例代码2：
int main()
{
char arr1[] = "abcdef";
char arr2[] = "abcdef";
char* p1 = "abcdef";//常量字符串
char* p2 = "abcdef";
if (arr1 == arr2)
printf("哈哈\n");
else
printf("呵呵\n");//输出 呵呵
if (p1 == p2)
printf("哈哈\n");//输出 哈哈
else
printf("呵呵\n");
return 0;
}
常量字符串为一固定的字符串，它的地址为其第一个元素的地址。如取常量字符串"abcde"的地址为 a的地址
二.数组指针
1.数组指针为能够指向数组的指针，它与其它相似类型的区别如下：
- int arr[10] :arr是一个10个元素的整型数组
- int* parr1[10] ：parr1是一个数组，数组有10个元素，每个元素的类型是Int*，parr1是指针数组
- int (*parr2)[10] ：parr2是一个指针，该指针指向了一个数组，数组有10个元素，每个元素的类型是int，parr2是数组指针
- int (*parr3[10])[5] ：parr3是一个数组，该数组有10个元素，每个元素是一个数组指针，该数组指针指向的数组有5个元素，每个元素的类型是int
总结：将数组名去掉之后剩下的部分即为数组里元素的类型。如int arr[10]去掉数组名arr[10]，剩下的int(整型)即为数组里元素的类型； int* parr1[10]去掉数组名parr1[10]，剩下的int*(整型指针)即为数组里元素的类型；int (*parr2)[10]去掉数组名parr2，剩下的int(*) [10](指针)即为数组里元素的类型；int (*parr3[10])[5]去掉数组名parr3[10]，剩下的int(*)[5](指针)即为数组里元素的类型
2.创建数组指针：
如果一个数组的类型为char* arr1[5]，创建它的数组指针为char* (*pa)[5] =&arr1；如果一个数组的类型为int arr2[5]，创建它的数组指针为int (*arr2)[5]=&arr2。代码如下：
int main()
{
char* arr1[5] ;
char* (*arr1)[5] = &arr1;//数组指针
int arr2[5];
int(*arr2)[5] = &arr2;//数组指针
return 0;
}3.数组指针的运用：
- 运用数组指针之前，先回顾一下指针对一维数组的用法，代码如下：
//打印arr[10]
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
int i;
int* p = arr;
for (i = 0; i < 10; i++)
{
printf("%d ", *(p+i));
}
return 0;
其中*(p+i)=*(arr+i)=arr[i]=p[i]，它们可以互换
- 现在来研究数组指针对二维数组的用法，代码如下：
void print1(int arr[3][5], int a, int b) { int i = 0; for (i = 0; i < a; i++) { int j = 0; for (j = 0; j < b; j++) { printf("%d ", arr[i][j]); } printf("\n"); } printf("\n"); } void print2(int (*p)[5], int a, int b) { int i = 0; for (i = 0; i < a; i++) { int j = 0; for (j = 0; j < b; j++) { printf("%d ", ( * (p + i))[j]); } printf("\n"); } printf("\n"); } int main() { int arr[3][5] = { {1,2,3,4,5},{2,3,4,5,6},{3,4,5,6,7} }; print1(arr, 3, 5); print2(arr, 3, 5); return 0; }这里用了两个函数，print1函数为以前的常规方法，print2函数为数组指针方法，其中print2里的( * (p + i))[j]= *(*(p+i)+j)=p[i][j]=*(p[i]+j)，它们可以互换
三.数组指针
1.数组传参
- 一维数组传参
void test1(int arr[])
{}
void test1(int arr[10])
{}
void test1(int* arr)
{}
void test2(int* arr[20])
{}
void test2(int** arr)
{}
int main()
{
int arr1[10] = { 0 };
int* arr2[20] = { 0 };
test1(arr1);
test2(arr2);
return 0;
}- 二维数组传参
二维数组传参，函数形参的设计可以省略第一个[]的数字，不能省略第二个[]的数字void test1(int arr[3][5]) {} void test1(int arr[][5])//二维数组传参，函数形参的设计可以省略第一个[]的数字，不能省略第二个[]的数字 {} void test2(int (* arr)[5]) {} int main() { int arr[3][5] = { 0 }; test1(arr);//二维数组传参传的是数组第一行的地址 test2(arr); return 0; }
二维数组传参传的是数组第一行的地址
2.函数指针
- 函数指针是指向函数的指针，存放函数的地址
-
&函数名 和 函数名 都是函数的地址int Add(int x, int y) { int z = x + y; return z; } int main() { int (*p)(int, int) = Add;//&Add和Add都是函数的地址 printf("%d\n", Add(10, 20)); printf("%d\n", p(10, 20)); printf("%d\n", (*p)(10, 20));//(*pa)中的*可有可无 printf("%d\n", (**p)(10, 20)); printf("%d\n", (***p)(10, 20)); return 0; } //都输出30 -
void Print(char* str) { printf("%s\n", str); } int main() { void (*p)(char*) = &Print; (*p)("hello world"); return 0; } //输出：hello world - 解释代码一：
(*(void(*)())0)() //把0强制类型转换成：void(*)()函数指针类型，此时0就是一个函数的地址 //调用0地址处的该函数解释代码二：
void (*signal(int,void(*)(int)))(int) //signal是一个函数声明 //signal函数的参数有两个，第一个是int，第二个是函数指针，该函数指针指向的函数的参数是int，返回类型是void //signal函数的返回类型也是一个函数指针：该函数指针指向的函数的参数是int，返回类型是void
3.函数指针数组
- 要把函数的地址存到一个数组中，这个数组就叫做函数指针数组。如：int (*parr1[10])()，其中parr1先和[ ]结合，说明parr1是数组，数组的内容是int (*)( )类型的函数指针
-
比较函数指针与函数指针数组的区别
char* my_strcpy(char* dest,const char* src) //1.写一个函数指针pf，能够指向my_strcpy char* (*pf)(char*,const char*) //写一个函数指针数组pfArr，能够存放4个my_strcpy函数的地址 char* (*pfArr[4])(char*,const char*) - 函数指针数组转化表写计算器
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 input = 0; int(*p[5])(int, int) = { 0,Add,Sub,Mul,Div };//函数指针数组的创建 do { menu(); printf("请选择\n"); scanf("%d", &input); if (input > 0 && input < 5) { int x, y; printf("请输入操作数\n"); scanf("%d%d", &x, &y); printf("%d\n", p[input](x, y));//函数指针数组的运用 } else if (input == 0) printf("退出\n"); else printf("输入错误，请重新输入\n"); } while (input); return 0; }
4.指向函数指针数组的指针
-
指向函数指针数组的指针 是一个指针，，此指针指向一个数组，数组的元素都是函数指针。代码如下：
int main() { int (*pfArr[4])(int, int); //pfArr是一个函数指针的数组 int (*(*ppfArr)[4])(int, int) = &pfArr; //ppfArr是一个指向函数指针数组的指针 //ppfArr是一个数组指针，指针指向的数组有4个元素 //ppfArr指向的数组的每个元素的类型是一个函数指针int(*)(int,int) return 0; }
5.回调函数
- 回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针
被用来调用其所指向的函数时，我们就说这是回调函数。回调函数不是由该函数的实现放直接调用，而是在特定的事
件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应 - 代码一：回调函数写计算器
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 Calc(int (*pf)(int, int)) { int x, y; printf("请输入两个操作数\n"); scanf("%d%d", &x, &y); printf("%d\n", pf(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 input = 0; do { menu(); printf("请选择\n"); scanf("%d", &input); switch (input) { case 1: Calc(Add); break; case 2: Calc(Sub); break; case 3: Calc(Mul); break; case 4: Calc(Div); break; case 0: printf("退出\n"); break; default: printf("输入错误，请重新输入\n"); break; } } while (input); return 0; } - 代码二：
void print(char* str) { printf("hehe:%s", str); } void test(void (*p)(char*)) { printf("test\n"); p("bit"); } int main() { test(print); return 0; }
四.qsort函数
1.qsort函数实现冒泡排序
struct Stu
{
char name[20];
int age;
};
int cmp_f(const void* e1,const void* e2)
{
return (*(float*)e1 - *(float*)e2);
}
//void*类型的指针，可以接收任意类型的地址
//void*类型的指针，不能进行解引用操作
//void*类型的指针，不能进行加减整数的操作
int cmp_Stu_name(const void* e1, const void* e2)
{
return strcmp(((struct Stu*)e1)->name, ((struct Stu*)e2)->name);
}
int cmp_Stu_age(const void* e1, const void* e2)
{
return ((*(struct Stu*)e1).age - (*(struct Stu*)e2).age);
}
void test1float()
{
float num[] = { 1.0, 3.0 ,2.0,4.0,5.0,6.0,8.0,7.0 };
int sz = sizeof(num) / sizeof(num[0]);
int i = 0;
qsort(num, sz, sizeof(num[0]), cmp_f);
for (i = 0; i < sz ; i++)
{
printf("%f ", num[i]);
}
printf("\n");
}
void test2name()
{
struct Stu s[3] = { {"wuxiajianru",20},{"fengzuo",10},{"yangfuli",50} };
int sz = sizeof(s) / sizeof(s[0]);
int i = 0;
qsort(s, sz, sizeof(s[0]), cmp_Stu_name);
for (i = 0; i < sz ; i++)
{
printf("%s ", s[i].name);
}
printf("\n");
}
void test3age()
{
struct Stu s[3] = { {"fengzuo",20},{"wuxiajianru",10},{"yangfuli",50} };
int sz = sizeof(s) / sizeof(s[0]);
int i = 0;
qsort(s, sz, sizeof(s[0]), cmp_Stu_age);
for (i = 0; i < sz ; i++)
{
printf("%d ", s[i].age);
}
printf("\n");
}
int main()
{
test1float();
test2name();
test3age();
return 0;
}2.C代码实现qsort函数
struct Stu
{
char name[20];
int age;
};
int cmp_Stu_name(const void* e1, const void* e2)
{
return strcmp(((struct Stu*)e1)->name, ((struct Stu*)e2)->name);
}
void Swap(char* buf1, char* buf2, int width)
{
int i;
for (i = 0; i < width; i++)
{
char tmp = *buf1;
*buf1 = *buf2;
*buf2 = tmp;
buf1++;
buf2++;
}
}
void bubble_sort(void* base, int sz, int width, int (*cmp)(void* e1, void* e2))
{
int i;
for (i = 0; i < sz - 1; i++)
{
int j = 0;
for (j = 0; j < sz - 1 - i; j++)
{
if (cmp((char*)base + j * width, (char*)base + (j + 1) * width) > 0)
{
Swap((char*)base + j * width, (char*)base + (j + 1) * width, width);
}
}
}
}
void test()
{
int i = 0;
struct Stu s[3] = { {"wuxiajianru",20},{"fengzuo",10},{"yangfuli",50} };
int sz = sizeof(s) / sizeof(s[0]);
bubble_sort(s, sz, sizeof(s[0]), cmp_Stu_name);
for (i = 0; i < sz; i++)
{
printf("%s ", s[i].name);
}
}
int main()
{
test();
return 0;
}
5687
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
