目录
先回顾上节的几个结论
//数组名存的是第一个元素的地址，有两个例外：
//sizeof(数组名)计算的是整个数组的大小
//&数组名取出来的是整个数组的地址。
//数组传参传的是首元素的地址
二级指针
//指针变量也是变量，和普通变量不同的是它存放了地址
int main()
{
int a = 10;
int* p = &a;
//一级指针：p是指针变量，*告诉我们p是存放了地址的变量（也就是指针变量），int告诉我们p指向的那个对象的类型是int，
//一级指针的指针类型是int*
int** pp = &p;
//二级指针：pp是指针变量，靠近p的那个*是告诉我们pp是存放了地址的变量（也就是指针变量），
//而前面的int*组合起来告诉我们pp存的是p的地址，而pp指向的是p,所以指向的是对象是个指针，而不是一个值，所以类型是指针类型int*
//二级指针的指针类型是int**
int*** ppp = &pp;
//三级指针：ppp是指针变量，靠近p的那个*告诉我们ppp是存放了地址的变量（也就是指针变量），
//而ppp指向的对象是个二级指针，二级指针的类型是int**
//三级指针用的很少
//*p解引用通过a的地址找到a的值
//*pp解引用找到p的地址
//**pp解引用找到p的地址，而p里面存放的是a的地址，最后通过a的地址找到a的值
printf("%d\n", **pp);
//二级指针变量是用来存放一级指针变量的地址
return 0;
}指针数组
//指针数组是指针还是数组？
//本质是数组：
// 比如
//int arr[10] 整型数组，数组中的每个元素是整型类型int
//int* arr[10]指针数组，数组中的每个元素是整形指针，类型是int*
//指针数组模拟二维数组
//模拟出二维数组的效果，但是不是二维数组！
int main()
{
int arr1[5] = { 1,2,3,4,5 };
int arr2[5] = { 2,3,4,5,6 };
int arr3[5] = { 3,4,5,6,7 };
int* arr[3] = { arr1,arr2,arr3 };//整型指针数组
int i = 0;//控制arr数组元素的下标
for (i = 0; i < 3; i++)
{
int j = 0;//控制arr1_3数组的下标
for (j = 0; j < 5; j++)
{
printf("%d ", arr[i][j]);//arr[i][j]==*(*(arr+i)+j)
}
printf("\n");
}
return 0;
}int main()
{
int arr[10] = { 0,1,2,3,4,5,6,7,8,9 };
int i = 0;
for (i = 0; i < 10; i++)
{
//printf("%d ", arr[i]);
printf("%d ", *(arr + i));//arr[i]==*(arr + i)
}
return 0;
}字符指针变量
int main()
{
//char ch='w';
//char*pc=&ch;
const char* p ="abcdef";//不是把字符串abcdef\0存放在p中，而是把第一个字符的地址存放在p中
//1.可以把字符串想象成一个字符数组（名），但是这个数组是不能修改的
//可以通过p存放的地址来访问里面的内容，但是不能改里面的内容
//比如
//p[3] = 'q';//编译器报错,为了防止这种现象发生，最好在char*p前加上const修饰变成常量字符串指针，这样一旦想改时，编译器就是提示
printf("%c\n", *p);
//2.当常量字符串出现在表达式中的时候，他的值是第一个字符的地址
printf("%c\n", "abcdef"[3]);//类似数组名存放的是第一个元素的地址，后面[数组元素个数]：arr[3]
//也可以这样写
printf("%c\n", p[3]);//因为p中存放的是首字符的地址，也类似数组名存放的是第一个元素的地址，后面[数组元素个数]：arr[3]
printf("%c\n", *(p+3));
return 0;
}//判断以下代码是否一样？
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");//not same
//两个数组是不同的数组，开辟了不同的空间，所以str1保存的h地址和str2是不一样的
if (str3 == str4)
printf("str3 and str4 are same\n");//are same
//从内存的利用率的角度来讲，常量字符串空间创建一份就够了，不用改变，没必要重复创建内存空间
else
printf("str3 and str4 are not same\n");
return 0;
}数组指针变量
//整形指针变量： int * pint; 存放的是整形变量的地址，能够指向整形数据的指针。
//浮点型指针变量： float* pf; 存放浮点型变量的地址，能够指向浮点型数据的指针。
//数组指针变量应该是：存放的应该是数组的地址，能够指向数组的指针变量。
//指针的*号的位置怎么放？跟int放在一起和跟数组名放在一起有什么区别？
//数组指针和指针数组有什么区别？
//int* p1[10];//这样的写法可以理解为p1是数组，里面有10个元素，每个元素的类型是int*,所以p1属于指针数组
//int (*p2)[10];//加上括号，让*号和数组名结合，这样的写法可以理解为*告诉我们p2是指针，
//指针所指向的对象是数组，数组有10个元素，每一个元素的类型是int，p2是指向数组的指针，p2属于数组指针
int main()
{
int a =10;
int* pa = &a;//取出来a的地址，pa指向的对象是整型，所以是整型指针
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
int(*parr)[10] = &arr;//取出的是数组的地址
//parr就是数组指针
//数组指针的类型是int(*)[10]//去掉数组名就是指针的类型
return 0;
}
int main()
{
int arr[0] = {1,2,3,4,5,6,7,8,9,10};
int* p1 = arr;
//指针类型：
// int* int*
int* p2 = &arr[0];
// int* int*
int(*p3)[10] = &arr;//数组指针，后面加[]
//int(*)[10] int(*)[10]
return 0;
}数组指针怎么访问？
int main()
{
int arr[10] = { 0,1,2,3,4,5,6,7,8,9 };
//指针访问数组
int*p= arr;
int i = 0;
int sz = sizeof(arr) / sizeof(int);
for (i = 0; i < sz; i++)
{
printf("%d ", *(p+i));
}
return 0;
}int main()
{
int arr[10] = { 0,1,2,3,4,5,6,7,8,9 };
//指针访问数组
int(*p)[10] = &arr;
int i = 0;
int sz = sizeof(arr) / sizeof(int);
for (i = 0; i < sz; i++)
{
printf("%d ", (*p)[i]);//不是所有场景都用，有特定的使用场景
}
//p == &arr;
//*p == *&arr==arr;
return 0;
}数组指针的应用场景:
//二维数组传参的本质
//void print(int arr[3][5], int r, int c)
//也可以写成指针形式：
void print(int(*arr)[5], int r, int c)
//第一行的一维数组的类型就是int[5],所以第一行的地址的类型就是数组指针类型int(*)[5]
{
int i = 0;
for (i = 0; i < r; i++)
{
int j = 0;
for (j = 0; j < c; j++)
{
//printf("%d ", arr[i][j]);
printf("%d ", *(*(arr+i)+j));
//*(arr + i)==arr[i]
//arr + i就是指向下标为i行的地址
//解引用后相当于拿到下标为i行的数组名，存放的是下标为i行的首元素的地址（起始位置），
//+j后就拿到该行下标为j的元素的地址
//再解引用后找到下标为j的元素
}
printf("\n");
}
}
int main()
{
int arr[3][5] = { {0,1,2,3,4},{6,7,8,9,10},{1,2,3,7,8} };
print(arr, 3, 5);//3行，5列
return 0;
}
//类比：
//一维数组传参，形参可以是数组，也可以是指针
//为什么？
//1.写成数组更加直观，为了方便理解；
//2.写成指针是因为数组传参，传递的是数组第一个元素的地址；
//int arr[10];
//test1(arr,10);//传10个元素过去
//接收void test1(int arr[10],int sz)
//或者接收void test2(int*arr，int sz)
//总结：
//二维数组传参，形参也可以写的是二维数组；直观，容易理解
//二维数组传参，形参也可以写成指针,数组名都是首元素的地址
//二维数组其实是元素为一维数组的数组
//对于二维数组来说，首元素其实是第一行，首元素的地址就是第一行的地址，
//而第一行的地址形式上指向的是第一行首元素的地址，但实则在运算时是整个第一行的地址，
//如果让数组+1，地址会跳到第二行的地址，而不是调到第一行的第二个元素的地址
//那二维数组传参时，写成指针形式是怎么的？
//传：print(arr, 3, 5)
//收：print(int(*arr)[5],int r, int c)//用数组指针接收
函数指针变量
//函数指针变量的创建
int Add(int x, int y)
{
return x + y;
}
int main()
{
int a = 10;
int* pa = &a;//整型指针
int arr[10] = { 0 };
int(*parr)[10] = &arr;//数组指针
printf("%p\n", &Add);
printf("%p\n", Add);
//函数指针变量 是用来存放函数的地址的
数组名--数组首元素的地址
//&数组名--整个数组的地址
//
//函数名？--函数的地址
//&函数名？--函数的地址
//函数function
int (*pf1)(int, int) = &Add;//pf就是函数指针变量,后面只需要交代清楚函数参数的类型即可
//加括号后，*号告诉我们pf是存放了函数地址的变量（指针），而pf指向的函数的参数是int类型，返回类型是int
//int (*)(int, int)是函数指针的类型
//如果不加括号int* pf(int, int) = &Add;
//那么pf是函数名，函数的返回值类型是int*
//通过函数指针调用函数
int ret = Add(3, 5);//函数名是地址
printf("%d\n", ret);
int ret2 = (*pf1)(4, 9);//可以不写*
// pf指向Add那个函数（存放了Add的地址），解引用后找到那个函数
// 找到之后传参4和9
printf("%d\n", ret2);//13
int(*pf2)(int, int) = Add;
int ret3 = (*pf2)(5, 6);//可以不写*
printf("%d\n", ret3);
int ret4 = pf2(5, 6);//变量不解引用，也相当于函数名，存放的是地址
printf("%d\n", ret3);
//注意，切不可写成*pf2(5,6)，一定要先解引用完后再去调
return 0;
}
练习：创建函数指针变量
char* test(int a, char c)
{
//...
return NULL;
}
int main()
{
char* (*pt)(int, char) = test;
//pt是个指针，指向的函数是int, char
//注意返回值类型是char*，而不是char
return 0;
}练习：解释以下代码
int main()
{
(*(void(*)())0)();
//void(*)()是个函数指针类型，存放了函数地址的指针
//（void(*)()）0 将int类型的0强制转换成void(*)()类型（换成一个函数的地址），类似(int)3.14,(int*)0x00567823
//*(（void(*)()）0)解引用后找到函数，这个函数没有参数，返回值类型void
//(*(（void(*)()）0))()调用0地址处的函数，没有传参
//总的来说，这段代码是一次函数调用
return 0;
}void(*signal(int, void(*)(int)))(int);
//signal(int, void(*)(int))
//函数signal后面的是两个参数类型，第一个参数类型是int,
//第二个参数是函数指针类型void(*)(int)，该指针指向的函数参数是int,返回类型是void
//signal函数的返回类型是这种类型的void(*)(int)函数指针
//该指针指向的函数参数是int,返回类型是void
//总的来说，上述代码是函数声明
int main()
{
return 0;
}typedef关键字
作用是重命名，简化
//重命名整型类型
typedef unsigned int uint;
//也可以用来重命名指针类型
//int(*pa)[10]--int(*)[10]
typedef int(* pArr_t)[10];//数组指针重命名不是放在原名后面的，而是放在*号后面
//重命名函数指针类型
//int(*pf)(int, int);--int(*)(int, int)
typedef int(*pf_t)(int, int);
int main()
{
unsigned int num;
uint num2;
int(*pb)[10];
pArr_t pa;//pa是个数组指针变量
pf_t pf;//pf是个函数指针变量
return 0;
}
再简化一下这串代码：
//简化一下void(*signal(int, void(*)(int)))(int);
//指针类型void(*)(int)
typedef void(*pf_t)(int);
//那么void(*signal(int, void(*)(int)))(int)可以简化为
pf_t signal(int, pf_t);
//signal中的第二个参数的类型是pf_t类型的
//signal的返回值类型也是pf_t类型的预知后事如何，请听下回分解......
207
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
