首页 C语言 指针
文章
取消

C语言 指针

此篇博客仍在整理中,内容质量及排版比较一般,还请见谅

什么是指针

计算机中所有的数据都必须放在内存中,不同类型的数据占用的字节数不一样。

例如 int 占用4个字节,char 占用1个字节

为了正确地访问这些数据,必须知道它们在内存中的准确位置,这个位置就叫做地址(Address)指针(Pointer)

内存地址通常使用16进制数表示,地址从0开始依次增加,对于32位环境,程序所能使用的内存为4G,最小的地址为0,最大的地址为0xFFFFFFFF

下面的代码演示了如何输出一个地址:

1
2
3
4
5
6
7
8
9
10
#include <stdio.h>

int main(){
    int a = 10;
    int b[5] = {0, 1, 2, 3, 4};
    char str1[] = "https://www.zfl9.com";
    char *str2 = "https://www.zfl9.com";
    printf("a: %p\nb: %p\nstr1: %p\nstr2: %p\n", &a, b, str1, str2);
    return 0;
}
1
2
3
4
5
$ ./a.out
a: 0x7ffcafdb1fe4
b: 0x7ffcafdb1fd0
str1: 0x7ffcafdb1fb0
str2: 0x400650

%p表示输出一个地址,也可以用%#x&是取地址符,因为数组名本身就表示数组的首地址,所以不需要&

指针变量

数据在内存中的地址也称为指针,如果一个变量存储了一份数据的指针,我们就称它为指针变量

在C语言中,允许用一个变量来存放指针,这种变量称为指针变量。

指针变量的值就是某份数据的地址,这样的一份数据可以是数组、字符串、函数,也可以是另外的一个普通变量或指针变量


定义指针变量:type *ptr;type *ptr = value;

*表示变量ptr是一个指针变量,而type是该指针指向的数据类型

如:int *p,p是一个指针变量,指向的数据类型为int,是一个整型指针

注意,指针变量和普通变量没有什么区别,都是变量,只不过存放的数据类型不同而已

  • 对于int a,它定义了一个变量a,数据的类型为int
  • 对于int a[6],它定义了一个变量a,是一个拥有6个元素的数组,元素的数据类型为int,数组的数据类型为int [6]
  • 对于int *p,它定义了一个变量p,数据的类型为int *

给指针变量赋值

1
2
int a = 10;
int *p = &a;

指针变量需要的是一个地址,所以需要使用&取出变量a的地址,并将其赋给变量p

同时,指针变量的值可以随时改变,和普通的变量一样,可以多次赋值

1
2
3
4
int a = 10, b = 20, c = 30;
int *p = &a;
p = &b;
p = &c;

通过指针变量取得数据

1
2
3
4
5
6
7
8
#include <stdio.h>

int main(){
    int a = 10;
    int *p = &a;
    printf("addr: %p, var: %d\n", p, *p);
    return 0;
}
1
2
$ ./a.out
addr: 0x7fffadfc0fd4, var: 10

*是指针运算符,用来取得某个地址上的数据

使用指针是间接获取数据,要经过两步运算,而通过变量名是直接获取数据


指针除了可以获取数据,还能修改数据

1
2
3
4
5
6
7
8
9
#include <stdio.h>

int main(){
    int a = 10;
    int *p = &a;
    *p = 100;
    printf("addr: %p, var: %d\n", p, *p);
    return 0;
}
1
2
$ ./a.out
addr: 0x7ffedc87fe64, var: 100

通过指针交换两个变量的值

1
2
3
4
5
6
7
8
9
10
11
12
#include <stdio.h>

int main(){
    int a = 10, b = 20, temp;
    printf("swap before: a = %d, b = %d\n", a, b);
    int *pa = &a, *pb = &b;
    temp = *pa;
    *pa = *pb;
    *pb = temp;
    printf("swap afer: a = %d, b = %d\n", a, b);
    return 0;
}
1
2
3
4
5
$ gcc a.c

$ ./a.out
swap before: a = 10, b = 20
swap afer: a = 20, b = 10

指针变量的运算

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

1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>

int main(){
    char a = 'a', *pa = &a;
    int b = 10, *pb = &b;
    double c = 3.14, *pc = &c;
    printf("pa: %p, pb: %p, pc: %p\n", pa, pb, pc);
    pa++; pb++; pc++;
    printf("pa: %p, pb: %p, pc: %p\n", pa, pb, pc);
    pa--; pb--; pc--;
    printf("pa: %p, pb: %p, pc: %p\n", pa, pb, pc);
    return 0;
}
1
2
3
4
5
6
$ gcc a.c

$ ./a.out
pa: 0x7fff4574be77, pb: 0x7fff4574be70, pc: 0x7fff4574be68
pa: 0x7fff4574be78, pb: 0x7fff4574be74, pc: 0x7fff4574be70
pa: 0x7fff4574be77, pb: 0x7fff4574be70, pc: 0x7fff4574be68

可以看出,pa、pb、pc每次加1,它们的地址分别加1、4、8,正好是char、int、double类型的长度

而每次减1,它们的地址分别减1、4、8,也正好是char、int、double类型的长度

看来指针偏移量与指针所指的数据类型相关,刚好等于数据类型的长度,而不仅仅是简单的算数加减,这就使得指针的加减运算有了实际意义

不过对于指向普通变量的指针,对其进行加减运算没有什么意义,因为我们并不知道它们前后都是什么数据

但是对于指向数组的指针,由于数组的元素时连续存储的,这时候就可以用指针来访问元素了

除了加减,还可以对指针变量进行比较,也就是比较它们的值,也就是数据的地址

但不可以对指针变量进行乘法、除法、取余等运算,没有实际意义,编译器也会报错

数组指针

数组指针:也就是指向数组的指针(严格来说,是指向数组的首个元素)

数组(Array)是一系列相同数据类型的数据的集合,每一份数据叫做一个数组元素(Element)。数组中的所有元素在内存中是连续排列的,整个数组占用的是一块内存。

在定义数组的时候,需要给出数组名和数组长度,数组名在有些时候可以认为是一个指针,它指向数组的第0个元素,即数组的首地址。

下面的例子演示了通过指针来访问数组:

1
2
3
4
5
6
7
8
9
10
#include <stdio.h>

int main(){
    int a[5] = {0, 1, 2, 3, 4};
    int i, len = sizeof(a) / sizeof(int);
    for(i=0; i<len; i++){
        printf("index: %d, var: %d\n", i, *(a + i));
    }
    return 0;
}
1
2
3
4
5
6
7
8
$ gcc a.c

$ ./a.out
index: 0, var: 0
index: 1, var: 1
index: 2, var: 2
index: 3, var: 3
index: 4, var: 4

*(a + i)等价于a[i]


也可以定义一个指针,指向数组,通过指针访问数组

1
2
3
4
5
6
7
8
9
10
11
12
#include <stdio.h>

int main(){
    int a[5] = {0, 1, 2, 3, 4};
    int *p = a;
    int i, len = sizeof(a) / sizeof(int);
    // int i, len = sizeof(p) / sizeof(int); 错误,sizeof(p)求得的只是一个指针变量的长度,而不是数组的长度
    for(i=0; i<len; i++){
        printf("index: %d, var: %d\n", i, *(p + i));
    }
    return 0;
}
1
2
3
4
5
6
7
8
$ gcc a.c

$ ./a.out
index: 0, var: 0
index: 1, var: 1
index: 2, var: 2
index: 3, var: 3
index: 4, var: 4

将数组作为指针使用时,该指针变量被 const 修饰,不能改变指针自身的值,只能操作指向的数据

比如,我们可以使用指针,通过自增来遍历数组元素

1
2
3
4
5
6
7
8
9
10
11
12
#include <stdio.h>

int main(){
    int a[5] = {0, 1, 2, 3, 4};
    int *p = a;
    int i;
    for(i=0; i<5; i++){
        printf("%d ", *(p++));
    }
    printf("\n");
    return 0;
}
1
2
3
4
$ gcc a.c

$ ./a.out
0 1 2 3 4

但是换成数组名就不行了,因此下面的代码编译就会报错

1
2
3
4
5
6
7
8
9
10
11
#include <stdio.h>

int main(){
    int a[5] = {0, 1, 2, 3, 4};
    int i;
    for(i=0; i<5; i++){
        printf("%d ", *(a++)); //编译错误
    }
    printf("\n");
    return 0;
}

假设指针p指向数组a的第n个元素,那*p++*++p(*p)++分别代表什么?

对于*p++++优先级比*高,等价于*(p++),由于是后自增,所以先进行其他操作,最后进行自增操作,所以是先取得第n个元素的值,然后再将指针p指向第n+1个元素

对于*++p,等价于*(++p),前自增,先将p指向第n+1个元素,然后再取第n+1个元素的值

对于(*p)++,先取得第n个元素的值,然后将第n个元素的值加1


数组与指针的区别

字符串指针

字符串指针:也就是指向字符串的指针

由于c语言没有专门的字符串类型,一般都是通过字符数组来存储字符串

字符数组也是数组,也可以用一个指针来指向这个数组

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#include <stdio.h>
#include <string.h>

int main(){
    char str[] = "https://www.zfl9.com";
    char *p = str;
    int i, len = strlen(str);
    for(i=0; i<len; i++){
        printf("%c", str[i]);
    }
    printf("\n");
    for(i=0; i<len; i++){
        printf("%c", *(str + i));
    }
    printf("\n");
    for(i=0; i<len; i++){
        printf("%c", p[i]);
    }
    printf("\n");
    for(i=0; i<len; i++){
        printf("%c", *(p + i));
    }
    printf("\n");
    return 0;
}
1
2
3
4
5
6
7
$ gcc a.c

$ ./a.out
https://www.zfl9.com
https://www.zfl9.com
https://www.zfl9.com
https://www.zfl9.com

c语言还支持另外一种表示字符串的方法,就是直接用指针指向一个字符串,叫做字符串常量

1
2
3
4
5
6
7
8
9
#include <stdio.h>

int main(){
    char str1[] = "hello, world!";
    char *str2 = "www.zfl9.com";
    printf("%s\n", str1);
    printf("%s\n", str2);
    return 0;
}
1
2
3
4
5
$ gcc a.c

$ ./a.out
hello, world!
www.zfl9.com

字符串的所有字符在内存中都是连续存储的,和数组一样

注意字符数组和字符串常量的区别,字符数组的内容是可写的,而字符串常量的内容是只读的

因为字符数组存放在内存的栈区(局部变量)或全局数据区(全局变量),拥有读写权限

而字符串常量中的字符串存放在常量区域,常量区域只有读的权限,不能写入

比如,下面的代码尝试修改字符串常量的值,这会发生段错误

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <stdio.h>

int main(){
    char str1[] = "hello, world!";
    char *str2 = "www.zfl9.com";
    printf("%s\n", str1);
    printf("%s\n", str2);

    str1[0] = 'H';
    printf("%s\n", str1);

    str2[0] = 'W';
    printf("%s\n", str2);
    return 0;
}
1
2
3
4
5
6
7
$ gcc a.c

$ ./a.out
hello, world!
www.zfl9.com
Hello, world!
[1]    76302 segmentation fault  ./a.out

再次强调,字符串常量是字符串本身不能被修改,但是指向它的字符指针可以改变指向,指向别的数据

如果需要经常修改字符串,那么应该选择字符数组,如果不需要经常变更字符串的值,就选择字符串常量

数组的各种访问方式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
#include <stdio.h>

int main(){
    char str[20] = "www.zfl9.com";

    char *s1 = str;
    char *s2 = str+2;

    char c1 = str[4];
    char c2 = *str;
    char c3 = *(str+4);
    char c4 = *str+2;
    char c5 = (str+1)[5];

    int num1 = *str+2;
    long num2 = (long)str;
    long num3 = (long)(str+2);

    printf("  s1 = %s\n", s1);
    printf("  s2 = %s\n", s2);

    printf("  c1 = %c\n", c1);
    printf("  c2 = %c\n", c2);
    printf("  c3 = %c\n", c3);
    printf("  c4 = %c\n", c4);
    printf("  c5 = %c\n", c5);

    printf("num1 = %d\n", num1);
    printf("num2 = %ld\n", num2);
    printf("num3 = %ld\n", num3);

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
$ ./a.out
  s1 = www.zfl9.com
  s2 = w.zfl9.com
  c1 = z
  c2 = w
  c3 = z
  c4 = y
  c5 = l
num1 = 121
num2 = 140727275501696
num3 = 140727275501698

s1 是指向数组 str 第 0 个元素的指针,所以输出 www.zfl9.com

s2 是指向数组 str 第 2 个元素的指针,所以输出 w.zfl9.com

c1 是数组 str 第 4 个元素的值,也就是 z

c2 是数组 str 第 0 个元素的值,也就是 w

c3 是数组 str 第 4 个元素的值,也就是 z

c4 是数组 str 第 0 个元素的值加2,也就是 w 的 ASCII 码加2,也就是字符 y

c5 是先计算 (str+1),指向数组的第 1 个元素,再转换为 *(str + 1 + 5),取得第 6 个元素的值,为 l

num1 是第 0 个元素的值,也就是字符 w 的 ASCII 码加 2,为 121

num2 是数组 str 第 0 个元素的地址

num3 是数组 str 第 2 个元素的地址


1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <stdio.h>

int main(){
    char str[20] = {0};
    int i;
    for(i=0; i<10; i++){
        str[i] = 97 + i; // 97为字符a的ASCII码值
    }
    printf("%s\n", str);
    printf("%s\n", str+2);
    printf("%c\n", str[2]);
    printf("%c\n", (str+2)[2]);
    return 0;
}
1
2
3
4
5
6
7
$ gcc a.c

$ ./a.out
abcdefghij
cdefghij
c
e

(str+2)[2]相当于*(str+2+2) == *(str+4) == str[4] == 'e'

指针作为函数参数

在C语言中,函数的参数不仅可以是整数、小数、字符等具体的数据,还可以是指向它们的指针

用指针变量作函数参数可以将函数外部的地址传递到函数内部,使得在函数内部可以操作函数外部的数据,并且这些数据不会随着函数的结束而被销毁

像数组、字符串、动态分配的内存等都是一系列数据的集合,没有办法通过一个参数全部传入函数内部,只能传递它们的指针,在函数内部通过指针来影响这些数据集合

有的时候,对于整数、小数、字符等基本类型数据的操作也必须要借助指针,一个典型的例子就是交换两个变量的值


如果不使用指针,就不能改变函数外的变量的值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <stdio.h>

void swap(int m, int n){
    int temp;
    temp = m;
    m = n;
    n = temp;
}

int main(){
    int m = 10, n = 20;
    printf("before: m = %d, n = %d\n", m, n);
    swap(m, n);
    printf("after: m = %d, n = %d\n", m, n);
    return 0;
}
1
2
3
4
5
$ gcc a.c

$ ./a.out
before: m = 10, n = 20
after: m = 10, n = 20

而通过指针就能交换

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <stdio.h>

void swap(int *p1, int *p2){
    int temp;
    temp = *p1;
    *p1 = *p2;
    *p2 = temp;
}

int main(){
    int m = 10, n = 20;
    printf("before: m = %d, n = %d\n", m, n);
    swap(&m, &n);
    printf("after: m = %d, n = %d\n", m, n);
    return 0;
}
1
2
3
4
5
$ gcc a.c

$ ./a.out
before: m = 10, n = 20
after: m = 20, n = 10

用数组作函数参数

数组是一组数据的集合,无法通过参数将它们一次性传递到函数内部,如果希望在函数内部操作数组,就应该传递数组指针

下面的例子中,max() 函数用于查找数组中值最大的元素

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>

int max(int *array, int len){
    int i, max = array[0]; // 假定 max = array[0]
    for(i=1; i<len; i++){
        if(array[i] > max){
            max = array[i];
        }
    }
    return max;
}

int main(){
    int array[6], i, maxVal;
    int len = sizeof(array) / sizeof(int);
    printf("enter 6 nums: ");
    for(i=0; i<len; i++){
        scanf("%d", array + i);
    }
    maxVal = max(array, len);
    printf("max: %d\n", maxVal);
    return 0;
}
1
2
3
4
5
$ gcc a.c

$ ./a.out
enter 6 nums: 12 55 30 8 93 27
max: 93

参数 array 仅仅是一个数组指针,在函数内部无法通过该指针获得数组长度,必须传入一个数组长度的参数

int max(int *array, int len) 也可写成 int max(int array[6], int len)int max(int array[], int len)

看似好像传入了整个数组,但无论那种方式都不会创建一个数组,他们都会转换为一个int *类型的指针


为什么C语言不允许传递整个数组的元素呢?

这是考虑到效率问题,由于数组的元素个数并没有限制,可能很小也可能很大

而参数传递的本质实际上是一次赋值的过程,也就是内存的拷贝,对于基本数据类型和一些其他的类型,数据量也就几个字节,拷贝很快

而拷贝一个很长的数组,既浪费时间又浪费空间,所以为了不影响效率,C语言不允许传递数组所有的元素

指针作为函数返回值

C语言允许函数的返回值是一个指针(地址),我们将这样的函数称为指针函数

下面的例子定义了一个函数 longStr(),用于返回两个字符串中较长的那个

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>

char *longStr(char *str1, char *str2){
    int len1 = strlen(str1), len2 = strlen(str2);
    return len1 > len2 ? str1 : str2;
}

int main(){
    char str1[50], str2[50], *str;

    printf("string1: ");
    scanf("%[^\n]", str1);

    printf("string2: ");
    setbuf(stdin, NULL);
    scanf("%[^\n]", str2);

    str = longStr(str1, str2);
    printf("longStr: %s\n", str);

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
$ gcc a.c

$ ./a.out
string1: 12345 12345
string2: 1234 123 1
longStr: 12345 12345

$ ./a.out
string1: www zfl9 com
string2: https://www.zfl9.com
longStr: https://www.zfl9.com

二级指针

所谓的二级指针就是指向指针的指针

指针可以指向一份普通类型的数据,例如 intdoublechar 等,也可以指向一份指针类型的数据,例如 int *double *char *

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

假设有一个整型变量 a,p 是指向 a 的指针,pp 是指向 p 的指针:

1
2
3
int a = 10;
int *p = &a;
int **pp = &p;

指针变量也是一种变量,也会占用存储空间,也可以使用 & 获取它的地址

C语言不限制指针的级数,每增加一级指针,在定义指针变量时就得增加一个星号

p1 是一级指针,指向普通类型的数据,定义时有一个星号

p2 是二级指针,指向一级指针 p1,定义时有两个星号

实际开发中常用的也就是一级指针和二级指针,二级以上比较少用

想要获取指针指向的数据时,一级指针加一个星号,二级指针加两个星号,三级指针加三个星号,以此类推

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <stdio.h>

int main(){
    int a = 10;
    int *p1 = &a;
    int **p2 = &p1;
    int ***p3 = &p2;

    printf("var of a: %d, %d, %d, %d\n", a, *p1, **p2, ***p3);
    printf("addr of p2: %p, %p\n", &p2, p3);
    printf("addr of p1: %p, %p, %p\n", &p1, p2, *p3);
    printf("addr of a: %p, %p, %p, %p\n", &a, p1, *p2, **p3);

    return 0;
}
1
2
3
4
5
6
7
$ gcc a.c

$ ./a.out
var of a: 10, 10, 10, 10
addr of p2: 0x7fff58ac1b80, 0x7fff58ac1b80
addr of p1: 0x7fff58ac1b88, 0x7fff58ac1b88, 0x7fff58ac1b88
addr of a: 0x7fff58ac1b94, 0x7fff58ac1b94, 0x7fff58ac1b94, 0x7fff58ac1b94

NULL 指针

一个指针变量可以指向计算机中的任何一块内存,不管该内存有没有被分配,也不管该内存有没有使用权限,只要把地址给它,它就可以指向,C语言没有一种机制来保证指向的内存的正确性,程序员必须自己提高警惕

指针使用之前一定要记得初始化,使用未初始化的指针是非常危险的,因为未初始化的指针乱指一气,运行程序时,在Linux下表现为段错误,在Windows下直接奔溃

强烈建议对未初始化的指针变量指向NULL,如int *p = NULL;

NULL是零值、等于零的意思,在C语言中表示空指针

从表面上理解,空指针是不指向任何数据的指针,是无效指针,程序使用它不会产生效果

很多库函数都对传入的指针做了判断,如果是空指针就不做任何操作,或者给出提示信息


其实,NULL是在stdio.h中定义的一个宏,它的具体内容为:

#define NULL ((void *)0)

(void *)0表示把数值 0 强制转换为void *类型,最外层的()把宏定义的内容括起来,防止发生歧义

从整体上来看,NULL 指向了地址为 0 的内存,而不是前面说的不指向任何数据

C语言没有规定 NULL 的指向,只是大部分标准库都约定成俗地将 NULL 指向 0,不要将 NULL 和 0 等同

void 指针

我们知道,void 可以表示函数没有返回值,也可以表示函数不接受参数

但当 void 与指针一起使用时(void *),它表示指向的数据类型是未知的

void * 变量通常被用来存储、传递内存地址,而不关心指向的数据类型以及长度

如果要对 void * 变量解引用,需要先将其转换为指向具体类型的指针,如 int *

指针数组

指针数组:是一个数组,数组的元素是一个指针

type *array[len];

由于[]的优先级比*高,所以应理解为type *(array[len]);

括号里面的array[len]说明这是一个数组,外面的type *说明数组元素的类型为指针

比如int *a[5];:a 是一个数组,拥有 5 个元素,每个元素的数据类型为 int *

除了元素的数据类型不同,指针数组和普通数组没有区别

1
2
3
4
5
6
7
8
9
10
#include <stdio.h>

int main(){
    int a = 10, b = 20, c = 30;
    int *array[3] = {&a, &b, &c};
    int **p = array; // 指向指针数组的指针
    printf("%d, %d, %d\n", *array[0], *array[1], *array[2]);
    printf("%d, %d, %d\n", **(p + 0), **(p + 1), **(p + 2));
    return 0;
}
1
2
3
4
5
$ gcc a.c

$ ./a.out
10, 20, 30
10, 20, 30

int **p = array;应该理解为int *(*p),括号里的*p表示这是一个指针,括号外的int *表示指针指向的数据类型为一个整型指针


指针数组还可以和字符串数组结合使用,请看下面的例子:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <stdio.h>

int main(){
    char *strings[3] = {
        "www.zfl9.com",
        "www.zflyun.com",
        "www.otokaze.top"
    };
    int i;
    for(i=0; i<3; i++){
        printf("%s\n", strings[i]);
    }
    return 0;
}
1
2
3
4
5
6
$ gcc a.c

$ ./a.out
www.zfl9.com
www.zflyun.com
www.otokaze.top

需要注意的是,字符数组 strings 中存放的是字符串的首地址,不是字符串本身,字符串本身位于其他的内存区域,和字符数组是分开的


指针数组和二级指针

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#include <stdio.h>

int main(){
    char *lines[5] = {
        "COSC1283/1284",
        "Programming",
        "Techniques",
        "is",
        "great fun"
    };

    char *str1 = lines[1];
    char *str2 = *(lines + 3);
    char c1 = *(*(lines + 4) + 6);
    char c2 = (*lines + 5)[5];
    char c3 = *lines[0] + 2;

    printf("str1 = %s\n", str1);
    printf("str2 = %s\n", str2);
    printf("  c1 = %c\n", c1);
    printf("  c2 = %c\n", c2);
    printf("  c3 = %c\n", c3);

    return 0;
}
1
2
3
4
5
6
7
8
$ gcc a.c

$ ./a.out
str1 = Programming
str2 = is
  c1 = f
  c2 = 2
  c3 = E

lines 是一个拥有 5 个元素的数组,数组元素的数据类型为 char *,即各个字符串的首地址

str1:lines[1],即数组 lines 的第1个元素,Programming 的首地址,所以输出 Programming

str2:*(lines + 3),等价于lines[3],即数组 lines 的第3个元素,is 的首地址,输出 is

c1:*(*(lines + 4) + 6),先看*(lines + 4),即数组 lines 的第4个元素,great fun 的首地址,然后加6,表示指针往后偏移6个长度,然后再取值,即 f

c2: (*lines + 5)[5]*lines等价于*(lines+0)等价于lines[0],即第0个元素,COSC1283/1284 的首地址,然后指针往后偏移5个长度,然后看到[5],等价于*(lines[0] + 5 + 5),即字符2

c3:*lines[0] + 2,等价于*(lines[0]) + 2,括号内表示数组第0个元素,即 COSC1283/1284 首地址,也就是字符 C 的地址,然后再取它的值,即字符 C,然后与数值2相加,即ASCII码67 + 2 = 69,即字符 E

二维数组指针

二维数组指针:它是一个指针,指向一个二维数组

1
2
3
4
5
6
7
int a[3][4] = {
    {1, 2, 3, 4},
    {2, 2, 3, 4},
    {3, 2, 3, 4}
};

int (*p)[4] = a;

由于[]优先级比*高,所以这个括号是必须的

首先看*p,表示这是一个指针,然后看int [4],表示这个指针指向一个拥有4个元素的数组

对指针 p 进行加1时,因为指向的数据类型为 int [4],所以前进的长度为 4 * 4 = 16 字节,刚好指向数组 a 下一个元素,减1同理

1) p 指向数组 a 开头,p + 1 指向数组下一行,p - 1 指向数组上一行

2) *(p + 1) 表示取地址上的数据,也就是第1行的数据,注意是一行数据,也就是一个一维数组,是由4个 int 类型组成的集合,所以用 sizeof 求它的长度为 4 * 4 = 16 字节

3) *(p + 1) + 1,表示的是第1行第1个元素的地址,上面说了,*(p + 1)是一个一维数组,还记得数组什么时候会转换为指向第0个元素的地址吗,除了数组定义、sizeof、&中,其他时候都会转换为指向第0个元素的指针,所以在这里就转换为了指针,然后加1,表示是一个指向第1行第1个元素的指针

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
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include <stdio.h>

int main(){
    int a[3][4] = {
        1, 2, 3, 4,
        2, 2, 3, 4,
        3, 2, 3, 4,
    };
    int i, j;
    int (*p)[4] = a;
    for(i=0; i<3; i++){
        for(j=0; j<4; j++){
            printf("%d ", *(*(p + i) + j));
        }
        printf("\n");
    }
    return 0;
}
1
2
3
4
5
6
$ gcc a.c

$ ./a.out
1 2 3 4
2 2 3 4
3 2 3 4

函数指针

函数指针,即指向函数的指针

本质上,变量名,数组名,函数名都是地址的助记符,但是我们认为变量名表示数据本身,而数组名、函数名分别表示数组首个元素的地址、函数的入口地址

我们也可以把一个指针指向一个函数,然后通过指针来调用函数

定义的形式为:return_type (*ptr)(param_list)

其中参数列表可以只给出参数的类型,省略参数名,这和函数声明类似

用指针来实现对函数的调用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <stdio.h>

int max(int a, int b){
    return a > b ? a : b;
}

int main(){
    int a, b;
    printf("enter 2 nums: ");
    scanf("%d %d", &a, &b);
    int (*p)(int, int) = max;
    printf("max: %d\n", p(a, b));
    return 0;
}
1
2
3
4
5
$ gcc a.c

$ ./a.out
enter 2 nums: 10 20
max: 20

复杂的指针声明

1
2
3
4
5
int *p[6];      // 指针数组
int *(p[6]);    // 指针数组,等价于上面的形式
int (*p)[6];    // 二维数组指针
int (*p)(int, int); // 函数指针
int (*p)(int a, int b); //函数指针,等价于上面的形式

C语言标准规定,对于一个符号的定义,编译器总是从它的名字开始读取,然后按照优先级顺序依次解析

对,从名字开始,不是从开头也不是从末尾,这是理解复杂指针的关键!

与指针相关的运算符优先级,由高到低

  • 定义中被()扩起来的部分
  • 后缀操作符:括号()表示这是一个函数,方括号[]表示这是一个数组
  • 前缀操作符:星号*表示这是一个指针变量

1) int *p[6];

从 p 开始理解,编译器先解析 p[6],p 是一个拥有6个元素数组,然后解析 int *,它说明这个数组的元素的数据类型为 int *,也就是指向 int 的指针,所以,从整体上讲,这是一个拥有6个元素的数组,数组元素的数据类型为整型指针,也就是指针数组

2) int (*p)[6];

从 p 开始理解,编译器先解析 *p,p 是一个指针,然后解析 int [6],它说明这个数组的元素的数据类型为 int [6],每个元素都是一个拥有6个元素的一维数组,所以,从整体上讲,这是一个指针,该指针指向拥有6个元素的一维数组,也就是说,这是一个二维数组指针

3) int (*p)(int, int);

从 p 开始理解,编译器先解析 *p,p 是一个指针,然后解析 int (int, int),说明 p 指向一个函数,该函数的参数列表为两个整数,而前面的 int 说明该函数的返回值类型为 int,所以,从整体上讲,这是一个指针,该指针指向一个函数原型为 int func(int, int) 的函数,也就是说,这是一个函数指针

4) char *(* c[10])(int **p);

从 c 开始理解,c[10]表示这是一个拥有10个元素数组,然后解析 (* c[10]),前面的 * 说明该数组的元素的是一个指针,但是指针指向的数据类型还不确定,剩下 char * (int **p),这是一个函数,函数参数为 int **p,返回值类型为 char *,所以,整体上讲,这是一个拥有10个元素的指针数组,每个元素(指针)都指向函数原型为 char *func(int **p) 的函数

5) int (*(*(*pfunc)(int *))[5])(int *);

从 pfunc 开始理解,(*pfunc)表示这是一个指针,然后看它外面一层的* (int *),这是一个函数,函数参数为 int *,返回值为一个指针,但是还不知道该指针指向的是什么数据类型,然后看它外面一层* [5],这说明该函数返回的指针指向一个指针数组,那么这个指针数组的元素又是什么类型呢?继续看,int (int *),这是一个函数,函数参数为 int *,返回值类型为 int,所以,这个指针数组的元素(指针)指向一个函数原型为int func(int *)的函数,综上所述,pfunc是一个函数指针,该函数的返回值是一个指针,它指向一个指针数组,指针数组的元素(指针)指向原型为int func(int *)的函数

指针与 const

有时候我们希望定义这样一种变量,它的值不能被改变,在整个作用域中都保持固定

例如,用一个变量来表示班级的最大人数,或者表示缓冲区的大小

为了满足这一要求,可以使用const关键字对变量加以限定

const int MAX = 100;

这样 MAX 的值就不能更改了,在后续的代码中,如果尝试更改它的内容,编译器会报错

我们经常将const变量称为常量,定义const常量的格式为:

const type name = value;(推荐),或 type const name = value;

由于常量一旦被创建后其值就不能再改变,所以常量必须在定义的同时赋值(初始化),后面的任何赋值行为都将引发错误


const 和指针一起使用

  • const int *ptr:表示指针指向的数据是只读的,但是指针本身可以改变指向
  • int const *ptr:同上
  • int *const ptr:表示指针本身是只读的,但是指针指向的数据是可以读写的

const 和函数的指针参数

在C语言中,单独定义 const 变量没有明显的优势,完全可以使用#define命令代替

const 通常用在函数形参中,如果形参是一个指针,为了防止在函数内部修改指针指向的数据,就可以用 const 来限制

在C语言标准库中,有很多函数的形参都被 const 限制了

我们自己在定义函数时也可以使用 const 对形参加以限制,例如查找字符串中某个字符出现的次数:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <stdio.h>
#include <string.h>

void strnchr(const char *str, char chr){
    int count = 0;
    int len = strlen(str);
    for(int i=0; i<len; i++){
        if(str[i] == chr){
            count++;
        }
    }
    printf("%d\n", count);
}

int main(){
    char str[] = "www.zfl9.com", chr = 'w';
    strnchr(str, chr);
    return 0;
}

根据 strnchr() 的功能可以推断,函数内部要对字符串 str 进行遍历,不应该有修改的动作,用 const 加以限制,不但可以防止由于程序员误操作引起的字符串修改,还可以给用户一个提示,函数不会修改你提供的字符串,请你放心


const 和非 const 类型转换

当一个指针变量 str1 被 const 限制时,并且类似const char *str1这种形式,说明指针指向的数据不能被修改

如果将 str1 赋值给另外一个未被 const 修饰的指针变量 str2,就有可能发生危险

因为通过 str1 不能修改数据,而赋值后通过 str2 能够修改数据了,意义发生了转变,所以编译器不提倡这种行为,会给出错误或警告

也就是说,const char *char *是不同的类型,不能将const char *类型的数据赋值给char *类型的变量

但反过来是可以的,编译器允许将char *类型的数据赋值给const char *类型的变量

这种限制很容易理解,char *指向的数据有读取和写入权限,而const char *指向的数据只有读取权限,降低数据的权限不会带来任何问题,但提升数据的权限就有可能发生危险

不过,我们依旧可以通过指针修改 const 变量的值,因为 const 仅仅是写给编译器看的,只要能够获得它的地址就能修改:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <stdio.h>

int main(void) {
    const int arr[5] = {1, 2, 3, 4, 5};
    int *ptr = (int *)arr, len = sizeof(arr) / sizeof(int);

    for (int i = 0; i < len; i++)
        printf("%d, ", ptr[i]);
    printf("\b\b \n");

    for (int i = 0; i < len; i++)
        ptr[i] += 100;

    for (int i = 0; i < len; i++)
        printf("%d, ", ptr[i]);
    printf("\b\b \n");

    return 0;
}
1
2
3
4
5
$ gcc -o main main.c

$ ./main
1, 2, 3, 4, 5
101, 102, 103, 104, 105

带参数的main()函数

我们之前的程序中,main()函数都是没有参数的,其实main()函数有两种标准函数原型

1
2
int main();
int main(int argc, char *argv[]);

如果要向程序传递命令行参数,就要使用第二种原型

第一个参数 int argc,是参数的个数,就算不传递参数,系统也会默认传递一个参数:当前执行文件的文件名,所以最小也为1

第二个参数 char *argv[],这是一个指针数组,每一个指针都指向一个字符串的首地址,第0个元素总是当前可执行文件的文件名的首地址

1
2
3
4
5
6
#include <stdio.h>

int main(int argc, char *argv[]){
    printf("argc: %d, argv[0]: %s\n", argc, argv[0]);
    return 0;
}
1
2
3
4
$ gcc a.c

$ ./a.out
argc: 1, argv[0]: ./a.out
1
2
3
4
5
6
7
8
9
#include <stdio.h>

int main(int argc, char *argv[]){
    int i;
    for(i=0; i<argc; i++){
        printf("第 %d 个参数为: %s\n", i, argv[i]);
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
$ gcc a.c

$ ./a.out
第 0 个参数为: ./a.out

$ ./a.out 1 2 3
第 0 个参数为: ./a.out
第 1 个参数为: 1
第 2 个参数为: 2
第 3 个参数为: 3

指针总结

指针(Pointer)就是内存的地址,C语言允许用一个变量来存放指针,这种变量称为指针变量。

指针变量可以存放基本类型数据的地址,也可以存放数组、函数以及其他指针变量的地址。

程序在运行过程中需要的是数据和指令的地址,变量名、函数名、字符串名和数组名在本质上是一样的,它们都是地址的助记符

在编写代码的过程中,我们认为变量名表示的是数据本身,而函数名、字符串名和数组名表示的是代码块或数据块的首地址

程序被编译和链接后,这些名字都会消失,取而代之的是它们对应的地址

定义含义
int *p;p是一个整型指针,它可以指向int类型的数据,也可以指向类似int arr[n]的数组
int **p;p是一个二级指针,指向int *类型的数据
int *p[n];p是一个指针数组,数组的每个指针都指向类型为int *的数据
int (*p)[n];p是一个二维数组指针
int *p();p是一个函数,它的返回值类型为int *
int (*p)();p是一个函数指针,指向原型为int func()的函数

1) 指针变量可以进行加减运算,例如 p++p+ip-=i。指针变量的加减运算并不是简单的加上或减去一个整数,而是跟指针指向的数据类型有关

2) 给指针变量赋值时,要将一份数据的地址赋给它,不能直接赋给一个整数,例如 int *p = 1000 是没有意义的,使用过程中一般会导致程序崩溃(段错误)

3) 使用指针变量之前一定要初始化,否则就不能确定指针指向哪里,如果它指向的内存没有使用权限,程序就崩溃了。对于暂时没有指向的指针,建议赋值NULL

4) 两个指针变量可以相减,如果两个指针变量指向同一个数组中的某个元素,那么相减的结果就是两个指针之间相差的元素个数

5) 数组也是有类型的,数组名的本意是表示一组类型相同的数据。在定义数组时,或者和 sizeof、& 运算符一起使用时数组名表示整个数组,表达式中的数组名会被转换为指针

本文由作者按照 CC BY 4.0 进行授权

C语言 随机数

C语言 预处理指令