【C语言】指针详解（2）
大家好，我是苏貝，本篇博客带大家了解指针(2)，如果你觉得我写的还不错的话，可以给我一个赞?吗，感谢❤️
文章目录
一. 字符指针
在指针的类型中我们知道有一种指针类型为字符指针 char* ，一般这样使用：
char ch = 'a';
char* p = &ch;
*p = 'w';
还有一种使用方式如下：
char* p = "abcdefg";
这是将一个字符串放到p指针变量里了吗？
不是的，指针变量p中存放的是字符串首字符的地址，也就是字符a的地址，能否简单的证明一下呢？
int main()
{
char* p = "abcdefg";
printf("%c", p[3]);
return 0;
}
答案：d。因为p中存放的是字符a的地址，p[3]==* (p+3)==d
还要注意：“abcdefg”是常量字符串，不能被修改，所以*p = ‘w’;是错误的，因此最好在char * p= “abcdefg”;之前加const
int main()
{
const char* p = "abcdefg";
//*p = 'w';//err
printf("%s", p);
return 0;
}
上面的了解清楚之后，我们来看下面的笔试题
#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 samen");
else
printf("str1 and str2 are not samen");
if (str3 == str4)
printf("str3 and str4 are samen");
else
printf("str3 and str4 are not samen");
return 0;
}
拓展：
数组名是数组首元素地址，除了以下2种情况：
（1）sizeof（数组名），此时的数组名代表整个数组，所以计算结果是整个数组的大小
（2）&数组名，此时的数组名也代表整个数组，取出的是整个数组的地址，返回的是数组首元素的地址
解析：if语句中str1和str2是数组str1和str2的首元素地址，在定义两个字符数组时，会开辟出不同的内存块，所以它们的首元素地址当然不同。因为“hello bit”是常量字符串，不能修改，所以没有必要用两块内存空间存储相同的常量字符串，因此C/C++会把常量字符串存储到单独的一个内存区域，当几个指针指向同一个字符串的时候，他们实际会指向同一块内存。
二 . 指针数组
我们知道，字符数组是存放字符类型的数组，整型数组是存放整型的数组，那么指针数组就当然是存放指针类型的数组，也就是说数组里面的元素都是指针类型的。指针数组可以写成如下形式：
int* arr[10];
[ ]的优先级高于 * ，所以arr先与[ ]结合成数组，数组有10个元素，元素的类型为int * 。那么指针数组有什么用呢？
2.1 模拟一个二维数组
下面代码的结果是打印arr1~arr3
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[] = { 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;
}
解析：
1.因为该代码中数组名是首元素地址，所以数组arr中存储的是arr1~arr3的首元素地址，所以类型为int *。
2.arr[i]是找到数组arr中第i个元素，如arr[1]就是找到第2个元素即数组arr2的首元素地址。arr[1][ j ]== *(arr[1]+j)，就是找到arr2的首元素地址后，再+j找到数组arr2中第j个元素
2.2 维护多个字符串
int main()
{
char* str[] = { "qing","dian","ge","zan","ba" };
int i = 0;
for (i = 0; i < 5; i++)
{
printf("%sn", str[i]);
}
return 0;
}
由上面的字符指针知，数组str存放的是字符串首字符的地址，所以结果为：
三 . 数组指针
我们知道，字符指针是指针，指向字符。整型指针是指针，指向整型。那么数组指针也是指针，指向的是数组。可以写成如下形式：
int arr[10]={0} ;
int (*p)[10]=&arr ;
*代表p为指针，因为[ ]的优先级高于 * ，所以为避免arr先与[ ]结合成数组，在 *p外面要加括号。[10]代表p指向的是数组，数组有10个元素，类型为int
注意：[ ]内一定要有数字，否则会报错
练习：指向下面指针数组的数组指针p该如何写呢？
char* arr[5];
先用 * 修饰p，代表p为指针，再将* p放在( )里，p指向的数组有5个元素，写成(*p)[5]，数组的类型为char * ，所以最后写成：
char* (*p)[5] = &str;
数组指针有什么用呢？
对二维数组进行传参时，我们一般会选择下面这种方法：（形参的数组[ ]中，行数可以不写，列数一定要写）
void print(int arr[][5], int row, int col)
{
int i = 0;
for (i = 0; i < row; i++)
{
int j = 0;
for (j = 0; j < col; 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;
}
但我们知道，数组传参本质上传的时数组首元素地址，所以可用指针来接收。之所以形参也可用数组的形式，是为了初学者能更好地理解。事实上，即便形参采用的是数组的形式，也不会真正创建一个数组。那我们如何用指针来接收二维数组呢？
在解决这一问题之前，我们要知道，二维数组是下面这样存储的
但是我们可以想象成下面这种3行5列的形式
二维数组作为实参，因为数组名为首元素地址，即第一行的地址{1，2，3，4，5}，所以用指针来接收时指针要指向第一行，又因为第一行有5个元素，所以指针是数组指针，如下：
void print(int(*p)[5], int row, int col)
{
int i = 0;
for (i = 0; i < row; i++)
{
int j = 0;
for (j = 0; j < col; j++)
{
printf("%d ", p[i][j]);
//p[i]=*(p+i)找到下标为i的行
//p[i][j]=*(*(p+i)+j)找到下标为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;
}
3.1 解释含义
学了指针数组和数组指针,让我们来一起回顾并看看下面代码的意思
int arr[5];
int *parr1[10];
int (*parr2)[10];
int (*parr3[10])[5]
解释：
1.arr是数组，数组有5个元素，元素的类型为int
2.parr1是数组，数组有10个元素，元素的类型为int*
3.parr2是数组指针，指向数组，数组有10个元素，元素的类型为int*
4.parr3是数组，是存放数组指针的数组，数组有10个元素，存放的这个数组指针指向的这个数组，有5个元素，元素的类型为int
四 . 数组参数、指针参数
在写代码的时候难免要把【数组】或者【指针】传给函数，那函数的参数该如何设计呢？
4.1 一维数组传参
#include <stdio.h>
void test(int arr[])//ok?
{}
void test(int arr[10])//ok?
{}
void test(int* arr)//ok?
{}
void test2(int* arr[20])//ok?
{}
void test2(int** arr)//ok?
{}
int main()
{
int arr[10] = { 0 };
int* arr2[20] = { 0 };
test(arr);
test2(arr2);
}
解析：
1.ok，用数组传参，可以用数组接收
2.ok，数组传参的本质是传首元素地址，事实上，即使形参写成数组形式，也不会真正创建一个数组，所以形参数组中[ ]里面的数字可写可不写，也可以写错，如写成10000
3.ok，数组传参的本质是传首元素地址，形参用一级指针接收
4.ok，用数组传参，可以用数组接收
5.ok，数组传参的本质是传首元素地址，形参用（*arr）代表是指针，指向数组首元素，元素类型为int *，所以形参为 int ** arr
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？
{}
void test(int** arr)//ok？
{}
int main()
{
int arr[3][5] = { 0 };
test(arr);
}
解析：
1.ok，用数组传参，可以用数组接收，行数可以不写，列数一定要写，因为对一个二维数组，可以不知道有多少行，但是必须知道一行多少元素。
2.no
3.ok
4.no，用指针来接收二维数组：二维数组的数组名是首元素地址，即可以想象成第一行的地址，每一行有5个元素。用指针来接收二维数组时，因为指向的是一行5个元素的地址，所以指针为数组指针，即 int(*arr)[5]
5.no
6.ok
7.no，二级指针是指向一级指针的，即二级指针存储的是一级指针的地址
4.3 一级指针传参
#include <stdio.h>
void print(int* p, int sz)
{
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%dn", *(p + i));
}
}
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 text(int* p)
{}
int main()
{
int a = 0;
int p = &a;
int arr[5] = { 0 };
text(&a);//传整型变量的地址
text(p);//传一级整型指针
text(arr);//传整型一维数组的数组名
return 0;
}
4.4 二级指针传参
#include <stdio.h>
void test(int** ptr)
{
printf("num = %dn", **ptr);
}
int main()
{
int n = 10;
int* p = &n;
int** pp = &p;
test(pp);
test(&p);
return 0;
}
思考：
当一个函数的参数部分为二级指针的时候，函数能接收什么参数？
void text(int** pp)
{}
int main()
{
int a = 0;
int* p = &a;
int** pp = &p;
int* arr[10] = { 0 };
text(&p);//传的是一级指针变量的地址
text(pp);//传的是二级指针变量
text(arr);//传的是int* 类型的一维数组的数组名
return 0;
}
五 . 函数指针
数组指针–指向数组的指针–存放的是数组的地址–&数组名就是数组的地址–数组名是首元素地址
函数指针–指向函数的指针–存放的是函数的地址–如何得到函数的地址呢？&函数名吗？
带着疑问，我们来看下面的代码
int Add(int x, int y)
{
return x + y;
}
int main()
{
printf("%pn", &Add);
printf("%pn", Add);
return 0;
}
因为&函数名==函数名，所以&函数名就是函数的地址，函数名也是函数的地址
那我们该如何写函数指针呢？以上面代码的函数Add为例
int (*p) (int, int)=&Add ;
int (*pp) (int, int)=Add ;
首先，用* 修饰p，表示p是个指针变量，再将* p放在( )中，在(*p)后面加( ),( )里面写函数的实参类型，最后在(*p)前写函数的返回类型
注意：*p必须放在( )里，否则因为( )的优先级高于 * ，p先与( )结合，即int * p (int, int)，这样就是函数声明
如何用函数指针调用函数？
1.使用 (*pf1)(2, 3)，因为pf1存放的是函数的地址，所以用 * 解引用找到该函数，再在( )里面写上对应的参数
2.使用 pf2(2, 3)，我们平时调用函数时，也只是用函数名+( )，例如：Add（）,因为pf2存放的是函数的地址，所以直接使用 pf2(2, 3)而不需要对pf2进行解引用
注意：因为pf1也是函数地址，所以 * 可写可不写，也可以写多个 * 。如果想使用 * 解引用，那么 *pf1必须放在( )中，否则先调用函数pf1(2,3)==5，然后执行 *5操作。
int Add(int x, int y)
{
return x + y;
}
int main()
{
int(*pf1)(int, int) = &Add;
int ret1 = (*pf1)(2, 3);
printf("%dn", ret1);
int(*pf2)(int, int) = Add;
int ret2 = pf2(2, 3);
printf("%dn", ret2);
return 0;
}
阅读两段有趣的代码
//代码1
(*(void (*)() )0 ) ();
//代码2
void (*signal(int, void(*)(int) ) )(int);
代码1：
我们以0为切入点，发现0前的( )内void ()( )是函数指针类型，( )内是类型，意思是强制类型转换，因为( )内是函数指针类型，所以0应该是地址而非数字，且0地址处的内容是函数。(void ( * )( ) ) 0前有 * ，意思是调用0地址处的函数，((void (*)() )0 ) 后面( )内无变量代表该函数无实参
代码2：
我们以signal函数为切入点，signal函数的参数有2个，第一个是int类型，第二个是函数指针类型，该函数指针指向的函数，参数是int，返回类型是void。发现缺失signal函数的返回类型，所以signal函数的返回类型也是函数指针类型，该函数指针指向的函数，参数是int，返回类型是void。所以这个代码是一次函数声明，声明的是signal函数。
我们发现该代码非常的复杂，能否简化一点呢？
//将void(*)(int)类型重命名为p_fun
//但不能写成typedef void(*)(int) p_fun;//err
typedef void(*p_fun)(int);//ok
p_fun signal(int, p_fun);
好了，那么本篇博客就到此结束了，如果你觉得本篇博客对你有些帮助，可以给个大大的赞?吗，感谢看到这里，我们下篇博客见❤️