如何在C语言中创建真正不可被修改的常量？

Great question! Let's unpack why your code works the way it does first, then dive into how to create truly unmodifiable constants in C.

First, a critical misconception: the const keyword in C is primarily a compile-time guardrail. It tells the compiler "don't let me modify this variable directly"—but it doesn't make the underlying memory read-only at the hardware level.

In your example:

const int x = 1;
int *y;
y = &x; // Your compiler should warn you about casting away const here!
*y += 1;

The variable x lives on the stack (since it's a local non-static variable). Even though const blocks direct assignments like x = 2, the stack memory itself is still writable. By casting away the const qualifier with the pointer, you're bypassing the compiler's checks and editing the stack memory directly.

If you want a value that can't be altered—even via pointer tricks—here are three reliable approaches:

1. Use Preprocessor Macros (#define) #

Macros are replaced with their literal value at compile time, so they don't exist in memory at runtime. There's no address to point to, making modification impossible:

#include <stdio.h>
#define X 1 // Compile-time replacement, no memory allocated

int main(int argc, char **argv) {
    printf("X = %d\n", X); // Prints 1
    // You can't do &X — macros have no memory address to reference
    return 0;
}

Note: Macros lack type checking, so stick to them for simple numeric constants.

2. Use static const (Global or Local Static) #

When you declare a const variable as static (either globally or as a static local inside a function), most compilers will place it in the read-only data segment (.rodata) of your program. Attempting to modify memory in this segment triggers a hardware-level error (like a segmentation fault on Linux/macOS, or an access violation on Windows):

#include <stdio.h>

static const int x = 1; // Stored in protected read-only memory

int main(int argc, char **argv) {
    int *y = (int *)&x; // Compiler will warn about casting away const
    *y += 1; // Runtime error: segmentation fault (can't modify .rodata)
    printf("x = %d\n", x);
    return 0;
}

This is a robust, type-safe way to create constants protected at the memory level.

3. Use Enumerations (enum) #

Enumerated constants are also compile-time values with no runtime memory address, so they can't be modified. They offer basic type safety and are perfect for related sets of constants:

#include <stdio.h>

enum {
    MIN_LIMIT = 1,
    MAX_LIMIT = 100
};

int main(int argc, char **argv) {
    printf("MIN_LIMIT = %d\n", MIN_LIMIT); // Prints 1
    // &MIN_LIMIT is invalid — enumerations have no memory address
    return 0;
}

• A plain const local variable is just a writable stack variable with compiler-enforced read-only access; it can be bypassed with pointers.
• For truly unmodifiable constants, choose:
  • #define for simple, type-agnostic compile-time values
  • static const for type-safe, memory-protected constants
  • enum for related groups of compile-time constants

内容的提问来源于stack exchange，提问作者ClementNerma