C语言指针

指针变量的定义和使用
定义指针变量

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

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]);