广州建设工程质量安全网站,定制网站建设公司电话,做网站游戏总结的例文,上海猎头公司排名前十引言#xff1a;在前面的c语言_指针初阶上#xff0c;我们了解了简单的指针类型以及使用#xff0c;下面我们将进入更深层次的指针学习#xff0c;对指针的理解会有一个极大的提升。从此以后#xff0c;指针将不再是难点#xff0c;而是学习底层语言的一把利器。 本章重点… 引言在前面的c语言_指针初阶上我们了解了简单的指针类型以及使用下面我们将进入更深层次的指针学习对指针的理解会有一个极大的提升。从此以后指针将不再是难点而是学习底层语言的一把利器。 本章重点
字符指针数组指针指针数组数组传参和指针传参函数指针函数指针数组指向函数指针数组的指针回调函数指针和数组面试题的解析 指针的主题我们在初级阶段的《指针》章节已经接触过了我们知道了指针的概念 指针就是个变量用来存放地址地址唯一标识一块内存空间。 指针的大小是固定的4/8个字节32位平台/64位平台。 指针是有类型指针的类型决定了指针的±整数的步长指针解引用操作的时候的权限。 指针的运算。 这个章节我们继续探讨指针的高级主题。
1. 字符指针
在指针的类型中我们知道有一种指针类型为字符指针char*;
一般使用:
int main()
{char ch w;char *pc ch;*pc w;return 0;
}还有一种使用方式如下
int main()
{char* pstr hello bit.;//这里是把一个字符串放到pstr指针变量里了吗printf(%s\n, pstr);return 0;
}代码char* pstr hello bit.特别容易让同学以为是把字符串hello bit 放到字符指针了但是本质是把字符串pstr 里hello bit首字符的地址放到了pstr中。
类似于int arr[3] {1, 2, 3}; int* parr arr。我们知道数组名就是首元素地址那么将数组名当作地址存入parr的指针变量中。 我们可以看到结果确实是把字符串的首元素地址存储在了parr指针变量中。 一道面试题 输出结果 为什么会产生出这种结果 通俗易懂来说,str1以及str2它们各自开辟了一块空间然后都拿了相同的字符串进行存储那么即便值相同地址却是不相同的。 str3和str4都指向了一块常量我们知道常量是不可以被修改的所以也没必要产生出两个指针指向同一个常量由此可得str3 str4。 所以这里的区别就是一个是存储值一个是指向常量。 当我们往下面学习指针数组和数组指针的时候就会产生一种没来由的困惑读起来都有点绕口。其实辨别起来很简单只需要去看最后两个字是什么。
指针数组数组装有指针元素的数组 数组指针指针指向数组的指针
2. 指针数组
在C语言_指针_初阶章节我们也学了指针数组指针数组是一个存放指针的数组。
这里我们再复习一下下面指针数组是什么意思
int* arr1[10]; //整形指针的数组
char *arr2[4]; //一级字符指针的数组
char **arr3[5];//二级字符指针的数组通过指针数组模拟实现二维数组 3. 数组指针
3.1 数组指针的定义
数组指针是指针还是数组
答案是指针。
我们已经熟悉了整型指针int* ptr能够指向整形数据的指针。浮点型指针float* ptr能够指向浮点型数据的指针。
那数组指针也就很明确了指向数组的指针。
下面代码哪个是数组指针
int *p1[10];
//p1先跟[]结合说明他是数组,[]里面是10说明装有10个整型指针的元素。
int (*p2)[10];//数组指针//p1, p2分别是什么画图详解 解释 首先p和先做结合也就是( * p)说明p是指针变量然后外面还剩下int [10]这个我们之前见过也就是装有10个整型元素的数组。那么好像就能合起来解释了也就是指向装有10个整型元素的数组的指针。 总结p是指针指向一个数组也就是数组指针。 这里需要注意的是[]的优先级是要高于 * 号的所以必须加上来保证p先和结合。 3.2 数组名 VS 数组名
对于下面的数组 int arr[10]; arr 和 arr 分别是啥
我们知道arr是数组名数组名表示数组首元素的地址。
那arr数组名到底是啥
我们看一段代码
#include stdio.h
int main()
{int arr[10] {0};printf(%p\n, arr);printf(%p\n, arr);return 0;
}输出结果 可见数组名和数组名打印的地址是一样的。
难道两个是一样的吗
我们再看一段代码
#include stdio.h
int main()
{int arr[10] { 0 };printf(arr %p\n, arr);printf(arr %p\n, arr);printf(arr1 %p\n, arr1);printf(arr1 %p\n, arr1);return 0;
}输出结果 根据上面的代码我们发现其实arr和arr虽然值是一样的但是意义应该是不一样的。 实际上arr 表示的是数组的地址而不是数组首元素的地址。细细体会一下 数组的地址1跳过整个数组的大小所以arr1 相对于 arr 的差值是40。 从上面可知数组名就是首元素的地址那么sizeof(数组名)难道取的是指针变量的字节嘛 由此可得sizeof(数组名)并不是取得首元素地址的字节这里的数组名代表了整个数组也就是取得是整个数组的地址。 我们可以看到虽然表达出来的结果完全一样但内在的意义确实完全不相同。 总结
数组名大部分情况下都是首元素地址但有两个例外如下
1.sizeof数组名这里面的数组名代表的是整个数组所以取出来的字节也就是整个数组的字节。
2.数组名这里的数组名代表的也是整个数组那么取出来的地址也就是整个数组的地址。
3.3 数组指针的使用
那数组指针是怎么使用的呢
既然数组指针指向的是数组那数组指针中存放的应该是数组的地址。
下面我们通过数组指针完成对数组内的元素进行一个遍历。 画图详解 上面我们讲述了一维数组取地址变成数组指针的使用方式下面我们来讲述二维数组取地址变成数组指针的使用方式并且会画图详细的描述整个流程。 画图详解 - 分批次详细解读针对二维数组取地址变成数组指对内部的值进行访问的一个过程 4. 数组参数、指针参数
4.1 一维数组传参
#include stdio.h
void test(int arr[])//ok?
//实参传递了数组名形参就可以用数组类型进行接受
{}
void test(int arr[10])//ok?
//完全没问题
{}
void test(int *arr)//ok?
//指向int类型元素的地址也就是指向首元素的地址。
{}
void test2(int *arr[20])//ok?
//完全没问题
{}
void test2(int **arr)//ok?
//(*arr)是一个指针指向了一个int*类型的元素。
{}int main()
{int arr[10] {0};int *arr2[20] {0};test(arr);test2(arr2);
}4.2 二维数组传参
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
//正确(*arr)是指针指向了一个装有五个整型元素的数组。
{}
void test(int **arr)//ok
//错误首元素地址代表的是一维数组的整个数组地址。
{}int main()
{int arr[3][5] {0};test(arr);
}一级指针传参
#include stdio.h
void print(int *p, int sz)
{int i 0;for(i0; isz; i){printf(%d\n, *(pi));}
}int main()
{int arr[10] {1,2,3,4,5,6,7,8,9};int *p arr;int sz sizeof(arr)/sizeof(arr[0]);//一级指针p传给函数print(p, sz);return 0;
}当一个函数的参数部分为一级指针的时候函数能接收什么参数 void test(char* ptr)
{}int main()
{char arr[10] abcdef;char ch a;char* ptr arr;test(arr);test(ch);test(ptr);return 0;
}二级指针传参
#include stdio.h
void test(int** ptr)
{printf(num %d\n, **ptr);
}int main()
{int n 10;int*p n;int **pp p;int* arr[5];test(pp);test(p);test(arr);return 0;
}5. 函数指针
首先我们看最后两位是指针那么他其实就是指向函数的指针。 输出的是两个地址这两个地址是test函数的地址。 那我们的函数的地址要想保存起来怎么保存
下面我们看代码
void test(char* pc, int arr[10])
{}int main()
{void (*ptr)(char*, int [10]) test;//test跟test都能表达地址可以省略。return 0;
}首先*和ptr先结合说明它是指针指向的是一个函数里面有char*的类型和int [10] 类型这个函数的类型是void类型。 总结指向了一个void类型函数里面参数有char*类型以及int[10]类型的指针。 那么我们既然知道了函数指针怎么创建那下面我们就继续讨论怎么使用函数指针。 看起来我们好像知道了该怎么使用函数指针进行传参了上面我们已经了解了pf就是函数地址,但是这里的(*pf)并不是对pf做一个解引用的访问在函数指针中函数名 函数名也就是说这里的*号仅仅起到装饰的作用并不能跟解引用访问串联起来。 聪明的朋友已经看出来了add和add都是代表着函数地址的意思那么pf好像等价于add那有没有可能pf(参数1参数2)也可以进行函数调用呢 看起来跟我们的想法是正确的。 阅读两段有趣的代码 (*(void (*)())0)();画图详解 void (*signal(int , void(*)(int)))(int);画图详解 在做一个类似的题目再次进行巩固所学的知识 6. 函数指针数组
数组是一个存放相同类型数据的存储空间那我们已经学习了指针数组 比如
int *arr[10];
//数组的每个元素是int*那要把函数的地址存到一个数组中那这个数组就叫函数指针数组那函数指针的数组如何定义呢
int (*parr1[10]])();parr1先和[]结合说明它是一个数组数组里面装有10个int(*)()函数类型元素。 那么我们从这里就明白了函数指针数组的写法那么我们开拓一下思路是不是也就知道了数组指针数组的写法
int arr_1[5] { 1, 2, 3, 4, 5 };
int arr_2[5] { 1, 2, 3, 4, 5 };
int arr_3[5] { 1, 2, 3, 4, 5 };
int (*parr[3])[5] {arr_1, arr_2, arr_3};parr先和[3]结合说明parr是一个数组里面装有三个指向装有5个int类型元素的数组的指针 听着可能有些绕口我们把这段话再次拆开来细细分析。 我们就先看里面的内容简单来说是不是就是指向数组的指针然后数组里面有三个元素都是这样的类型。 函数指针数组的用途转移表
例子计算器
//加法
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 x 0;int y 0;int ret 0;do{menu();printf(请选择);scanf(%d, input);switch (input){case 1:printf(请输入两个数字);scanf(%d %d, x, y);ret add(x, y);printf(ret %d\n, ret);break;case 2:printf(请输入两个数字);scanf(%d %d, x, y);ret sub(x, y);printf(ret %d\n, ret);break;case 3:printf(请输入两个数字);scanf(%d %d, x, y);ret mul(x, y);printf(ret %d\n, ret);break;case 4:printf(请输入两个数字);scanf(%d %d, x, y);ret div(x, y);printf(ret %d\n, ret);break;case 0:printf(退出计算器\n);break;default:printf(输入错误请重新选择\n);break;}} while (input);return 0;
}虽然实现了计算器项目但是可以看到代码中出现了大量重复的代码显得十分冗余。 所以衍生出了下面的这个方式使用函数指针数组实现计算器
//加法
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 x 0;int y 0;int ret 0;//函数指针数组int (*PfArr[5])(int, int) {NULL, add, sub, mul, div};do{menu();printf(请选择);scanf(%d, input);if (input 1 input 4){printf(请输入两个数字);scanf(%d %d, x, y);//通过函数指针数组调用函数 - 转移表//通过函数指针数组找到对应下标然后跳到该函数位置得到结果再次返回来。int ret (*PfArr[input])(x, y);printf(ret %d\n, ret);}else if (input 0){printf(退出计算器\n);}else{printf(输入有误请重新检查\n);}} while (input);return 0;
}可以明显的感受到代码进行了简化。 7. 指向函数指针数组的指针
其实很好理解指针指向了一个数组数组里面的元素都是函数指针。
void test(const char* str)
{printf(%s\n, str);
}int main()
{//函数指针void(*pf)(const char*) test;//函数指针数组void(*pf[5])(const char*);//指向函数指针数组的指针void(*(*pf)[5])(const char*);//再次拓展//指向函数指针数组的指针的数组void(*(*pf[5])[5])(const char*);return 0;
}8. 回调函数 回调函数就是一个通过函数指针调用的函数。如果你把函数的指针地址作为参数传递给另一个函数当这个指针被用来调用其所指向的函数时我们就说这是回调函数。回调函数不是由该函数的实现方直接调用而是在特定的事件或条件发生时由另外的一方调用的用于对该事件或条件进行响应。 画图详解 那我们知道了回调函数的概念通过回调函数来继续实现计算器项目
//加法
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);
}//在特定条件下通过传递过来的地址作为媒介去调用函数
void Cacl(int(*pf)(int, int))
{int x 0;int y 0;printf(请输入两个数字);scanf(%d %d, x, y);int ret (*pf)(x, y);printf(ret %d\n, ret);
}int main()
{int input 0;int x 0;int y 0;int ret 0;do{menu();printf(请选择);scanf(%d, input);switch (input){case 1:Cacl(add);break;case 2:Cacl(sub);break;case 3:Cacl(mul);break;case 4:Cacl(div);break;case 0:printf(退出计算器\n);break;default:printf(输入有误请重新输入\n);break;}} while (input);return 0;
}通过回调函数的方式完成计算器项目代码也是得到了很大的简化。 下面在讲qsort之前我们先了解一下冒泡排序的思路。
其实冒泡排序的核心思路不难就是通过相邻两个数字进行对比不断的将一个最大值或者最小值挪到最右边以上仅仅是一趟我们要通过多躺实现最终的效果。
我们将冒泡排序再次复习一遍。
//冒泡排序
void Bubble_sort(int* arr, int sz)
{int i 0;//趟数for (i 0; i sz - 1; i){int j 0;//一趟比较的次数for (j 0; j sz - 1 - i; j){//相邻两个数字进行比对if (arr[j] arr[j 1]){//三个空杯子原理进行交换int tmp arr[j];arr[j] arr[j 1];arr[j 1] tmp;}}}
}//输出排序结果
void Printf(int* arr, int sz)
{int i 0;for (i 0; i sz; i){printf(%d , arr[i]);}return 0;
}int main()
{int arr[10] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };int sz sizeof(arr) / sizeof(arr[0]);Bubble_sort(arr, sz);Printf(arr, sz);return 0;
}输出结果 首先演示一下qsort函数的使用
#include stdlib.h
#include string.h//void*指针 - 无具体类型指针
// void*指针可以接受任意类型的指针
//void*类型指针不能直接进行解引用访问
//也不能直接用来进行指针运算//整型数组通过整型元素比较
int cmp_int(const void* p1, const void* p2)
{return *(int*)p2 - *(int*)p1;
}//输出结果
void Printf(int* arr, int sz)
{int i 0;for (i 0; i sz; i){printf(%d , arr[i]);}
}//测试qsort排序整型
void test1()
{int arr[10] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };int sz sizeof(arr) / sizeof(arr[0]);qsort(arr, sz, sizeof(int), cmp_int);Printf(arr, sz);
}//测试qsort排序结构体
typedef struct Stu Stu;
struct Stu
{char name[20];int age;
};//结构体通过年龄比较
int cmp_stu_by_age(const void* p1, const void* p2)
{return (((Stu*)p1)-age - ((Stu*)p2)-age);
}//结构体通过名字比较
int cmp_stu_by_name(const void* p1, const void* p2)
{//名字不能直接相减需要通过专门的字符比较函数 - strcmpreturn strcmp(((Stu*)p1)-name, ((Stu*)p1)-name);
}void test2()
{Stu arr[3] { {XingC, 22}, {qmx_07, 20}, {Yuu, 21}};int sz sizeof(arr) / sizeof(arr[0]);qsort(arr, sz, sizeof(arr[0]), cmp_stu_by_age);printf(%d\n, arr[2].age);
}void test3()
{Stu arr[3] { {XingC, 22}, {qmx_07, 20}, {Yuu, 21} };int sz sizeof(arr) / sizeof(arr[0]);qsort(arr, sz, sizeof(arr[0]), cmp_stu_by_name);int i 0;for (i 0; i 3; i){printf(name %s\tage %d\n, arr[i].name, arr[i].age);}
}int main()
{test1();test2();test3();return 0;
}使用回调函数模拟实现qsort采用冒泡的方式。 问题一传统冒泡排序我们会用整型数组类型接收那么我们想模拟实现快排那就不能固定使用整型数组类型 问题二传统冒泡排序比较使用大小符号比较的那么结构体如何使用大小符号比较呢 问题三传统冒泡排序符合条件进行交换是通过三个杯子交换实现的但是不同的数据交换略有差异。 //交换
//因为我们不知道我们要交换的类型是什么所以以最小字节来进行一一交换最合适不过
//我们还是需要知道这个类型的字节多少所以传入了一个sz
void Swap(char* buf1, char* buf2, int sz)
{int i 0;//我们知道字节大小的情况下循环交换两数的每个字节for (i 0; i sz; i){char tmp *(buf1 i);*(buf1 i) *(buf2 i);*(buf2 i) tmp;}
}void Bubble_sort(const void* base, int num, int sz, int (*cmp)(const void*, const void*))
{int i 0;for (i 0; i num - 1; i){int j 0;for (j 0; j num - 1 - i; j){//通过我们自己写的比较函数来判断是否符合条件if ((*cmp)((char*)base j * sz, (char*)base (j 1) * sz) 0){//交换Swap((char*)base j * sz, (char*)base (j 1) * sz, sz);}}}
}//定义结构体
typedef struct Stu Stu;
struct Stu
{char name[20];int age;
};//结构体年龄成员比较方式
int cmp_stu_by_age(const void* p1, const void* p2)
{return (((Stu*)p1)-age - ((Stu*)p2)-age);
}//结构体名字成员比较方式
int cmp_stu_by_name(const void* p1, const void* p2)
{return strcmp(((Stu*)p1)-name, ((Stu*)p2)-name);
}//测试Bubble_sort 排序结构体数据
void test_2()
{Stu arr[3] { {XingC, 22}, {qmx_07, 20}, {Yuu, 21} };int sz sizeof(arr) / sizeof(arr[0]);Bubble_sort(arr, sz, sizeof(arr[0]), cmp_stu_by_name);int i 0;for (i 0; i sz; i){printf(name %s\tage %d\n, arr[i].name, arr[i].age);}
}//整型比较方式
int cmp_int(const void* p1, const void* p2)
{return *(int*)p1 - *(int*)p2;
}//测试Bubble_sort 排序整型数据
void test_1()
{int arr[10] {5, 7, 2, 3, 9, 1, 6, 8, 4, 10};int sz sizeof(arr) / sizeof(arr[0]);//cmp_int是函数名实参传入函数名形参接收函数的类型Bubble_sort(arr, sz, sizeof(arr[0]), cmp_int);int i 0;for (i 0; i sz; i){printf(%d , arr[i]);}
}int main()
{/*test_1();*/test_2();return 0;
}9. 指针和数组笔试题解析 画图详解 对于指针来说类型只是一个环节最重要的是你要知道指针指向哪里。 总结
sizeof(数组名)这里的数组名表示整个数组计算的是整个数组的大小。数组名这里的数组名表示整个数组取出的是整个数组的地址。除此之外所有的数组名都表示首元素的地址。
10. 指针笔试题 输出结果
总结 当我们能学到这里的时候想必已经对指针了解的比较深入了纵观整个指针的学习过程中其实一直绕不开的就是指针类型最重要的也就是指针类型我们一直围绕的也就是指针类型。 其实指针就是一个指向或者是一个地址当不需要进行任何操作的时候就可以用void*替代但涉及到任何运算以及解引用操作权限都需要指针类型。 当我们能彻底搞清楚我们指针的类型的时候那么也就对解引用操作以及运算移动操作都将非常清晰让我们在底层的访问中无往不利。
本章完~
