C语言指针

发表于 更新于 分类于 阅读次数： 阅读次数： 本文字数： 12k 阅读时长 ≈ 11 分钟
指针变量的定义和使用
定义指针变量

定义指针变量与定义普通变量非常类似，不过要在变量名前面加星号*，格式为：

1
datatype *name;
或者 
1
datatype *name = value;

*表示这是一个指针变量， datatype 表示该指针变量所指向的数据的类型 。例如：

1
int *p1;

p1 是一个指向 int 类型数据的指针变量，至于 p1 究竟指向哪一份数据，应该由赋予它的值决定。再如：

1
2
int a = 100;
int *p_a = &a;

在定义指针变量 p_a 的同时对它进行初始化，并将变量 a 的地址赋予它，此时 p_a 就指向了 a。值得注意的是，p_a 需要的一个地址， a 前面必须要加取地址符&，否则是不对的。 和普通变量一样，指针变量也可以被多次写入。

1
2
3
4
//定义普通变量 float a = 99.5, b = 10.6;
char c = '@', d = '#';
//定义指针变量 float *p1 = &a; char *p2 = &c;
//修改指针变量的值 p1 = &b; p2 = &d;

定义指针变量时必须带 *给指针变量赋值时不能带 *

假设变量 a、 b、 c、 d 的地址分别为 0X1000、 0X1004、 0X2000、 0X2004，下面的示意图很好地反映了 p1、 p2 指向的变化：

另外，p1、 p2 的类型分别是 float *和 char *，而不是 float 和 char，它们是完全不同的数据类型。

通过指针变量取得数据

指针变量存储了数据的地址，通过指针变量能够获得该地址上的数据，格式为：

1
*pointer;

这里的 * 称为指针运算符，用来取得某个地址上的数据，例如：

1
2
3
4
5
#include <stdio.h>
int main()
{ 
    int a = 15; int *p = &a; printf("%d, %d\n", a, *p); //两种方式都可以输出a的值 return 0; 
}

运行结果：
15, 15

假设变量 a、 p 的地址分别为 0X1000、 0XF0A0，它们的指向关系如下图所示：

程序被编译和链接后， a、 p 被替换成相应的地址。使用 *p 的话，要先通过地址 0XF0A0 取得变量 p 本身的值，这个值是变量 a 的地址，然后再通过这个值取得变量 a 的数据，前后共有两次运算；而使用 a 的话，可以通过地址 0X1000 直接取得它的数据，只需要一步运算。

那么，使用指针是间接获取数据，使用变量名是直接获取数据，前者比后者的代价要高。

另外，给指针变量本身赋值时不能加 *，例如：

1
2
3
int *p;
p = &a;
*p = 100;

指针变量也可以出现在普通变量能出现的任何表达式中，例如： 

1
2
3
4
5
int x, y, *px = &x, *py = &y;
y = *px + 5; //表示把x的内容加5并赋给y， *px+5相当于(*px)+5
y = ++*px; //px的内容加上1之后赋给y， ++*px相当于++(*px)
y = *px++; //相当于y=(*px)++
py = px; //把一个指针的值赋给另一个指针
关于 * 和 &的拓展

假设有一个 int 类型的变量 a， pa 是指向它的指针，那么* &a 和&* pa 分别是什么意思呢？

  • &a 可以理解为*(&a)， &a 表示取变量 a 的地址（等价于 pa）， *(&a)表示取这个地址上的数据（等价于 pa），绕来绕去，又回到了原点， * &a 仍然等价于 a。
    &     pa 可以理解为&(pa)， * pa 表示取得 pa 指向的数据（等价于 a）， &( pa)表示数据的地址（等价于 &a），所以&*pa 等价于 pa。
指针变量的运算

指针变量保存的是地址，而地址本质上是一个整数，所以指针变量可以进行部分运算，例如加法、减法、比较等，例如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <stdio.h>
int main(){
    int a = 10, *pa = &a, *paa = &a;
    double b = 99.9, *pb = &b;
    char c = '@', *pc = &c;
//最初的值
    printf("&a=%#X, &b=%#X, &c=%#X\n", &a, &b, &c);
    printf("pa=%#X, pb=%#X, pc=%#X\n", pa, pb, pc);
//加法运算
    pa++; pb++; pc++;
    printf("pa=%#X, pb=%#X, pc=%#X\n", pa, pb, pc);  
//减法运算
    pa -= 2; pb -= 2; pc -= 2;
    printf("pa=%#X, pb=%#X, pc=%#X\n", pa, pb, pc);
//比较运算
    if(pa == paa){
        printf("%d\n", *paa);
    }else{
        printf("%d\n", *pa);
    }
    return 0;
}

运行结果：

&a=0X62FDFC, &b=0X62FDF0, &c=0X62FDEF
pa=0X62FDFC, pb=0X62FDF0, pc=0X62FDEF
pa=0X62FE00, pb=0X62FDF8, pc=0X62FDF0
pa=0X62FDF8, pb=0X62FDE8, pc=0X62FDEE
4203849

从运算结果可以看出： pa、 pb、 pc 每次加 1，它们的地址分别增加 4、 8、 1，正好是 int、 double、 char 类型的长度；减 2 时，地址分别减少 8、 16、 2，正好是 int、 double、 char 类型长度的 2 倍 。

以 a 和 pa 为例， a 的类型为 int，占用 4 个字节， pa 是指向 a 的指针，如下图所示：

这个时候 pa 指向整数 a 的中间， *pa 使用的是橙色虚线画出的 4 个字节，其中前 3 个是变量 a 的，后面 1 个是其它数据的，把它们“搅和”在一起显然没有实际的意义，取得的数据也会非常怪异。
如果 pa++;使得地址加 4 的话，正好能够完全跳过整数 a，指向它后面的内存，如下图所示：

数组中的所有元素在内存中是连续排列的，如果一个指针指向了数组中的某个元素，那么加 1 就表示指向下一个元素，减 1 就表示指向上一个元素，这样指针的加减运算就具有了现实的意义。

但是，C 语言并没有规定变量的存储方式，如果连续定义多个变量，它们有可能是挨着的，也有可能是分散的，这取决于变量的类型、编译器的实现以及具体的编译模式，所以对于指向普通变量的指针，我们往往不进行加减运算，虽然编译器并不会报错，但这样做没有意义，因为不知道它后面指向的是什么数据。

数组指针（指向数组的指针）

数组（Array）是一系列具有相同类型的数据的集合，每一份数据叫做一个数组元素（Element）。数组中的所有元素在内存中是连续排列的，整个数组占用的是一块内存。以 int arr[] = { 99, 15, 100, 888, 252 };为例，该数组在内存中的分布如下图所示：

定义数组时，要给出数组名和数组长度，数组名可以认为是一个指针，它指向数组的第 0 个元素。 在 C 语言中，我们将第 0 个元素的地址称为数组的首地址。 以上面的数组为例，下图是 arr 的指向：

以指针的方式遍历数组元素为例：

1
2
3
4
5
6
7
8
9
10
11
#include <stdio.h>
int main(){
	int arr[] = {99,15,100,888,252 };
	int len = sizeof(arr) / sizeof(int); //求数组长度
	int i;
	for(i=0; i<len; i++){
		printf("%d ",*(arr+i)); //*(arr+i)等价于arr[i]
	}
	printf("\n");
	return 0;
}

运行结果：

99 15 100 888 252

第 5 行代码用来求数组的长度， sizeof(arr) 会获得整个数组所占用的字节数， sizeof(int) 会获得一个数组元素所占用的字节数，它们相除的结果就是数组包含的元素个数，也即数组长度。
第 8 行代码中我们使用了*(arr+i)这个表达式， arr 是数组名，指向数组的第 0 个元素，表示数组首地址， arr+i 指向数组的第 i 个元素， *(arr+i) 表示取第 i 个元素的数据，它等价于 arr[i]。

我们也可以定义一个指向数组的指针，例如： 

1
2
int arr[] = { 99, 15, 100, 888, 252 };
int *p = arr;

arr 本身就是一个指针，可以直接赋值给指针变量 p。 arr 是数组第 0 个元素的地址，所以 int *p = arr;也可以写作int *p = &arr[0];。也就是说， arr、 p、 &arr[0] 这三种写法都是等价的，它们都指向数组第 0 个元素，或者说指向数组的开头 。

引入数组指针后，我们就有两种方案来访问数组元素了，一种是使用下标，另外一种是使用指针。

(1) 使用下标
也就是采用 arr[i] 的形式访问数组元素。如果 p 是指向数组 arr 的指针，那么也可以使用 p[i] 来访问数组元素，它等价于 arr[i]。

(2) 使用指针
也就是使用 *(p+i) 的形式访问数组元素。另外数组名本身也是指针，也可以使用 *(arr+i) 来访问数组元素，它等价于 *(p+i)。

不管是数组名还是数组指针，都可以使用上面的两种方式来访问数组元素。不同的是，数组名是常量，它的值不能改变，而数组指针是变量（除非特别指明它是常量），它的值可以任意改变。也就是说，数组名只能指向数组的开头，而数组指针可以先指向数组开头，再指向其他元素。

关于数组指针的拓展

假设 p 是指向数组 arr 中第 n 个元素的指针，那么 *p++、 *++p、 (*p)++ 分别是什么意思呢？

*p++ 等价于 *(p++)，表示先取得第 n 个元素的值，再将 p 指向下一个元素。

*++p 等价于 * (++p)，会先进行 ++p 运算，使得 p 的值增加，指向下一个元素，整体上相当于 * (p+1)，所以会获得第 n+1 个数组元素的值。
(*p)++ 就非常简单了，会先取得第 n 个元素的值，再对该元素的值加 1。假设 p 指向第 0 个元素，并且第个元素的值为 99，执行完该语句后，第 0 个元素的值就会变为 100。

字符串指针

C 语言中没有特定的字符串类型，我们通常是将字符串放在一个字符数组中 ，例如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <stdio.h>
#include <string.h>
int main(){
char str[] = "wearexc.github.io";
	int len = strlen(str), i;
	//直接输出字符串
	printf("%s\n", str);
	//每次输出一个字符
	for(i=0; i<len; i++){
		printf("%c", str[i]);
	}
	printf("\n");
return 0;
}

运行结果：

wearexc.github.io

使用指针的方式来输出字符串： 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include <stdio.h>
#include <string.h>
int main(){
	char str[] = "wearexc.github.io";
	char *pstr = str;
	int len = strlen(str), i;  //strlen是计算数组的长度 
	//使用*(pstr+i)
	for(i=0; i<len; i++){
		printf("%c", *(pstr+i));
	}
	printf("\n");
	//使用pstr[i]
	for(i=0; i<len; i++){
		printf("%c", pstr[i]);
	}
	printf("\n");
	//使用*(str+i)
	for(i=0; i<len; i++){
		printf("%c", *(str+i));
	}
	printf("\n");
	return 0;
}

除了字符数组， C 语言还支持另外一种表示字符串的方法，就是直接使用一个指针指向字符串，例如：

1
char *str = "wearexc.github.io";

或者：

1
2
char *str;
str = "wearexc.github.io";

但需要注意的是，字符数组存储在全局数据区或栈区，第二种形式的字符串存储在常量区。全局数据区和栈区的字符串（也包括其他数据）有读取和写入的权限，而常量区的字符串（也包括其他数据）只有读取权限，没有写入权限。

二级指针（指向指针的指针）

如果一个指针指向的是另外一个指针，我们就称它为二级指针，或者指向指针的指针。

假设有一个 int 类型的变量 a， p1 是指向 a 的指针变量， p2 又是指向 p1 的指针变量，它们的关系如下图所示：

即：

1
2
3
int a =100;
int *p1 = &a;
int **p2 = &p1;

指针变量也是一种变量，也会占用存储空间，也可以使用&获取它的地址。 C 语言不限制指针的级数，每增加一级指针，在定义指针变量时就得增加一个星号 * 。 p1 是一级指针，指向普通类型的数据，定义时有一个 * ； p2 是二级指针，指向一级指针 p1，定义时有两个*。

如果我们希望再定义一个三级指针 p3，让它指向 p2，那么可以这样写：

1
int ***p3 = &p2;

四级指针也是类似的道理：

1
int ****p4 = &p3;

例如：

1
2
3
4
5
6
7
8
9
10
11
12
#include <stdio.h>
int main(){
    int a =100;
    int *p1 = &a;
    int **p2 = &p1;
    int ***p3 = &p2;
    printf("%d, %d, %d, %d\n", a, *p1, **p2, ***p3);
    printf("&p2 = %#X, p3 = %#X\n", &p2, p3);
    printf("&p1 = %#X, p2 = %#X, *p3 = %#X\n", &p1, p2, *p3);
    printf(" &a = %#X, p1 = %#X, *p2 = %#X, **p3 = %#X\n", &a, p1, *p2, **p3);
    return 0;
}

运行结果：

100, 100, 100, 100
&p2 = 0X62FE00, p3 = 0X62FE00
&p1 = 0X62FE08, p2 = 0X62FE08, *p3 = 0X62FE08
&a = 0X62FE14, p1 = 0X62FE14, *p2 = 0X62FE14, **p3 = 0X62FE14

以三级指针 p3 为例来分析上面的代码。 *p3 等价于( (*p3))。 *p3 得到的是 p2 的值，也即 p1 的地址； * (p3)得到的是 p1 的值，也即 a 的地址；经过三次“取值”操作后， * ( (*p3)) 得到的才是 a 的值。

指针数组（数组每个元素都是指针）

如果一个数组中的所有元素保存的都是指针，那么我们就称它为指针数组。指针数组的定义形式一般为：

1
dataType *arrayName[length];

[ ]的优先级高于*，该定义形式应该理解为：

1
dataType *(arrayName[length]);

括号里面说明 arrayName 是一个数组，包含了 le ngth 个元素，括号外面说明每个元素的类型为 dataType *。
除了每个元素的数据类型不同，指针数组和普通数组在其他方面都是一样的，下面是一个简单的例子： 

1
2
3
4
5
6
7
8
9
10
11
#include <stdio.h>
int main(){
    int a = 16, b = 932, c = 100;
    //定义一个指针数组
    int *arr[3] = {&a, &b, &c};//也可以不指定长度，直接写作 int *parr[]
    //定义一个指向指针数组的指针
    int **parr = arr;
    printf("%d, %d, %d\n", *arr[0], *arr[1], *arr[2]);
    printf("%d, %d, %d\n", **(parr+0), **(parr+1), **(parr+2));
    return 0;
}

运行结果：

16, 932, 100
16, 932, 100

arr 是一个指针数组，它包含了 3 个元素，每个元素都是一个指针，在定义 arr 的同时，我们使用变量 a、 b、 c 的地址对它进行了初始化，这和普通数组是多么地类似。

parr 是指向数组 arr 的指针，确切地说是指向 arr 第 0 个元素的指针，它的定义形式应该理解为 int *(parr)，括号中的表示 parr 是一个指针，括号外面的 int *表示 parr 指向的数据的类型。arr 第 0 个元素的类型为 int *，

所以在定义 parr 时要加两个 *。

第一个 printf() 语句中， arr[i] 表示获取第 i 个元素的值，该元素是一个指针，还需要在前面增加一个 * 才能取得它指向的数据，也即 *arr[i] 的形式。

第二个 printf() 语句中， parr+i 表示第 i 个元素的地址， *(parr+i) 表示获取第 i 个元素的值（该元素是一个指针），
**(parr+i) 表示获取第 i 个元素指向的数据。

二维数组指针（指向二维数组的指针）

二维数组在概念上是二维的，有行和列，但在内存中所有的数组元素都是连续排列的，它们之间没有“缝隙”。以下面的二维数组 a 为例：

1
int a[3][4] = { {0, 1, 2, 3}, {4, 5, 6, 7}, {8, 9, 10, 11} };

从概念上理解， a 的分布像一个矩阵：

1
2
3
0  1  2  3
4  5  6  7
8  9 10 11

但在内存中， a 的分布是一维线性的，整个数组占用一块连续的内存：

C 语言中的二维数组是按行排列的，也就是先存放 a[0] 行，再存放 a[1] 行，最后存放 a[2] 行；每行中的 4 个元素也是依次存放。数组 a 为 int 类型，每个元素占用 4 个字节，整个数组共占用 4×(3×4) = 48 个字节。
C 语言允许把一个二维数组分解成多个一维数组来处理。对于数组 a，它可以分解成三个一维数组，即 a[0]、 a[1]、a[2]。每一个一维数组又包含了 4 个元素，例如 a[0] 包含 a[0] [0]、 a[0] [1]、 a[0] [2]、 a[0] [3]。
假设数组 a 中第 0 个元素的地址为 1000，那么每个一维数组的首地址如下图所示：

为了更好的理解指针和二维数组的关系，我们先来定义一个指向 a 的指针变量 p：

1
int (*p)[4] = a;

括号中的 * 表明 p 是一个指针，它指向一个数组，数组的类型为 int [4]，这正是 a 所包含的每个一维数组的类型。

[ ]的优先级高于*， ( )是必须要加的，如果赤裸裸地写作 int *p[4]，那么应该理解为 int *(p[4])， p 就成了一个指针数组，而不是二维数组指针。
对指针进行加法（减法）运算时，它前进（后退）的步长与它指向的数据类型有关， p 指向的数据类型是 int [4]，那么 p+1 就前进 4×4 = 16 个字节， p-1 就后退 16 个字节，这正好是数组 a 所包含的每个一维数组的长度。也就是说， p+1 会使得指针指向二维数组的下一行， p-1 会使得指针指向数组的上一行。

那么，可以知道

(1) p 指向数组 a 的开头，也即第 0 行； p+1 前进一行，指向第 1 行。
(2) *(p+1)表示取地址上的数据，也就是整个第 1 行数据。注意是一行数据，是多个数据，不是第 1 行中的第 0 个元素。

例如：

1
2
3
4
5
6
7
#include <stdio.h>
int main(){
    int a[3][4] = { {0, 1, 2, 3}, {4, 5, 6, 7}, {8, 9, 10, 11} };
    int (*p)[4] = a;
    printf("%d\n", sizeof(*(p+1)));
    return 0;
}

运行结果：
16

(3) *(p+1)+1 表示第 1 行第 1 个元素的地址。如何理解呢？

*(p+1)单独使用时表示的是第 1 行数据，放在表达式中会被转换为第 1 行数据的首地址，也就是第 1 行第 0 个元素的地址，因为使用整行数据没有实际的含义，编译器遇到这种情况都会转换为指向该行第 0 个元素的指针；

就像一维数组的名字，在定义时或者和 sizeof、 & 一起使用时才表示整个数组，出现在表达式中就会被转换为指向数组第 0 个元素的指针。

(4) *( *(p+1)+1)表示第 1 行第 1 个元素的值。很明显，增加一个 * 表示取地址上的数据。
根据上面的结论，可以很容易推出以下的等价关系：

1
2
3
a+i == p+i
a[i] == p[i] == *(a+i) == *(p+i)
a[i][j] == p[i][j] == *(a[i]+j) == *(p[i]+j) == *(*(a+i)+j) == *(*(p+i)+j)
指针数组和二维数组指针的区别

指针数组和二维数组指针在定义时非常相似，只是括号的位置不同： 

1
2
int *(p1[5]); //指针数组，可以去掉括号直接写作 int *p1[5];
int (*p2)[5]; //二维数组指针，不能去掉括号

指针数组和二维数组指针有着本质上的区别：指针数组是一个数组，只是每个元素保存的都是指针，以上面的 p1为例，在 32 位环境下它占用 4×5 = 20 个字节的内存。二维数组指针是一个指针，它指向一个二维数组，以上面的 p2 为例，它占用 4 个字节的内存。

函数指针（指向函数的指针）

一个函数总是占用一段连续的内存区域，函数名在表达式中有时也会被转换为该函数所在内存区域的首地址，这和数组名非常类似。我们可以把函数的这个首地址（或称入口地址）赋予一个指针变量，使指针变量指向函数所在的内存区域，然后通过指针变量就可以找到并调用该函数。这种指针就是函数指针。
函数指针的定义形式为： 

1
returnType (*pointerName)(param list);

returnType 为函数返回值类型， pointerNmae 为指针名称， param list 为函数参数列表。参数列表中可以同时给出参数的类型和名称，也可以只给出参数的类型，省略参数的名称，这一点和函数原型非常类似。
注意( )的优先级高于*，第一个括号不能省略，如果写作 returnType *pointerName(param list);就成了函数原型，它表明函数的返回值类型为 returnType *。

例如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <stdio.h>
//返回两个数中较大的一个
int max(int a, int b){
    return a>b ? a : b;
}
int main(){
    int x, y, maxval;
    //定义函数指针
    int (*pmax)(int, int) = max; //也可以写作int (*pmax)(int a, int b)
    printf("Input two numbers:");
    scanf("%d %d", &x, &y);
    maxval = (*pmax)(x, y);
    printf("Max value: %d\n", maxval);  
    return 0;
}

运行结果：
Input two numbers:10 50↙
Max value: 50

第 14 行代码对函数进行了调用。 pmax 是一个函数指针，在前面加 * 就表示对它指向的函数进行调用。注意( )的优先级高于*，第一个括号不能省略。

对 C 语言指针的总结

指针（Pointer）就是内存的地址， C 语言允许用一个变量来存放指针，这种变量称为指针变量。指针变量可以存放基本类型数据的地址，也可以存放数组、函数以及其他指针变量的地址。

程序在运行过程中需要的是数据和指令的地址，变量名、函数名、字符串名和数组名在本质上是一样的，它们都是地址的助记符：在编写代码的过程中，我们认为变量名表示的是数据本身，而函数名、字符串名和数组名表示的是代码块或数据块的首地址；程序被编译和链接后，这些名字都会消失，取而代之的是它们对应的地址。

常见指针变量的定义

定 义 含 义
int *p; p 可以指向 int 类型的数据，也可以指向类似 int arr[n] 的数组。
int **p; p 为二级指针，指向 int * 类型的数据。
int *p[n]; p 为指针数组。 [ ] 的优先级高于 *，所以应该理解为 int *(p[n]);