面经-C语言——指针相关概念总结

在 C 语言中，指针是非常重要的概念，它与数组、函数等密切相关。本文将详细介绍以下几种指针类型，并通过具体示例帮助大家理解它们的区别和用法：

• 指针数组
• 数组指针
• 指针常量
• 常量指针
• 指向常量的常量指针
• 指针函数
• 函数指针

1. 指针数组 (Array of Pointers)

指针数组是一个数组，其中的每个元素都是指针。简单来说，指针数组是存储多个指针的数组。

语法：

type *arr[n];  // arr是一个指针数组，包含n个指向type类型的指针

示例：

#include 

int main() {
    int a = 10, b = 20, c = 30;
    int *arr[3];  // 指针数组，包含3个int指针

    arr[0] = &a;  // arr[0]指向a
    arr[1] = &b;  // arr[1]指向b
    arr[2] = &c;  // arr[2]指向c

    printf("arr[0] points to: %d\n", *arr[0]);
    printf("arr[1] points to: %d\n", *arr[1]);
    printf("arr[2] points to: %d\n", *arr[2]);

    return 0;
}

输出：

arr[0] points to: 10
arr[1] points to: 20
arr[2] points to: 30

2. 数组指针 (Pointer to an Array)

数组指针是指向整个数组的指针，指针本身是数组的起始地址。

语法：

type (*ptr)[n];  // ptr是一个指向包含n个元素的数组的指针

示例：

#include 

int main() {
    int arr[3] = {10, 20, 30};
    int (*ptr)[3] = &arr;  // ptr是一个指向含有3个int的数组的指针

    printf("ptr[0] = %d\n", (*ptr)[0]);
    printf("ptr[1] = %d\n", (*ptr)[1]);
    printf("ptr[2] = %d\n", (*ptr)[2]);

    return 0;
}

输出：

ptr[0] = 10
ptr[1] = 20
ptr[2] = 30

3. 指针常量 (Pointer Constant)

指针常量是指一个指针变量在初始化后，不能改变其指向的地址。你可以改变指针所指向的内容，但不能改变指针本身指向的地址。

语法：

type * const ptr;  // ptr是指向type类型的常量指针

示例：

#include 

int main() {
    int a = 10, b = 20;
    int * const ptr = &a;  // ptr是一个常量指针，初始化后无法改变指向

    printf("ptr points to: %d\n", *ptr);  // 输出ptr所指向的值

    // ptr = &b;  // 错误，不能修改ptr的指向

    return 0;
}

输出：

ptr points to: 10

4. 常量指针 (Pointer to a Constant)

常量指针是指指针指向的数据是常量，你不能通过该指针修改数据内容，但可以改变指针的指向。

语法：

const type *ptr;  // ptr是指向常量的指针

示例：

#include 

int main() {
    int a = 10, b = 20;
    const int *ptr = &a;  // ptr是指向常量的指针

    printf("ptr points to: %d\n", *ptr);

    // *ptr = 15;  // 错误，不能通过ptr修改所指向的值

    ptr = &b;  // 可以改变ptr的指向

    printf("ptr now points to: %d\n", *ptr);

    return 0;
}

输出：

ptr points to: 10
ptr now points to: 20

5. 指向常量的常量指针 (Pointer to a Constant Constant)

这是一个更严格的声明，指针不仅不能修改指向的数据，指针本身也不能修改。

语法：

const type * const ptr;  // ptr是指向常量的常量指针

示例：

#include 

int main() {
    int a = 10, b = 20;
    const int * const ptr = &a;  // ptr是指向常量的常量指针

    printf("ptr points to: %d\n", *ptr);

    // *ptr = 15;  // 错误，不能修改ptr指向的值
    // ptr = &b;  // 错误，不能改变ptr的指向

    return 0;
}

输出：

ptr points to: 10

6. 指针函数 (Pointer Function)

指针函数是返回指针的函数。返回的指针类型可以是任何类型的指针。

语法：

type* function_name();  // 返回类型是type指针的函数

示例：

#include 

int* get_pointer_to_array(int *arr) {
    return arr;  // 返回数组的指针
}

int main() {
    int arr[3] = {10, 20, 30};
    int *ptr = get_pointer_to_array(arr);  // 获取指向数组的指针

    printf("First element: %d\n", *ptr);  // 输出数组的第一个元素

    return 0;
}

输出：

First element: 10

7. 函数指针 (Function Pointer)

函数指针是指向函数的指针，允许你在运行时动态地选择调用哪个函数。

语法：

return_type (*function_ptr)(args);  // function_ptr是一个指向函数的指针

示例：

#include 

// 定义两个简单函数
int add(int a, int b) {
    return a + b;
}

int subtract(int a, int b) {
    return a - b;
}

int main() {
    int (*func_ptr)(int, int);  // 声明一个函数指针
    func_ptr = add;  // 将函数指针指向add函数

    printf("Add: %d\n", func_ptr(10, 5));  // 调用add函数

    func_ptr = subtract;  // 改变指向subtract函数
    printf("Subtract: %d\n", func_ptr(10, 5));  // 调用subtract函数

    return 0;
}

输出：

Add: 15
Subtract: 5

总结

类型	描述	示例
指针数组	一个数组，每个元素都是指针。	int *arr[3]
数组指针	一个指针，指向整个数组。	int (*ptr)[3]
指针常量	指针的值不可修改，指向的地址不能改变。	int * const ptr
常量指针	指针所指向的数据不可修改，但可以改变指针指向的地址。	const int *ptr
指向常量的常量指针	指针本身和指针所指向的数据都不能修改。	const int * const ptr
指针函数	返回类型是指针的函数。	int* get_pointer_to_array()
函数指针	指向函数的指针，允许动态选择函数调用。	int (*func_ptr)(int, int)