C语言指针

October 14, 2021

注意！以下内容均在 gcc 10.3.0 下测试，情况可能会与 vc++6.0 不一致
可以跳着阅读

指针声明

指针类型 * 指针名
注意，这里星号可以在位置任意（星号总是写在类型与指针名之间）
甚至无需空格，如以下声明等效
指针类型* 指针名 指针类型 *指针名
指针类型*指针名

指针的意思是指针变量，指针变量中存储了地址（内存地址）

这意味着指针是一个变量（左值），而地址是一个字面量（右值）
或者说地址是一个实际的值，而指针是变量

如00007ff673193000称为地址（字面量），声明int* p;后，p 称为指针变量

声明int* p;，可以发现，p 的类型为 int*，即 int 类型的指针
因为需要知道指针指向的地址中保存的值的类型，所以指针也自然需要类型

类似于3.14f为浮点数，声明float pi;后，pi 称为浮点变量
浮点变量中存储了浮点数，而指针变量中存储的地址

注意，*p不是指针，p才是指针，*p意味着取得指针指向的地址的值

因此，一般指针和地址可以互换，所以我们会说指针指向一个值，或者地址指向一个值，意思都是相同的

指针必须声明其指向的存储单元的类型。例如int* p，可以说p的类型是int*，也可以说 *p的类型是 int

通过 &变量 获取变量的地址

通过 *地址 来访问该地址

int a = 1;
int *ptr;
ptr = &a;
*ptr = *ptr + 1;  // => 2

上述代码中，声明了指向int类型的指针变量ptr，并将其(指针变量 ptr)赋值为变量 a 的地址

这样，ptr 就保存了 a 的地址，然后，通过*星号访问(访问意味着可以获取和修改)该地址指向的值

通过*ptr 访问某一地址指向的值。在上例中，*ptr + 1 返回 2，然后，通过*ptr = *ptr + 1 将该地址指向的值修改为 2

指针运算（实质为地址运算）

地址类似于00007ff673193000，表示内存单元的编号，它和一般的数不同

地址与整数值的运算表示地址的移动

地址 + 1 表示地址向后移动一位的地址（一位是指地址类型的长度）

假设地址为ads = 00000001，那么ads + 1究竟是多少，并不是说一定是00000002，其实取决于 ads 的类型，因为不同类型的变量所占内存空间也不同。

地址与地址相减，得到地址之间的距离

地址之间的比较运算(>,<)，比较的是各自的内存地址哪一个更大，返回值是整数 1（true）或 0（false）

数组指针

数组名是一个常量指针，返回其首元素的地址

先声明以下变量

int arr[3]; // 为 arr 划分了占用 3 个 int 类型的连续的空间，并可通过 `arr` 访问
arr[0] = 0;
arr[1] = 1;
arr[2] = 2;

依据以上原则，arr 返回&arr[0]

*arr 指向 arr[0]
*(arr + 1) 指向 arr[1]
*(arr + 2) 指向 arr[2]

很明显，对于 arr[n]， *(arr + i) 访问 arr[i]

可以这么认为：数组声明int arr[n]实质上开辟了 n 个类型为 int 的空间。
此操作类似于int* arr = malloc(n * sizeof(int))（或int* arr = calloc(n, sizeof(int))），手动划分了 n 个类型为 int 的空间。
然后，arr 是这段空间起始位置的地址，即 arr == &arr[0]，只不过数组声明的变量由系统管理（栈空间，而不是堆）。

根据上文可以发现，arr[i] 实际上就是 *(arr + i)，因为 arr 其实是数组起始位置的地址

指针数组

声明一个元素全为指针的数组，即得到一个指针数组

char* words[3];
words[0] = "Hello";
words[1] = "world";
words[2] = "clang";
// or  char* words[] = {"Hello", "world", "clang"};
printf(words[0]);
printf(", ");
printf(words[1]);
printf("!  print by ");
printf(words[2]);
// => Hello, world!  print by clang

main 函数形参

int main(int argc, char* argv[])
一般使用 const 修饰 int main(int argc, char const *argv[])
其中 argc 意为 argument count，argv 为 argument vector

#include <stdio.h>
int main(int argc, char const *argv[])
{
    for (int i = 0; i < argc; i++)
        printf("argv[%d]=%s\n", i, argv[i]);
}

假设编译后文件名为 code.out 或 code.exe

code.exe hello world hello clang
或 code.out hello world hello clang

输出

argv[0]=disk:\path\to\file\code.exe 或 /path/to/file/code.out
argv[1]=hello
argv[2]=world
argv[3]=hello
argv[4]=clang

注意 argv[0]是执行文件所在路径，后面的为命令行参数

指针作为函数参数

int sum(int arr[], int len);
int sum(int* arr, int len);

以上声明是等价的，因为调用数组时都传入数组名，函数内部即获得数组首位置的地址
由于函数内部获取的是数组的地址，在函数内部对数组的改动会影响到传入的数组本身

引用传递(C++)

void swap(int &a, int &b){
    int temp = a;
    a = b;
    b = temp;
}

函数定义时使用了&，表示传递引用，传入的参数和函数内得到的参数是一致的，否则则传递值，此时函数内部无法访问外部参数

字符串指针

字符串是字符数组

声明以下变量 s，s 占用连续 14 个长度为 char 的地址

char s[14] = "Hello, world!";

声明以下变量 p。 "Hello, world!"为一字符串数组常量，按照约定，其字面量返回其首元素的地址，即'H'的地址。
根据上文，我们声明了一个指针变量 p，其指向的类型为 char。

char *p = "Hello, world!";

现在，p 是'H'的地址（即 p == &p[0]），通过*p 可访问'H'本身

我们可以做以下验证

#include <stdio.h>
int main()
{
    char *p = "abc";
    printf("%p %p %p %p %p\n", p, &p[0], &p[1], &p[2], &p[3]);
    char s[4] = "abc";
    printf("%p %p %p %p %p\n", s, &s[0], &s[1], &s[2], &s[3]);
}

输出

00007ff673193000 00007ff673193000 00007ff673193001 00007ff673193002 00007ff673193003
000000a1f53ff8a4 000000a1f53ff8a4 000000a1f53ff8a5 000000a1f53ff8a6 000000a1f53ff8a7

证明了 p == &p[0]是正确的

然而对于字符串（字符数组），数组名返回首字符的地址。
使用标准库时，我们通过传入首字符的地址 printf(p) printf(s) 来输出整个字符串

我们可以做以下验证

#include <stdio.h>
int main()
{
    char *p = "abc";
    puts(&p[0]);
    char s[4] = "abc";
    puts(&s[0]);
}

证明了我们实际使用的就是字符数组第一个元素的地址，因为 puts()及某些 io 函数的某些参数其实就是一个指针
实际上函数定义如下
int puts(const char *_Str)
int printf(const char *__format, ...)

多级指针

多级指针是指针的指针

#include <stdio.h>
int main()
{
    int a = 1;
    int **p;           //p是地址的地址
    int *address = &a; //address保存了a的地址
    p = &address; //p保存了地址变量address的地址
    printf("%p %p %p %p", address, p, *p, **p);
    printf("\n%d", **p);
}

输出

000000fb891ff974 000000fb891ff968 000000fb891ff974 0000024300000001
1

通过访问 p，*p 得到一个地址，然后访问这个地址**p，得到这个地址指向的值 1

指针与多维数组

回顾多维数组

#include <stdio.h>
int main()
{
    // 定义二维数组时，必须指明第二维的长度，第一维的长度可以自动推导
    // 相当于 int arr[2][3]
    // arr 的类型为 int (*)[3]
    int arr[][3] = {
        {1, 2, 3},
        {4, 5, 6},
    };
    // 首尾元素的地址
    printf("%p %p\n", &arr[0][0], &arr[1][2]);
    // 若不指明第二维的长度，则默认为一维数组第一个元素，即使溢出
    printf("%p %p\n", &arr[0][0], &arr[0]);
    printf("%p %p\n", &arr[1][0], &arr[1]);
    printf("%p %p\n", &arr[2][0], &arr[2]);
    printf("%p %p\n", &arr[3][0], &arr[3]);
    // 首尾地址距离为 5
    printf("%d\n", &arr[1][2] - &arr[0][0]);
}

输出

0000006553fffd00 0000006553fffd14
0000006553fffd00 0000006553fffd00
0000006553fffd0c 0000006553fffd0c
0000006553fffd18 0000006553fffd18
0000006553fffd24 0000006553fffd24
5

sizeof 运算符

sizeof 作用于数组时，返回整个数组的字节大小

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

输出

sizeof(int)=4
12 24 48
12 12 12
4 4 4

指针访问二维数组

多维数组实质是数组的数组。

可以通过指针访问二维数组，就像用指针访问一维数组一样。

数组作为函数形参时会退化为指针。

#include <stdio.h>
void printArray(int arr[][3])
{ // arr 的类型为 int (*)[3]
    printf("%d %d\n", arr[1][2], *(*(arr + 1) + 2));
    printf("%p %p\n", &arr[1][2], *(arr + 1) + 2);
}
int main()
{
    int arr[][3] = {
        {1, 2, 3},
        {4, 5, 6},
    };
    printArray(arr);
    // 因为多维数组本质上还是线性存储，所以表面上看是越界，实际上仍然可以访问
    printf("%d %d\n", arr[2][0], arr[1][3]);
    printf("%d %d\n", *(*(arr + 2)), *(*(arr + 1) + 3));
}

输出

6 6
00000061fadff6f4 00000061fadff6f4
16 16
16 16

const 修饰指针变量

下面两个语句完全等效
声明了 int 常量

const int a = 1;
int const a = 1;

下面两个语句也完全等效
声明了指向的值不可变的指针
因为是 const *p 形式，*p 被 const 修饰，所以*p 不可变 (但是p可变)

const int* p = 2;
int const *p = 2;

下面声明了地址不可变的指针
因为是 const p 形式，const 修饰 p，所以 p 不可变 (但是*p可变)

int* const p = 2;

下面声明了地址和指向的值都不可变的指针

const int* const p = 2;

注意，指针不能指向 const 定义的常量的地址，因为 const 定义的常量类型带有 const，而不是原类型
所以编译不通过
例如：

const int n = 2; // n的类型是const int，而不是int

使用强制转换时，编译通过， const 定义的常量可以被修改，这是很危险的操作这证明了 const 修饰符修饰的变量仅在编译的防止被修改，但无法保证通过对其地址访问进行修改此种情况下使用宏定义常量略有优势

int *p = (int*) &n;
*p = 2;
printf("%d", p); // => 2

函数名与函数指针

void print(int a) {
  printf("%d\n", a);
}

void (*print_ptr)(int) = &print;

注意*的优先级问题，*修饰函数指针

函数名是指向函数代码的指针，通过函数名可以获取函数地址

// 因此
print == &print == *print == print_ptr == *print_ptr;
print(10) == (*print)(10) == (&print)(10) == (*print_ptr)(10) == print_ptr(10)

以下代码作为验证

#include <stdio.h>
void print(int a)
{
    printf("%d\n", a);
}
int main()
{
    void (*print_ptr)(int) = &print;
    printf("%p %p %p %p %p", print, &print, *print, print_ptr, *print_ptr);
}

输出

00007ff7fcf31591 00007ff7fcf31591 00007ff7fcf31591 00007ff7fcf31591 00007ff7fcf31591

注意，&print_ptr != print_ptr, 因为 print_ptr 是函数指针，而非函数名

←Back to home