C语言指针
指针变量的定义和使用
定义指针变量
定义指针变量与定义普通变量非常类似,不过要在变量名前面加星号*,格式为:
1 | datatype *name; |
1 | datatype *name = value; |
*表示这是一个指针变量, datatype 表示该指针变量所指向的数据的类型 。例如:
1 | int *p1; |
p1 是一个指向 int 类型数据的指针变量,至于 p1 究竟指向哪一份数据,应该由赋予它的值决定。再如:
1 | int a = 100; |
在定义指针变量 p_a 的同时对它进行初始化,并将变量 a 的地址赋予它,此时 p_a 就指向了 a。值得注意的是,p_a 需要的一个地址, a 前面必须要加取地址符&,否则是不对的。 和普通变量一样,指针变量也可以被多次写入。
1 | //定义普通变量 float a = 99.5, b = 10.6; |
定义指针变量时必须带 *给指针变量赋值时不能带 *
假设变量 a、 b、 c、 d 的地址分别为 0X1000、 0X1004、 0X2000、 0X2004,下面的示意图很好地反映了 p1、 p2 指向的变化:

另外,p1、 p2 的类型分别是 float *和 char *,而不是 float 和 char,它们是完全不同的数据类型。
通过指针变量取得数据
指针变量存储了数据的地址,通过指针变量能够获得该地址上的数据,格式为:
1 | *pointer; |
这里的 * 称为指针运算符,用来取得某个地址上的数据,例如:
1 |
|
运行结果:
15, 15
假设变量 a、 p 的地址分别为 0X1000、 0XF0A0,它们的指向关系如下图所示:

程序被编译和链接后, a、 p 被替换成相应的地址。使用 *p 的话,要先通过地址 0XF0A0 取得变量 p 本身的值,这个值是变量 a 的地址,然后再通过这个值取得变量 a 的数据,前后共有两次运算;而使用 a 的话,可以通过地址 0X1000 直接取得它的数据,只需要一步运算。
那么,使用指针是间接获取数据,使用变量名是直接获取数据,前者比后者的代价要高。
另外,给指针变量本身赋值时不能加 *,例如:
1 | int *p; |
指针变量也可以出现在普通变量能出现的任何表达式中,例如:
1 | int x, y, *px = &x, *py = &y; |
关于 * 和 &的拓展
假设有一个 int 类型的变量 a, pa 是指向它的指针,那么* &a 和&* pa 分别是什么意思呢?
- &a 可以理解为*(&a), &a 表示取变量 a 的地址(等价于 pa), *(&a)表示取这个地址上的数据(等价于 pa),绕来绕去,又回到了原点, * &a 仍然等价于 a。
& pa 可以理解为&(pa), * pa 表示取得 pa 指向的数据(等价于 a), &( pa)表示数据的地址(等价于 &a),所以&*pa 等价于 pa。
指针变量的运算
指针变量保存的是地址,而地址本质上是一个整数,所以指针变量可以进行部分运算,例如加法、减法、比较等,例如:
1 |
|
运行结果:
&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 |
|
运行结果:
99 15 100 888 252
第 5 行代码用来求数组的长度, sizeof(arr) 会获得整个数组所占用的字节数, sizeof(int) 会获得一个数组元素所占用的字节数,它们相除的结果就是数组包含的元素个数,也即数组长度。
第 8 行代码中我们使用了*(arr+i)这个表达式, arr 是数组名,指向数组的第 0 个元素,表示数组首地址, arr+i 指向数组的第 i 个元素, *(arr+i) 表示取第 i 个元素的数据,它等价于 arr[i]。
我们也可以定义一个指向数组的指针,例如:
1 | int arr[] = { 99, 15, 100, 888, 252 }; |
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 |
|
运行结果:
wearexc.github.io
使用指针的方式来输出字符串:
1 |
|
除了字符数组, C 语言还支持另外一种表示字符串的方法,就是直接使用一个指针指向字符串,例如:
1 | char *str = "wearexc.github.io"; |
或者:
1 | char *str; |
但需要注意的是,字符数组存储在全局数据区或栈区,第二种形式的字符串存储在常量区。全局数据区和栈区的字符串(也包括其他数据)有读取和写入的权限,而常量区的字符串(也包括其他数据)只有读取权限,没有写入权限。
二级指针(指向指针的指针)
如果一个指针指向的是另外一个指针,我们就称它为二级指针,或者指向指针的指针。
假设有一个 int 类型的变量 a, p1 是指向 a 的指针变量, p2 又是指向 p1 的指针变量,它们的关系如下图所示:

即:
1 | int a =100; |
指针变量也是一种变量,也会占用存储空间,也可以使用&获取它的地址。 C 语言不限制指针的级数,每增加一级指针,在定义指针变量时就得增加一个星号 * 。 p1 是一级指针,指向普通类型的数据,定义时有一个 * ; p2 是二级指针,指向一级指针 p1,定义时有两个*。
如果我们希望再定义一个三级指针 p3,让它指向 p2,那么可以这样写:
1 | int ***p3 = &p2; |
四级指针也是类似的道理:
1 | int ****p4 = &p3; |
例如:
1 |
|
运行结果:
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 |
|
运行结果:
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 | 0 1 2 3 |
但在内存中, 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 |
|
运行结果:
16
(3) *(p+1)+1 表示第 1 行第 1 个元素的地址。如何理解呢?
*(p+1)单独使用时表示的是第 1 行数据,放在表达式中会被转换为第 1 行数据的首地址,也就是第 1 行第 0 个元素的地址,因为使用整行数据没有实际的含义,编译器遇到这种情况都会转换为指向该行第 0 个元素的指针;
就像一维数组的名字,在定义时或者和 sizeof、 & 一起使用时才表示整个数组,出现在表达式中就会被转换为指向数组第 0 个元素的指针。
(4) *( *(p+1)+1)表示第 1 行第 1 个元素的值。很明显,增加一个 * 表示取地址上的数据。
根据上面的结论,可以很容易推出以下的等价关系:
1 | a+i == p+i |
指针数组和二维数组指针的区别
指针数组和二维数组指针在定义时非常相似,只是括号的位置不同:
1 | int *(p1[5]); //指针数组,可以去掉括号直接写作 int *p1[5]; |
指针数组和二维数组指针有着本质上的区别:指针数组是一个数组,只是每个元素保存的都是指针,以上面的 p1为例,在 32 位环境下它占用 4×5 = 20 个字节的内存。二维数组指针是一个指针,它指向一个二维数组,以上面的 p2 为例,它占用 4 个字节的内存。
函数指针(指向函数的指针)
一个函数总是占用一段连续的内存区域,函数名在表达式中有时也会被转换为该函数所在内存区域的首地址,这和数组名非常类似。我们可以把函数的这个首地址(或称入口地址)赋予一个指针变量,使指针变量指向函数所在的内存区域,然后通过指针变量就可以找到并调用该函数。这种指针就是函数指针。
函数指针的定义形式为:
1 | returnType (*pointerName)(param list); |
returnType 为函数返回值类型, pointerNmae 为指针名称, param list 为函数参数列表。参数列表中可以同时给出参数的类型和名称,也可以只给出参数的类型,省略参数的名称,这一点和函数原型非常类似。
注意( )的优先级高于*,第一个括号不能省略,如果写作 returnType *pointerName(param list);就成了函数原型,它表明函数的返回值类型为 returnType *。
例如:
1 |
|
运行结果:
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]); |