目录
指针基本概念
在初阶指针中我们了解到一些指针的基本概念:
1.指针就是个变量，用来存放地址，地址唯一标识一块内存
2.指针的大小是固定的4/8个字节（32位/64位平台）
3指针是有类型的，指针的类型决定了指针的+整数的步长，指针解引用时操作的权限
例如，char*类型的指针解引用，它的权限（或步长）在32位平台下只有一个字节，而int*型的指针在32位平台下的权限（步长）为4个字节。
1.字符指针
#include<stdio.h>
int main()
{
char ch = 'w';
char* pc = &ch;
*pc = 'w';//这里的pc就是一个字符指针
return 0;
}这里的pc就是一个字符指针，可以通过解引用pc来对w进行操作。
#include<stdio.h>
int main()
{
char arr[]="abcdef";//数组内容为字符串
//char *p="abcdef";//指针存储的内容为字符串"abcdef"的首个字母的地址
const char *p="abcdef"；//abcdef为常量字符串，需要加const来修饰
return 0;
}这两个定义有什么区别， char arr[]='' abcdef''只是一个对数组普通的初始化，将字符串''abcdef''放数组arr中
char *p="abcdef"中，abcdef是常量字符串，其前面需要用const来修饰，那么第二个操作是不是直接将整个字符串保存在字符指针中了呢？答案是否定的。
该操作实际上是将常量字符串''abcdef''的首个字符的地址保存到字符指针*p中
而我们应该如何验证呢？
#include<stdio.h>
int main()
{
char arr[] = "abcdef";
const char* p = "abcdef";
printf("%s\n",p);
printf("%c",*p);
return 0;
}若此时p中存储的是字符串"abcdef"首字符的地址，那么第一个printf打印的结果应为"abcdef"
第二个printf中对字符指针p进行*解引用的结果应该是字符串首字符a。
于是我们得到了结论：该操作实际上是将常量字符串''abcdef''的首字符的地址保存到字符指针*p中
有这样一道面试题来练手，如下:
#include <stdio.h>
int main()
{
char str1[] = "hello bit.";
char str2[] = "hello bit.";
const char *str3 = "hello bit.";
const char *str4 = "hello bit.";
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;
} 
可以看到str1与str2是不相同的，而str3与str4是相同的，那么这究竟是什么原因呢？
char str1[] = "hello bit.";
char str2[] = "hello bit.";
两个数组的内容是相同的，但是开辟的并不是同一块空间 ，str1和str2都是数组名，代表了数组首元素的地址，而两个数分别开辟了不同的内存空间，所以首元素的地址不同，所以str1与str2不同而对于str3和str4，"hello bit."由const修饰，为常量字符串同时str3与str4都是字符指针，存储的是字符指针"hello bit."的首字符的地址，且其是由const修饰的常量字符串，故str3与str4指向的空间的地址相同，所以str3==str4；
2.指针数组
类比：
整型数组-存放整型的数组；
字符数组-存放字符的数组；
指针数组-存放指针的数组；
#include<stdio.h>
int main()
{
int* arr1[10];//整形指针的数组
char *arr2[4];//一级字符指针的数组
char **arr3[5];//二级字符指针的数组
return 0;
}使用指针数组模拟实现二维数组
#include<stdio.h>
int main()
{
int arr1[] = { 1,2,3,4,5 };
int arr2[] = { 2,3,4,5,6 };
int arr3[] = { 3,4,5,6,7 };
int* arr[3] = {arr1,arr2,arr3};
int i = 0;
for (i = 0; i < 3; i++)
{
int j = 0;
for (j = 0; j < 5; j++)
{
printf("%d", arr[i][j]);
}
printf("\n");
}
return 0;
}
用i遍历左边的数组，用j遍历右边的数组 ，结果如下图：
需要特别注意的是，指针数组模拟实现的二维数组与真正的二维数组不同的是，该指针数组中各元素地址的存放不一定是连续的。
3.数组指针
3.1数组指针概念
首先来做一个区分
整形指针-指向整型变量的指针，存放整型变量的地址的指针变量；
字符指针-指向字符变量的指针，存放字符变量的地址的指针变量；
数组指针-指向数组变量的指针，存放数组变量的地址的指针变量；
int*p1[10];//指针数组（p1先与[]结合）
int(*p2)[10];//数组指针（p2先与*运算符结合）p2是指针指向的是数组，称为数组指针变量。
3.2对数组名的理解
数组名是数组首元素的地址，但是有两个例外，如下
1.sizeof（数组名），这里的数组名不是数组首元素的地址，数组名此时表示整个数组，sizeof（数组名）计算是整个数组的大小，单位是字节。
2.&数组名，这里的数组名表示整个数组，&数组名取出的是整个数组的地址
除此之外，所有地方的数组名都是数组首元素的地址。
#include<stdio.h>
int main()
{
int arr[10]={0};
printf("%p\n",arr);
printf("%p\n",&arr[0]);
printf("%p\n",&arr);
return 0;
}
前两个输出都表示的是数组首元素的地址，而第三个应该表示的是整个数组的地址，但是我们可以观察到三者的输出结果是相同的，
#include<stdio.h>
int main()
{
int arr[10] = { 0 };
printf("%p\n", arr);
printf("%p\n", arr+1);
printf("%p\n", &arr[0]);
printf("%p\n", &arr[0]+1);
printf("%p\n", &arr);
printf("%p\n", &arr+1);
return 0;
}观察运行结果
前两个输出+1，都只跳过了4个字节，而第三个+1跳过了40个字节，正好是数组十个元素所占的字节数，由此可见 &数组名 代表的是整个数组的地址。
再观察下图，首元素的地址和数组的地址在占用内存的情况，更加证实了我们上面的说法。
3.3数组指针的使用
int(*p)[10]=&arr; 定义了一个数组指针，p的类型是int (*)[10]（但是在监视窗口中，显示的类型为int[10]*,这大概是编译器为了方便我们理解才这样写的吧），下面是数组指针的写法。
#include<stdio.h>
int main()
{
int(*p)[10]=&arr;
return 0;
}下面是一个使用数组指针打印二维数组的例子。
下面是打印二维数组的一种较为普通常见的写法：二维数组传参，形参是二维数组的形式
#include<stdio.h>
void Print(int arr[3][5], int r, int c)
{
int i = 0;
for (i = 0;i < 3; i++)
{
int j = 0;
for (j = 0; j < 5; j++)
{
printf("%d", arr[i][j]);
}
printf("\n");
}
}
int main()
{
int arr[3][5] = { 1,2,3,4,5,2,3,4,5,6,3,4,5,6,7 };
Print(arr,3,5);
return 0;
}首先，对于二维数组，我们可以这样来理解：二维数组的每一行可以理解为二维数组的一个元素，每一行又是一个一维数组，所以我们可以这样理解二维数组其实是一维数组的数组。除此之外，二维数组的数组名，代表的是首元素地址，而首元素为第一个一维数组，即为第一行的地址，也是第一行一维数组的地址
在学习数组指针之后，我们可以尝试二维数组传参，形参是指针的形式。 如下：
#include<stdio.h>
void Print(int (*p)[5], int r, int c)
{
int i = 0;
for (i = 0; i < r; i++)
{
int j = 0;
for (j = 0; j < c; j++)
{
printf("%d",*(*(p+i)+j));
}
printf("\n");
}
}
int main()
{
int arr[3][5] = { 1,2,3,4,5,2,3,4,5,6,3,4,5,6,7 };
//arr为二维数组的数组名，为首元素的地址，指针传参
Print(arr, 3, 5);
return 0;
}
对于这里的*(*(p+i)+j)进行分析，p为传参所传来的二维数组首元素的地址，也就是第一行一维数组的地址，在对其解引用*（p+i），相当于某一个一维数组的数组名，同时在用另外一个数j来对这个一维数组中的其他元素进行遍历获得他们的地址也就是*（p+i）+j,最后得到这个地址后在进行解引用即可获得二维数组中的所有元素*(*(p+i)+j)
一维数组传参，形参的部分可以是数组也可以是指针，同样二维数组传参的部分可以是数组也可以是指针，下面以二维数组为例：
#include<stdio.h>
void test1(char arr[3][5], int r, int c)
{}
void test2(char(*p)[5], int r, int c)
{}
int main()
{
char arr[3][5] = { 0 };
test1(arr, 3, 5);
test2(arr, 3, 5);
return 0;
}该二维数组为3行5列，指针传参的时候传过去的是第一行的地址，第一行有五个元素，故为
char(*p)[5]。 补充：（p[i]==*(p+i)）;
4.数组参数，指针参数
4.1一维数组传参
例子如下：
#include<stdio.h>
void test(int arr[]) {}//ok? ok
void test(int arr[10]){}//ok? ok
void test(int *arr){}//ok? ok
void test2(int *arr[20]){}//ok? ok
void test2(int **arr){}//ok? ok
int main()
{
int arr[10] = { 0 };
int* arr2[20] = { 0 };
test(arr);
test2(arr2);
return 0;
}重点讲解void test2(int **arr){}， arr2的类型是int *[20]，而arr2是一个指针，将int *类型的数据传过去，是一个二级指针，用int** arr接受，合理。
4.2二维数组传参
#include<stdio.h>
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? √
void test(int **arr) {}//ok? ×
int main()
{
int arr[3][5] = {0};
test(arr);
}二维数组的列是不能够省略的，传参过去后，可以用数组指针来接受，而不是指针数组。
最后一个，传参过去的是数组名，是一级指针，不能够用二级指针来接收。
1.当一个函数的参数部分为一级指针时，函数能接受什么参数？
void test(char *p){}
char ch='2';
char ptr=&ch;
char arr[]="abcdef";
test(&ch);
test(ptr);
test(arr);//传过去的参数为一级指针即可。
2.当函数的参数为二级指针时，可以接受什么参数？
void test(char** p){}
int n=10;
int *p=&n;
int **p=&p;
char* arr[5];
test(&p);
test(pp);
test(arr)
5.函数指针
5.1函数指针的概念
即为指向函数的指针。
int (*)(int,int)就是函数指针的类型
#include<stdio.h>
int Add(int x, int y)
{
return x + y;
}
int main()
{
int (*pf)(int,int)=&Add;//pf为函数指针
return 0;
}5.2对函数名的李姐
#include<stdio.h>
int Add(int x, int y)
{
return x + y;
}
int main()
{
printf("%p\n", &Add);
printf("%p\n", Add);
return 0;
}
函数名和&函数名的运算结果都是函数的地址。
5.3函数指针的使用
练习填写函数指针
给出test函数的定义，用pf表示test。
#include<stdio.h>
void test(char* pc, int arr[10])
{
}
int main()
{
void (*pf)(char*, int[10]) = &test;
return 0;
}函数名的用法
#include<stdio.h>
int Add(int x, int y)
{
return x + y;
}
int main()
{
int (*pf)(int, int) = Add;
int r = Add(3, 5);
printf("%d\n", r);
int m = (*pf)(4, 5);//int m=pf(4,5)也可以。
printf("%d\n", m);
}
int m = (*pf)(4, 5);也可以实现Add函数，那么是怎么实现的呢？
int (*pf)(int, int) = Add;首先将Add存在了pf中，这时*pf相当于函数名。
下面有两段interesting的代码
int main()
{
(*( void (*)() )0 )();
return 0;
}这一代码其实就是调用0地址处的函数。在调用前将0转换成了void(*)()类型的指针。
这一段代码是这样实现的：
1.将0强制类型转化为void(*)()类型的函数指针
2.调用0地址处的这个函数
第二段interesting的代码：
int main()
{
void(* signal(int,void(*)(int)) )(int);
}通过分析我们知道了signal是一个函数名，参数是int型和void(*)(int)函数指针类型。
void(* signal(int,void(*)(int)) )(int);
signal(int,void(*)int)) ，整个代码是一个函数指针，再看看去掉这一大块之后留下的内容
void(* )(int);就是上面内容的函数返回类型。
5.4小优化
#include<stdio.h>
typedef unsigned int uint;
typedef int* prt_t;
typedef int(*parr_t)[10];//错误的写法typedef int(*)[10]parr_t;
typedef int (*pf_t)(int, int);//此时pf_t就是这个函数指针的类型
int main()
{
uint u1;
prt_t p1;
int* p2;
return 0;
}再对上面signal函数进行小小优化：
#include<stdio.h>
typedef void(*pf_t)(int);
int main()
{
void(*signal(int, void(*)(int)))(int);
pf_t signal(int, pf_t);
return 0;
}可以看到啊，非常的简洁啊。
6.函数指针数组
函数指针存放在数组中。
小结
创作不易，留下你的赞可好？
693
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
