中企动力做网站价格,网站建设公司现在还挣钱吗,建设厅网站的秘钥怎么买,wordpress欢迎页面模板目录
①(●◡●)前言
1.字符指针
✌字符指针和数组笔试题
2.指针数组 和数组指针
#x1f44a;指针数组
#x1f44a;数组指针 #x1f44a;数组名和数组名
3.数组传参和指针传参
#x1f44a;一维数组传参
#x1f44a;二维数组传参 #x1f44a;一级…
目录
①(●◡●)前言
1.字符指针
✌字符指针和数组笔试题
2.指针数组 和数组指针
指针数组
数组指针 数组名和数组名
3.数组传参和指针传参
一维数组传参
二维数组传参 一级指针传参
二级指针传参
4.函数指针
5.函数指针数组
函数指针数组应用
6.函数指针数组的指针
7.回调函数
qsort()
冒泡排序通用版 ①(●◡●)前言 在之前【C语言】入门——指针介绍了指针的概念 1. 指针就是个变量用来存放地址地址唯一标识一块内存空间。 2. 指针的大小是固定的4/8个字节32位平台/64位平台。 3. 指针是有类型指针的类型决定了指针的-整数的步长指针解引用操作的时候的权限。 4. 指针的运算。 这一篇介绍更深度的指针内容
1.字符指针 步长最短的字符型指针字符指针就是用来存放字符变量或字符串变量的指针 当存储字符串变量时会像数组一样只存入首字母的地址在解引用时可以根据首地址依次往后访问并解引用直到遇到结束标志 \0 由此看来指针貌似和数组有点相似。 int main()
{char s1 a;char* p s1;char* p2 abcdef;printf(%c\n, *p);printf(%s\n, p2);return 0;
} ✌字符指针和数组笔试题
//字符指针笔试题
int main()
{char arr1[] { Hello World };char arr2[] { Hello World };const char* str1 Hello World;const char* str2 Hello World;if (arr1 arr2)printf(arr1 and arr2 are same\n);elseprintf(arr1 and arr2 are not same\n);if (str1 str2)printf(str1 and str2 are same\n);elseprintf(str1 and str2 are not same\n);return 0;
} arr1和arr2是两个独立的数组自然地址不一样独立空间所以不相等 str1和str2是因为指向同一块空间因为两个相同的常量在内存中只会开辟一块空间 2.指针数组 和数组指针 指针数组是数组数组内存放的是指针 数组指针是指针存放数组的地址。 数组指针与指针数组容易混淆 int arr[5]; arr是一个数组每个元素是int类型的 有5个元素 int* parr1[10]; parr1是一个数组数组10个元素每个元素的类型是int* int (*parr2)[10]; parr2是一个指向数组的指针指向的数组有10个元素每个元素的类型是int int(* parr3[10])[5]; parr3是一个数组数组有10个元素每个元素的类型是int(*)[5] parr3是存放数组指针的数组 指针数组
//指针数组
int main()
{int a 1, b 2, c 3;int* pa a;int* pb b;int* pc c;int* arr[3] { pa,pb,pc };int i 0;for (i 0; i 3; i){printf(地址:%p\n, arr[i]);printf(值为:%d\n, *arr[i]);}return 0;
} 定义三个变量取各自他们的地址赋给不同的指针指针为int*再将指针放到数组内存放 arr的类型为int* (*arr)[3] arr的类型为int* arr; 数组指针
//数组指针
#include stdio.h
int main()
{int arr[10] { 0 };int (*p)[10] arr;//数组指针存放整形数组arr的地址return 0;
} 数组名和数组名
//数组名与数组名
int main()
{int arr[5] { 1,2,3,4,5 };int(*pa)[5] arr;printf(这是起始地址:%p %p\n, arr, pa);printf(这是1后的地址:%p %p\n, arr 1, pa 1);return 0;
} arr1加一个步长但是是整个数组的地址1所以是跳过整个数组大小 数组5个元素0x00fbfe58是首元素地址58-5c-60-64-68-6c 跳过了整个数组大小20个字节; arr1; 首元素地址1是跳过一个元素大小 58-5c;整型数组一个整型4个字节跳过一个元素即是4个字节 3.数组传参和指针传参
一维数组传参
//一维数组传参
void test1(int arr[])
{}//一维数组可以省略元素数也可以写上
void test1(int*pa)
{}//用一级指针接收一维数组
void test2(int*arr2[10])
{}//形参用指针数组接收指针数组传参
void test2(int**ppa)
{}//指针数组本质上是二级指针
int main()
{int arr1[10] { 0 };int* arr2[10] { 0 };test1(arr1);test2(arr2);return 0;
}
二维数组传参 三种方式 完整传参行和列都不省略 省略行 数组指针接受 //二维数组传参
void test(int arr[3][5])
{}//完整接收
void test(int arr[][5])
{}//省略行是可以的
void test(int(*pa)[5])
{}//用我们前面的数组指针接收
void test(int** pa)
{}//是错误的
int main()
{int arr[3][3] { 0 };test(arr);return 0;
} 一级指针传参
//一级指针传参
void test1(int* pa, int sz)
{}//传数组名用指针接收
void test2(int* pa, int sz)
{}//传指针用指针接收
int main()
{int arr[3] { 1,2,3 };int sz sizeof(arr) / sizeof(arr[0]);int* pa arr;test1(arr, sz);test2(pa, sz);return 0;
}
二级指针传参
//二级指针传参
void test1(int**pa)
{}//接收的是二级指针
void test2(int**pa)
{}//接收的一级指针的地址
int main()
{int a 10;int* pa a;//一级指针int** ppa pa;//二级指针test1(ppa);//传二级指针test2(pa);//将一级指针的地址取出来return 0;
}
4.函数指针 函数指针是指向函数的指针函数名就是地址 函数指针由三部分组成 类型、指针、形参 类型和形参可以为空当想要调用函数时只需要通过指针并传入参数就能正常使用函数。 int Add(int x,int y)
{return x y;
}
int main()
{int (*p)(int, int) Add;printf(%d, p(2, 3)); //5return 0;
} 来个函数指针趣题
void (*signal(int, void(*)(int)))(int);1.函数指针 void(*)(int) 2.函数名: signal 3.signal函数的参数 int, void(*)(int); 一个整型一个函数指针 4.返回值signal函数的返回值是指针 5.函数指针数组 将一些函数地址存入数组中就得到了函数指针数组。 //函数指针数组
int Add(int x, int y)
{return x y;
}
int Sub(const int x, const int y)
{return x - y;
}
int main()
{int(*pfun[2])(const int x, const int y) { Add,Sub };printf(%d\n, pfun[0](2, 3)); //5printf(%d\n, pfun[1](5, 3)); //2return 0;
}
函数名就是地址名不需要地址函数形参不能省略
函数指针数组应用
//简易整型计算器
#includestdio.h
void menu()
{printf(*****计算器*****\n);printf(**1.Add 2.Sub**\n);printf(**3.Mul 4.DIV**\n);printf(*****0.exit*****\n);}
int add(const int x, const int y)
{return x y;
}
int sub(const int x, const int y)
{return x - y;
}
int mul(const int x, const int y)
{return x * y;
}
int div(const int x, const int y)
{return x / y;
}
int main()
{int input 1;int(*calc[5])(const int x, const int y) { 0,add,sub,mul,div };//放0的原因是和菜单中的序号对应上while (input){menu();printf(请输入:);scanf(%d, input);if (input 0 input 5){int x 0, y 0;printf(请输入两个数:);scanf(%d %d, x, y);printf(计算结果为%d\n, calc[input](x, y));}else if (input 5)printf(选择错误请重新选择!\n);}printf(退出计算器\n);return 0;
}6.函数指针数组的指针 套娃式本质是指针
void test(const char* str)
{printf(%s\n, str);
}
int main()
{//函数指针pfunvoid (*pfun)(const char*) test;//函数指针的数组pfunArrvoid (*pfunArr[5])(const char* str);pfunArr[0] test;//指向函数指针数组pfunArr的指针ppfunArrvoid (*(*ppfunArr)[5])(const char*) pfunArr;return 0;
}例子2
//函数指针数组的指针
int add(int x, int y)
{return x y;
}
int main()
{//这是函数指针数组int (*pa[5])(int x, int y) { add };//这是函数指针数组的指针,需要取出地址int(*(*ppa)[5])(int x, int y) pa;printf(这是函数指针数组的指针%p\n, ppa);printf(这是函数指针数组后的地址%p\n, pa);return 0;
}
7.回调函数 回调函数就是一个通过函数指针调用的函数。 如果你把函数的指针地址作为参数传递给另一个 函数当这个指针被用来调用其所指向的函数时这就是回调函数。 依赖函数指针有了函数指针才能实现回调函数 qsort() qsort():快速排序 库函数头文件#includestdlib.h qsort函数可以进行各种数据的排序 void qsort(void* base, //待排序数组的第一个元素的地址 size_t num, //待排序数组的元素个数 size_t size, //待排序数组中一个元素的大小 int (* cmp)(const void* e1, const void* e2) //函数指针自己定义排序函数 整型实例
//qsort()
#includestdio.h
#includestdlib.h
int cmp(const void* e1, const void* e2)
{return *(int*)e1 - *(int*)e2;
}
int main()
{int arr[] {5,4,3,2,1 };int sz sizeof(arr) / sizeof(arr[0]);qsort(arr, sz, sizeof(arr[0]), cmp);int i 0;for (i 0; i sz; i){printf(%d , arr[i]);}return 0;
} 函数指针-cmp指向了一个函数这个函数是用来比较两个元素的 e1和e2中存放的是需要比较的两个元素的地址 void* 不能直接进行计算需要强转成其他类型 结构体示例
#includestring.h
#includestdlib.h
struct Stu
{char name[20];int age;
};int cmp_by_name(const void* e1,const void* e2)
{return strcmp(((struct Stu*)e1)-name,((struct Stu*)e2)-name);
}
int main()
{struct Stu arr[] { {zhangsan,20},{wangwu,15} };//元素个数int sz sizeof(arr) / sizeof(arr[0]);qsort(arr, sz, sizeof(arr[0]), cmp_by_name);return 0;
} strcmp是根据字符字典顺序比较的后面的大需要包含头文件#includestdlib.h qsort函数中就用到了回调函数的知识使用qsort它都会去调用比较函数。 冒泡排序通用版
用冒泡排序的思路去模仿qsort()
#includestring.h
struct Stu
{char name[20];int age;
};
//结构体年龄比较
int cmp_age(void* e1, void* e2)
{return ((struct Stu*)e1)-age - ((struct Stu*)e2)-age;
}
//字节交换,size是一个数据的字节大小
void swap(char* buf1, char* buf2, size_t size)
{int k 0;for (k 0; k size; k){char temp *buf1;*buf1 *buf2;*buf2 temp;buf1;buf2;}
}
//整型比较
int cmp_int(const void* e1, const void* e2)
{return *(int*)e1 - *(int*)e2;
}
//打印
void print(int* arr, int sz)
{int i 0;for (i 0; i sz; i){printf(%d , arr[i]);}
}
//冒泡模拟qsort
void my_qsort(void* base, size_t num, size_t size, int(*cmp_name)(const void* p1, const void* p2))
{int i 0;for (i 0; i num - 1; i){int j 0;for (j 0; j num - 1 - i; j){if (cmp_name((char*)base j * size, (char*)base (j 1) * size) 0) //得到的返回值如果大于0就交换{swap((char*)base j * size, (char*)base (j 1) * size, size);}}}
}int main()
{struct Stu arr[] { {zhangsan,15},{lisi,12},{wangwu,30} };int iarr[] { 9,8,7,6,5,4,3,2,1,0 };//整型数组的元素个数int isz sizeof(iarr) / sizeof(iarr[0]);my_qsort(iarr, isz, sizeof(iarr[0]), cmp_int);print(iarr, isz);//结构体的元素个数int sz sizeof(arr) / sizeof(arr[0]);my_qsort(arr, sz, sizeof(arr[0]), cmp_age);return 0;
}感谢你看到这里 以上就是我对进阶指针的介绍身为初学者自知有很多不足和需要改善的地方希望大佬们指点一二感激不急 ⭐愿星光照亮每一位赶路人 ⭐
