MK
摩柯社区 - 一个极简的技术知识社区
AI 面试

C语言指针表达式的运用

2021-12-296.5k 阅读

C语言指针表达式的基础概念

指针的本质

在C语言中，指针是一种特殊的数据类型，它存储的是内存地址。每一个变量在内存中都有一个对应的地址，指针变量就是用来存放这些地址值的。例如，假设有一个整型变量 int num = 10;，在内存中，num 占据一定的字节空间，并且有一个对应的内存地址，比如 0x1000（实际地址取决于系统和内存分配情况）。我们可以定义一个指针变量来存储 num 的地址：int *ptr;，这里 * 表示 ptr 是一个指针变量，int 表示 ptr 所指向的数据类型是整型。然后通过 ptr = # 来让 ptr 存储 num 的地址，& 是取地址运算符。

指针表达式的定义

指针表达式是指包含指针变量、指针运算符（如 * 和 &）以及其他操作数（如变量、常量等），并按照C语言语法规则组成的表达式。指针表达式通过对指针进行各种运算，从而实现对其所指向内存数据的灵活操作。例如，*ptr + 1 就是一个指针表达式，它先取出 ptr 所指向的内存单元的值，然后加1。

指针表达式中的运算符

取地址运算符 &

取地址运算符 & 用于获取变量的内存地址。它的操作数必须是一个左值（可以出现在赋值号左边的表达式，通常是变量）。例如：

#include <stdio.h>
int main() {
    int num = 20;
    int *ptr;
    ptr = &num;
    printf("The address of num is: %p\n", (void *)ptr);
    return 0;
}

在上述代码中，ptr = &num; 使用 & 运算符获取了 num 的地址，并赋值给 ptr。printf 函数中使用 %p 格式化输出地址，需要将指针类型强制转换为 void * 以保证可移植性。

间接访问运算符 *

间接访问运算符 *，也称为解引用运算符，它用于访问指针所指向的内存单元中的值。其操作数必须是一个指针类型。例如：

#include <stdio.h>
int main() {
    int num = 30;
    int *ptr = &num;
    printf("The value of num is: %d\n", *ptr);
    *ptr = 40;
    printf("The new value of num is: %d\n", num);
    return 0;
}

在代码中，*ptr 用于获取 ptr 所指向的内存单元（即 num）的值。当执行 *ptr = 40; 时，实际上是修改了 num 的值，因为 ptr 指向 num 的内存地址。

指针的算术运算符

指针可以进行一些算术运算，主要包括加法 +、减法 -、自增 ++ 和自减 --。

指针的加法运算

指针的加法运算并不是简单地将指针值（内存地址）与一个整数相加，而是根据指针所指向的数据类型的大小来进行偏移。例如，对于一个 int 类型的指针，假设 int 类型在当前系统占4个字节，如果有 int *ptr;，当执行 ptr = ptr + 2; 时，ptr 的值会增加 2 * sizeof(int) 个字节，即8个字节。示例代码如下：

#include <stdio.h>
int main() {
    int arr[] = {10, 20, 30, 40, 50};
    int *ptr = arr;
    ptr = ptr + 2;
    printf("The value at ptr is: %d\n", *ptr);
    return 0;
}

在上述代码中，arr 是一个整型数组，数组名在表达式中会被转换为指向数组首元素的指针。ptr = ptr + 2; 使 ptr 指向数组的第3个元素（数组下标从0开始），然后通过 *ptr 输出该元素的值。

指针的减法运算

指针的减法运算同样基于所指向数据类型的大小。两个指针相减的结果是它们之间相差的元素个数，前提是这两个指针指向同一个数组中的元素。例如：

#include <stdio.h>
int main() {
    int arr[] = {10, 20, 30, 40, 50};
    int *ptr1 = &arr[0];
    int *ptr2 = &arr[3];
    int diff = ptr2 - ptr1;
    printf("The difference between ptr2 and ptr1 is: %d\n", diff);
    return 0;
}

在这段代码中，ptr1 指向数组的首元素，ptr2 指向数组的第4个元素。ptr2 - ptr1 的结果是3，表示它们之间相差3个 int 类型的元素。

指针的自增和自减运算

指针的自增 ++ 和自减 -- 运算与加法和减法运算类似，只不过是每次只移动一个元素的位置。例如，ptr++ 等价于 ptr = ptr + 1;，ptr-- 等价于 ptr = ptr - 1;。以下是自增运算的示例：

#include <stdio.h>
int main() {
    int arr[] = {10, 20, 30, 40, 50};
    int *ptr = arr;
    printf("The first value is: %d\n", *ptr);
    ptr++;
    printf("The second value is: %d\n", *ptr);
    return 0;
}

在代码中，ptr++ 使 ptr 从指向数组的首元素移动到指向第二个元素。

关系运算符与指针

指针可以使用关系运算符（如 <, >, <=, >=, ==, !=）进行比较。当两个指针指向同一个数组中的元素时，关系运算符可以比较它们的相对位置。例如：

#include <stdio.h>
int main() {
    int arr[] = {10, 20, 30, 40, 50};
    int *ptr1 = &arr[1];
    int *ptr2 = &arr[3];
    if (ptr1 < ptr2) {
        printf("ptr1 is before ptr2 in the array\n");
    }
    return 0;
}

在上述代码中，ptr1 指向数组的第二个元素，ptr2 指向数组的第四个元素。通过 ptr1 < ptr2 比较它们在数组中的位置关系。

复杂指针表达式

指针与数组的复杂表达式

在C语言中，数组和指针有着紧密的联系。数组名可以看作是一个常量指针，指向数组的首元素。例如，对于 int arr[5];，arr 等同于 &arr[0]。我们可以通过指针表达式来访问数组元素，并且可以构造复杂的表达式。比如，*(arr + 2) 等价于 arr[2]，它们都表示访问数组的第三个元素。下面是一个复杂一些的示例：

#include <stdio.h>
int main() {
    int arr[] = {1, 2, 3, 4, 5};
    int (*ptr)[5] = &arr;
    printf("The third element is: %d\n", *(*ptr + 2));
    return 0;
}

在上述代码中，int (*ptr)[5] 定义了一个指向包含5个 int 类型元素的数组的指针 ptr。*ptr 等价于 arr，*(*ptr + 2) 就相当于 arr[2]，从而获取数组的第三个元素。

指针与结构体的复杂表达式

结构体是一种自定义的数据类型，它可以包含不同类型的成员。指针与结构体结合可以构造出复杂且强大的表达式。例如，假设有如下结构体定义：

struct Student {
    char name[20];
    int age;
    float score;
};

我们可以定义结构体指针，并通过指针表达式访问结构体成员。使用 -> 运算符可以通过结构体指针访问成员，它等价于 (*ptr).member。示例代码如下：

#include <stdio.h>
#include <string.h>
struct Student {
    char name[20];
    int age;
    float score;
};
int main() {
    struct Student stu = {"Tom", 20, 85.5};
    struct Student *ptr = &stu;
    printf("Name: %s, Age: %d, Score: %.2f\n", ptr->name, ptr->age, ptr->score);
    return 0;
}

在上述代码中，ptr->name、ptr->age 和 ptr->score 分别通过指针 ptr 访问结构体 stu 的成员。如果要通过复杂表达式修改结构体成员的值，比如将年龄增加1，可以使用 (ptr->age)++;。

多级指针表达式

多级指针是指指针指向的是另一个指针。例如，int **pptr; 定义了一个二级指针 pptr，它指向的是一个 int * 类型的指针。多级指针在一些复杂的数据结构（如链表的链表）中非常有用。下面是一个简单的示例：

#include <stdio.h>
int main() {
    int num = 10;
    int *ptr = &num;
    int **pptr = &ptr;
    printf("The value of num is: %d\n", **pptr);
    return 0;
}

在上述代码中，pptr 指向 ptr，而 ptr 指向 num。通过 **pptr 可以最终访问到 num 的值。复杂的多级指针表达式可能涉及到指针的移动和多层解引用。例如，如果有一个数组的指针的指针，可以通过如下方式访问数组元素：

#include <stdio.h>
int main() {
    int arr[3] = {10, 20, 30};
    int *ptr[3] = {&arr[0], &arr[1], &arr[2]};
    int **pptr = ptr;
    printf("The second element is: %d\n", *(*pptr + 1));
    return 0;
}

在这段代码中，ptr 是一个包含3个指针的数组，每个指针指向 arr 数组的一个元素。pptr 指向 ptr 数组的首元素。*(*pptr + 1) 先通过 *pptr 得到 ptr[0]，然后 *pptr + 1 得到 ptr[1]，最后通过解引用 *(*pptr + 1) 得到 arr[1] 的值。

指针表达式在函数中的运用

函数参数中的指针表达式

在C语言中，函数参数可以是指针类型，通过指针表达式可以在函数内部修改调用函数外部的变量值。例如，交换两个整数的函数可以这样实现：

#include <stdio.h>
void swap(int *a, int *b) {
    int temp;
    temp = *a;
    *a = *b;
    *b = temp;
}
int main() {
    int num1 = 10, num2 = 20;
    printf("Before swap: num1 = %d, num2 = %d\n", num1, num2);
    swap(&num1, &num2);
    printf("After swap: num1 = %d, num2 = %d\n", num1, num2);
    return 0;
}

在上述代码中，swap 函数的参数 a 和 b 是指针类型。在函数内部，通过 *a 和 *b 解引用指针，实现对调用函数中 num1 和 num2 的值交换。

函数返回值中的指针表达式

函数也可以返回指针类型。例如，下面的函数返回一个指向字符串常量的指针：

#include <stdio.h>
const char *getMessage() {
    return "Hello, world!";
}
int main() {
    const char *msg = getMessage();
    printf("%s\n", msg);
    return 0;
}

在上述代码中，getMessage 函数返回一个指向字符串常量 "Hello, world!" 的指针。需要注意的是，当返回指针时，要确保所指向的内存区域在函数调用结束后仍然有效。如果返回的是函数内部局部变量的指针，该指针可能会指向无效内存，因为局部变量在函数结束时会被销毁。例如，下面的代码是错误的：

#include <stdio.h>
char *getBadMessage() {
    char str[] = "Invalid message";
    return str;
}
int main() {
    char *msg = getBadMessage();
    printf("%s\n", msg);
    return 0;
}

在这个错误示例中，str 是 getBadMessage 函数内部的局部数组，函数结束后 str 所占据的内存被释放，msg 指向的是无效内存，可能导致程序运行错误。

指针表达式的内存管理与常见错误

指针表达式与内存分配

在使用指针表达式时，经常需要进行动态内存分配，以确保指针有合法的内存可指向。C语言提供了 malloc、calloc 和 realloc 等函数来进行动态内存分配。例如，使用 malloc 分配内存：

#include <stdio.h>
#include <stdlib.h>
int main() {
    int *ptr = (int *)malloc(sizeof(int));
    if (ptr != NULL) {
        *ptr = 10;
        printf("The value of ptr is: %d\n", *ptr);
        free(ptr);
    } else {
        printf("Memory allocation failed\n");
    }
    return 0;
}

在上述代码中，malloc(sizeof(int)) 分配了 sizeof(int) 个字节的内存，并返回一个指向该内存的指针。通过 ptr != NULL 检查内存分配是否成功。如果成功，将值10赋给 *ptr，使用完后通过 free(ptr) 释放内存。

指针表达式常见错误

野指针

野指针是指指向一块已经释放或者从未分配过的内存区域的指针。例如：

#include <stdio.h>
#include <stdlib.h>
int main() {
    int *ptr = (int *)malloc(sizeof(int));
    *ptr = 20;
    free(ptr);
    // 此时ptr成为野指针
    printf("The value of ptr is: %d\n", *ptr);
    return 0;
}

在上述代码中，free(ptr) 释放了 ptr 所指向的内存，但后续又尝试访问 *ptr，这是非常危险的，可能导致程序崩溃或未定义行为。

空指针解引用

空指针是指值为 NULL 的指针。解引用空指针会导致未定义行为。例如：

#include <stdio.h>
int main() {
    int *ptr = NULL;
    printf("The value of ptr is: %d\n", *ptr);
    return 0;
}

在这段代码中，ptr 被初始化为 NULL，然后尝试解引用 ptr，这会引发错误。在使用指针之前，应该始终检查指针是否为 NULL。

内存泄漏

内存泄漏是指程序中分配了内存，但在不再需要时没有释放，导致内存浪费。例如：

#include <stdio.h>
#include <stdlib.h>
int main() {
    int *ptr = (int *)malloc(sizeof(int));
    *ptr = 30;
    // 这里没有调用free(ptr)，导致内存泄漏
    return 0;
}

在上述代码中，malloc 分配的内存没有通过 free 释放，随着程序的运行，这种情况如果频繁发生，会导致可用内存逐渐减少。

指针表达式在实际项目中的应用

在数据结构中的应用

指针表达式在数据结构的实现中起着核心作用。例如，链表是一种常用的数据结构，其节点之间通过指针连接。下面是一个简单的单向链表的实现示例：

#include <stdio.h>
#include <stdlib.h>
struct Node {
    int data;
    struct Node *next;
};
struct Node* createNode(int value) {
    struct Node *newNode = (struct Node *)malloc(sizeof(struct Node));
    newNode->data = value;
    newNode->next = NULL;
    return newNode;
}
void insertAtHead(struct Node **head, int value) {
    struct Node *newNode = createNode(value);
    newNode->next = *head;
    *head = newNode;
}
void printList(struct Node *head) {
    struct Node *current = head;
    while (current != NULL) {
        printf("%d -> ", current->data);
        current = current->next;
    }
    printf("NULL\n");
}
int main() {
    struct Node *head = NULL;
    insertAtHead(&head, 10);
    insertAtHead(&head, 20);
    insertAtHead(&head, 30);
    printList(head);
    return 0;
}

在上述代码中，struct Node 定义了链表节点的结构，包含一个数据成员 data 和一个指向下一个节点的指针 next。createNode 函数用于创建新节点，insertAtHead 函数通过指针表达式 newNode->next = *head; 和 *head = newNode; 实现将新节点插入到链表头部，printList 函数通过指针表达式 current = current->next; 遍历链表并打印节点数据。

在操作系统相关编程中的应用

在操作系统相关编程中，指针表达式常用于内存管理、进程间通信等方面。例如，在内存映射文件的操作中，需要使用指针表达式来访问映射到内存中的文件数据。下面是一个简单的示例，展示如何使用 mmap 函数（在POSIX系统中）将文件映射到内存并进行读写：

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <unistd.h>
int main() {
    int fd = open("test.txt", O_RDWR | O_CREAT, S_IRUSR | S_IWUSR);
    if (fd == -1) {
        perror("open");
        return 1;
    }
    const char *content = "Hello, mmap!";
    write(fd, content, strlen(content));
    struct stat sb;
    if (fstat(fd, &sb) == -1) {
        perror("fstat");
        close(fd);
        return 1;
    }
    void *ptr = mmap(NULL, sb.st_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    if (ptr == MAP_FAILED) {
        perror("mmap");
        close(fd);
        return 1;
    }
    char *data = (char *)ptr;
    printf("Data read from mapped file: %s\n", data);
    if (munmap(ptr, sb.st_size) == -1) {
        perror("munmap");
    }
    close(fd);
    return 0;
}

在上述代码中，mmap 函数将文件映射到内存，并返回一个指向映射区域的指针 ptr。通过指针表达式 char *data = (char *)ptr; 将指针转换为合适的类型，以便进行数据访问和操作。最后通过 munmap 函数解除映射。

在嵌入式系统编程中的应用

在嵌入式系统编程中，指针表达式常用于与硬件寄存器交互。例如，在ARM微控制器中，需要通过指针访问特定的寄存器地址来配置外设。假设某个外设的控制寄存器地址为 0x40000000，我们可以通过如下方式访问该寄存器：

#include <stdint.h>
// 假设控制寄存器是32位的
volatile uint32_t *controlReg = (volatile uint32_t *)0x40000000;
void configurePeripheral() {
    *controlReg = 0x00000001; // 设置控制寄存器的值
}
int main() {
    configurePeripheral();
    return 0;
}

在上述代码中，volatile 关键字用于告诉编译器不要对该变量进行优化，因为硬件寄存器的值可能随时被硬件修改。通过指针表达式 *controlReg = 0x00000001; 对控制寄存器进行赋值，从而配置外设。

通过深入理解和熟练运用C语言指针表达式，程序员能够编写出高效、灵活且强大的程序，无论是在数据结构、操作系统编程还是嵌入式系统等领域，指针表达式都发挥着不可或缺的作用。同时，要注意指针表达式可能带来的内存管理问题和常见错误，以确保程序的稳定性和可靠性。