C语言学习--const修饰符的作用，如何强制修改const定义的对象内容

const 在 C 语言中的作用及应用场景

const 是 C 语言中的一个关键字，用于定义不可修改的变量。通过在变量声明中使用 const，可以指示编译器在代码中禁止对该变量进行修改，增加代码的安全性和可读性。以下是几个典型的应用场景：

1.修饰变量

使用 const 修饰变量可以定义不可变的常量，通常用来保护数据避免在后续的代码中被意外修改。

c
#include 

int main() {
    const int num = 10; // 定义不可修改的整型常量
    // num = 20; // 错误：不能修改 const 修饰的变量

    printf("num = %d\n", num);
    return 0;
}

应用场景：

• 防止程序员无意中修改数据。
• 确保变量在整个程序执行过程中保持不变。

2. 修饰指针

const 修饰指针时，有以下几种常见用法：

• 常量指针 (const int *ptr): 指针所指向的数据不可修改，但指针自身可以修改。

const int value = 10;
const int *ptr = &value;
// *ptr = 20; // 错误：不能修改 ptr 所指向的数据
ptr = NULL;   // 合法：可以改变 ptr 本身的指向

• 指针常量 (int * const ptr): 指针自身不可修改，但指向的数据可以修改。

int value = 10;
int * const ptr = &value;
*ptr = 20;    // 合法：可以修改 ptr 所指向的数据
// ptr = NULL; // 错误：不能修改指针本身的指向

• 常量指针常量 (const int * const ptr): 指针本身和它所指向的数据都不可修改。

const int value = 10;
const int * const ptr = &value;
// *ptr = 20; // 错误：不能修改 ptr 所指向的数据
// ptr = NULL; // 错误：不能修改指针本身的指向

应用场景：

• 防止指针指向的数据或指针本身被无意中修改，提高代码的健壮性。

修饰函数

使用 const 修饰函数参数，特别是在函数参数为指针时，可以有效防止函数内部修改该参数指向的内容。

void print_array(const int *array, size_t size) {
    for (size_t i = 0; i < size; i++) {
        printf("%d ", array[i]);
        // array[i] = 0; // 错误：不能修改 const 修饰的内容
    }
}

应用场景：

防止函数修改输入参数的值，特别是在需要保护传入数组或结构体的情况下。

特殊用法，修饰寄存器

在嵌入式编程中，寄存器通常是只读的，使用 const 修饰寄存器可以表明该寄存器值不会被程序更改，仅用于读取操作。

volatile const uint32_t * const REGISTER_STATUS = (uint32_t *)0x40001000;

应用场景：

• 使用 const 修饰硬件寄存器可以防止无意写入寄存器内容。

如何在运行过程中修改 const 变量参数

在正常情况下，const 变量在编译时被定义为不可修改。但是在一些特殊情况下（例如硬件寄存器或调试场景），我们可能需要修改 const 变量的内容。下面介绍一些绕过 const 限制的方法。

以下是一个结构体定义，包含不同形式的 const 修饰变量和指针：

```c
```c
#include 
#include 
#include 

// 示例结构体，包含不同的 const 成员
typedef struct {
    const uint32_t capacity;                 // 常量变量，不能修改
    uint32_t *const start_ptr;               // 指针常量，指针本身不能改变
    const uint32_t *current_ptr;             // 常量指针，指向的数据不能修改
    uint32_t *next_ptr;                      // 普通指针，无 const 限制
} RingBuffer;

• 对于上面的数据结构，我们希望修改capacity以及s指针常量tart_ptr的值，常量指针和普通指针，都能直接修改指针指向的对象，达到修改的目的。

示例实例

创建 RingBuffer 结构体的实例，其中包含不同的 const 修饰成员：

uint32_t buffer[100];
RingBuffer ring_buffer = {
    .capacity = 100,
    .start_ptr = buffer,
    .current_ptr = buffer,
    .next_ptr = buffer
};

2.1 通过指针强制转换修改 const 修饰的成员

对于 const 修饰的普通变量或指针，我们可以通过强制转换来进行修改。这种方式会绕过编译器的 const 限制。

示例：修改 const uint32_t capacity

capacity 是一个 const 修饰的变量。我们可以通过强制类型转换将其转换为 uint32_t * 类型来绕过 const 限制。

#include 

void modify_capacity(RingBuffer *rb, uint32_t new_capacity) {
    (*(uint32_t *)&rb->capacity) = new_capacity;  // 强制类型转换绕过 const 限制
}

int main() {
    printf("Original capacity: %u\n", ring_buffer.capacity);
    modify_capacity(&ring_buffer, 200);
    printf("Modified capacity: %u\n", ring_buffer.capacity);  // 输出：Modified capacity: 200
    return 0;
}

修改 uint32_t *const start_ptr 指针常量的值

start_ptr 是一个指针常量，表示指针本身不能修改，可以通过二级指针强制转换的方式，修改start_ptr的指向

uint32_t new_buffer[100];
*((uint32_t **)&ring_buffer ->start_ptr) = &new_buffer;  // 强制类型转换绕过 const 限制

2.2 利用union联合体修改 const 修饰的成员

利用联合体（union）来修改 const 属性的原理在于联合体的所有成员共享相同的内存空间。通过访问联合体的非 const 成员，我们可以绕过 const 修饰符，直接修改 const 数据。这种做法常用于底层编程、嵌入式系统开发或特定调试需求中。

在联合体中，我们定义了 RingBuffer 结构体和一个原始字节数组 raw_data，两者共享同一块内存空间。通过 raw_data 访问数据，我们可以绕过 const 限制修改 RingBuffer 中的 const 成员。

typedef union {
    RingBuffer ring_buffer;                 // 原始的 RingBuffer 结构体
    uint8_t raw_data[sizeof(RingBuffer)];   // 访问相同内存的字节数组
} RingBufferUnion;

修改 const 成员示例

我们通过 RingBufferUnion 修改 RingBuffer 中的 const 成员 capacity 和 start_ptr。首先，将 RingBuffer 初始化为只读内容，然后通过联合体的 raw_data 字段修改 const 成员。

void modify_const_members_via_union(RingBufferUnion *rb_union, uint32_t new_capacity, uint32_t *new_start_ptr) {
    // 强制将 raw_data 的前几个字节转换为 uint32_t，修改 capacity
    *((uint32_t *)rb_union->raw_data) = new_capacity;

    // 修改 start_ptr 的值
    *((const uint32_t **)(rb_union->raw_data + sizeof(uint32_t))) = new_start_ptr;
}

使用示例

我们定义一个 RingBuffer 实例并尝试修改其 const 成员。

int main() {
    uint32_t buffer[100];
    RingBufferUnion rb_union = {
        .ring_buffer = {
            .capacity = 100,               // 初始化容量
            .start_ptr = buffer,
            .end_ptr = buffer + 100,
            .current_ptr = buffer
        }
    };

    printf("Original capacity: %u\n", rb_union.ring_buffer.capacity);
    printf("Original start_ptr: %p\n", (void *)rb_union.ring_buffer.start_ptr);

    // 通过联合体修改 const 成员
    uint32_t new_capacity = 200;
    uint32_t new_start_buffer[100];
    modify_const_members_via_union(&rb_union, new_capacity, new_start_buffer);

    printf("Modified capacity: %u\n", rb_union.ring_buffer.capacity);
    printf("Modified start_ptr: %p\n", (void *)rb_union.ring_buffer.start_ptr);

    return 0;
}

注意事项

• 破坏 const 语义：此方法强制修改指针常量的指向，违背了 const 的语义，需在应用场景中确保安全。
• 底层访问风险：联合体强制访问原始数据结构有一定的风险，建议仅在底层代码或调试环境中使用。

通过此方法，可以在不改变结构体定义的情况下强制修改指针常量的指向。不过这种操作在生产环境中应慎用。