【C】语言指针（指针数组字符、函数、数组指针）等-CSDN博客

#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*的，就可以存放在parr数组中
 int* parr[3] = {arr1, arr2, arr3};
 int i = 0;
 int j = 0;
 for(i=0; i<3; i++)
 {
 for(j=0; j<5; j++)
 {
 printf("%d ", parr[i][j]);
 }
 printf("\n");
 }
 return 0;
}

parr[i]是访问parr数组的元素，parr[i]找到的数组元素指向了整型⼀维数组，parr[i][j]就是整型⼀维数组中的元素。

上述的代码模拟出⼆维数组的效果，实际上并⾮完全是⼆维数组，因为每⼀⾏并⾮是连续的。

简单的解释图：

二、字符指针变量

在指针的类型中我们知道有⼀种指针类型为字符指针 char* ;

⼀般使⽤:

int main()
{
 char ch = 'w';
 char *pc = &ch;//pc就是字符指针
 *pc = 'w';
 return 0;
}

还有⼀种使⽤⽅式如下：

int main()
{
 const char* pstr = "hello bit.";//这⾥是把⼀个字符串放到pstr指针变量⾥了吗？
 printf("%s\n", pstr);
 return 0;
}

代码 const char* pstr = "hello bit."; 特别容易让同学以为是把字符串 hello bit 放

到字符指针 pstr ⾥了，但是本质是把字符串 hello bit. ⾸字符的地址放到了pstr中。

上⾯代码的意思是把⼀个常量字符串的⾸字符 h 的地址存放到指针变量 pstr 中。

举例：

char* p ="abcdef";

//不是把字符串abcdef\0存放在p中，而是把第一个字符的地址存放在p中

//printf("%c n"，*p);

1.你可以把字符串想象为一个字符数组

但是要注意：

//p[3] ='q';//err

不可以更改值；常量字符串内容不能更改

const char* p ="abcdef";

//不是把字符串abcdef\@存放在p中，而是把第一个字符的地址存放在p中

printf("%c\n"，*p);

1.你可以把字符串想象为一个字符数组，但是这个数组是不能修改的

2.当常量字符串出现在表达式中的时候，他的值是第一个字符的地址

《剑指offer》中收录了⼀道和字符串相关的笔试题，我们⼀起来学习⼀下：

#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指向的是⼀个同⼀个常量字符串。C/C++会把常量字符串存储到单独的⼀个内存区域，当⼏个指针指向同⼀个字符串的时候，他们实际会指向同⼀块内存。但是⽤相同的常量字符串去初始化不同的数组的时候就会开辟出不同的内存块。所以str1和str2不同，str3和str4相同。

三、数组指针变量

1. 数组指针变量是什么？

之前我们学习了指针数组，指针数组是⼀种数组，数组中存放的是地址（指针）。

数组指针变量是指针变量？还是数组？

答案是：指针变量。

类比一下：

• 整形指针变量： int * pint; 存放的是整形变量的地址，能够指向整形数据的指针。

• 浮点型指针变量： float * pf; 存放浮点型变量的地址，能够指向浮点型数据的指针。

那数组指针变量应该是：存放的应该是数组的地址，能够指向数组的指针变量。

下⾯代码哪个是数组指针变量？

int *p1[10];
int (*p2)[10];

p1是数组，数组10个元素，每个元素的类型是int*，所以p1是指针数组。

p2是指针，指针指向的是数组，数组有10个元素，每个类型都是int

p2是指向数组的指针，数组指针。

数组指针变量：

int (*p)[10];

解释： p先和*结合，说明p是⼀个指针变量变量，然后指着指向的是⼀个⼤⼩为10个整型的数组。所以 p是⼀个指针，指向⼀个数组，叫数组指针。

这⾥要注意：[]的优先级要⾼于*号的，所以必须加上（）来保证p先和*结合。

我们再延伸一下：

i nt*p1=arr； //int*

int*p2=&arr[0]； //int*

int(*p3)[10]=&arr； //int(*)[10]

2. 数组指针变量怎么初始化

int arr[10] = {0};
&arr;//得到的就是数组的地址

如果要存放个数组的地址，就得存放在数组指针变量中，如下：

int(*p)[10] = &arr;

调试也能看到 &arr 和 p 的类型是完全⼀致的。

数组指针类型解析:

int (*p) [10] = &arr;
 | | |
 | | |
 | | p指向数组的元素个数
 | p是数组指针变量名
 p指向的数组的元素类型

我们延伸一下：

*p==*&arr==arr；

print("%d "，(*p)[i])；

3. 一维数组传参，形参可以是数组，也可以是指针，为什么？

• 1.学成数组更加直观，为了方便理解。

• 2.写成指针是因为数组传参，传递的是数组第一个元素的地址。

4. ⼆维数组传参的本质

• 1.二维数组传参，形参写成数组，也是可以的，非常直观，容易理解

• 2.形参也可以写成指针

我们讲⼀下⼆维数组传参的本质。

过去我们有⼀个⼆维数组的需要传参给⼀个函数的时候，我们是这样写的：

1 #include <stdio.h>
2
3 void test(int a[3][5], int r, int c)//这里int a[3][5]，可以写还曾int（*arr）[5]，
4 {                                   //二维数组传参，形参写的是二维数组
5 int i = 0;
6 int j = 0;
7 for(i=0; i<r; i++)//行
8 {
9 for(j=0; j<c; j++)//；列
10 {
11 printf("%d ", a[i][j]);//这里a[i][j]可以写成*（*（arr+i）+j）
12 }
13 printf("\n");
14 }
15 }
16 int main()
17 {
18 int arr[3][5] = {{1,2,3,4,5}, {2,3,4,5,6},{3,4,5,6,7}};
19 test(arr, 3, 5);
20 return 0;
21 }

我们解释一下：

*（arr+i)==arr[i]

如果我们把二维数组的每一行理解成一维数组这个一维数组他们的名字分别表示

数组名：第一行arr[0],第二行arr[1],第三行arr[2]

而数组名又相当于首元素地址

【二维数组其实元素是一维数组的数组；对应二维数组，首元素其实是第一行数组地址】

所以，根据数组名是数组⾸元素的地址这个规则，⼆维数组的数组名表⽰的就是第⼀⾏的地址，是⼀维数组的地址。根据上⾯的例⼦，第⼀⾏的⼀维数组的类型就是 int [5] ，所以第⼀⾏的地址的类型就是数组指针类型 int(*)[5] 。那就意味着⼆维数组传参本质上也是传递了地址，传递的是第⼀

⾏这个⼀维数组的地址，那么形参也是可以写成指针形式的。如下：

 #include <stdio.h>

 void test(int (*p)[5], int r, int c)
 {
 int i = 0;
 for(i=0; i<r; i++)
 {
 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}};
 test(arr, 3, 5);
 return 0;
}

总结：⼆维数组传参，形参的部分可以写成数组，也可以写成指针形式

四、函数指针变量

1. 函数指针变量的创建

根据整型指针，数组指针，我们类⽐关系

得出结论：

函数指针变量应该是⽤来存放函数地址的，未来通过地址能够调⽤函数的。

数组名---数组首元素的地址

&数组名---整个数组的地址

函数名和&函数名一样，都是函数的地址

函数是否有地址呢？

我们做个测试：

#include <stdio.h>
void test()
{
 printf("hehe\n");
}
int main()
{
 printf("test: %p\n", test);
 printf("&test: %p\n", &test);
 return 0;
}

输出结果如下：

test: 005913CA
&test: 005913CA

所以函数是有地址的，函数名就是函数的地址，当然也可以通过 &函数名的方式 获得函数的地址。

如果我们要将函数的地址存放起来，就得创建函数指针变量咯， 函数指针变量的写法其实和数组指针⾮常类似。

如下：

void test()
{
 printf("hehe\n");
}
void (*pf1)() = &test;
void (*pf2)()= test;
int Add(int x, int y)
{
 return x+y;
}
int(*pf3)(int, int) = Add;
int(*pf3)(int x, int y) = &Add;//x和y写上或者省略都是可以的

函数指针类型解析：

int (*pf3) ( int x, int y)

| | ------------

| | |

| | pf3 指向函数的参数类型和个数的交代

| 函数指针变量名

pf3 指向函数的返回类型

int (*) ( int x, int y) //pf3 函数指针变量的类型

2. 函数指针变量的使用

通过函数指针调⽤指针指向的函数。

1：

#include <stdio.h>
int Add(int x, int y)
{
 return x+y;
}
int main()
{
 int(*pf3)(int, int) = Add;//也可以&add
 
 printf("%d\n", (*pf3)(2, 3));//
 printf("%d\n", pf3(3, 5));//和上一行效果相同
 return 0;
}

2：

3. 两段有趣的代码

1代码： 1 ((void ()())0)(); 【C】语言指针（3）（4）回放

2代码： 1 void (signal(int , void()(int)))(int);

********两段代码均出⾃：《C陷阱和缺陷》这本书**********

五 typedef关键字

typedef 是⽤来类型重命名的 ，可以将复杂的类型，简单化。

⽐如，你觉得 unsigned int 写起来不⽅便，如果能写成 uint 就⽅便多了，那么我们可以使⽤：

typedef unsigned int uint;
//将unsigned int 重命名为uint

如果是 指针类型 ，能否重命名呢？其实也是可以的，⽐如，将 int* 重命名为 ptr_t ,这样写：

typedef int* ptr_t;

但是对于 数组指针 和 函数指针稍微有点区别 ：

⽐如我们有 数组指针类型 int(*)[5] ,需要重命名为 parr_t ，那可以这样写：

typedef int (* parr_t )[5]; //新的类型名必须在*的右边

函数指针类型 的重命名也是⼀样的，⽐如，将 void(*)(int) 类型重命名为 pf_t ,就可以这样写：

typedef void (* pfun_t )( int ) ;//新的类型名必须在*的右边

那么要简化代码2，可以这样写：

typedef void(*pfun_t)(int);
pfun_t signal(int, pfun_t);

【C】语言 指针（指针数组 字符、函数、数组指针）等

一、指针数组

1.指针数组模拟⼆维数组