C Language Special: const, static, and Data Scope

In the C language, const and static are two very commonly used keywords that relate to the modifiability, lifecycle, and scope of variables. By combining variable declarations, pointer usage, and function design, we can flexibly control the access permissions, visibility, and lifetime of variables.

1. const (Constant Modifier)

const is used to declare read-only variables, meaning that once a variable is initialized, it cannot be modified.

Basic Syntax

const data_type variable_name = value;

Example:

const int a = 10;
a = 20;  // Error: a is a constant and cannot be modified

const Modifying Pointers

const int *p;   // Pointer to a constant, cannot modify value through *p
int * const p;  // Constant pointer, address cannot change, value can change
const int * const p; // Double const, neither value nor address can change

const Used for Function Parameters

void printStr(const char *str);  // Indicates that the passed string content will not be modified

Benefits:Improves code safety and readability.

2. static (Static Storage Class)

static keyword has three core usages:

1. Modifying Local Variables

It keeps the variable’s value unchanged between function calls.

void counter() {
    static int count = 0;
    count++;
    printf("count = %d\n", count);
}

Each call accumulates on the previous one instead of reinitializing.

2. Modifying Global Variables

Limits the variable to be visible only within this file, other .c files cannot reference it.

static int fileData = 123;

3. Modifying Functions

static void helper() {
    // Only available in the current file
}

Can be used to hide implementation details, enhancing module encapsulation.

3. Data Scope and Lifetime

Classified by Scope:

Type	Access Range
Local Variable	Within function or block
Global Variable	Throughout the project files
Static Variable	Current function or current file
Parameter	Used only within the function

Classified by Lifetime:

Variable Type	Lifetime	Storage Area
Ordinary Local Variable	During function call	Stack
Static Variable (static)	Throughout the program’s execution	Data Segment
Constant (const)	Same as other variable types	Depends on declaration location

4. Comparison of const and #define

#define PI 3.14
const float pi = 3.14;

Comparison Point	`<span>#define</span>`	`<span>const</span>`
Type Checking	No type checking	Compile-time checking
Memory Occupation	Does not occupy memory	May occupy memory
Debug Support	Not debuggable	Variable can be viewed
Recommended Use	Macro constants	Type-safe constants

5. Combination of static + const

Used to declare read-only static variables, such as module-level configuration items:

static const int MAX_SIZE = 100;

Significance: This variable cannot be modified and can only be used in the current file.

6. Practical Example: Static Accumulator and Constant Limitation

int counter() {
    static int count = 0;
    return ++count;
}
const int MAX_RETRY = 3;
// MAX_RETRY = 4; // Error, cannot modify

7. Analysis of Pointer and static Combination

This part is the easiest to confuse, so let’s systematically sort it out.

Common Syntax and Meaning

Syntax	Meaning
`<span>static int *x;</span>`	x is a static int pointer variable
`<span>int * static x;</span>`	Equivalent to the above, legal syntax, less common
`<span>static int * static x;</span>`	Incorrect syntax: repeated modifier

Extension: Adding const

Declaration Form	Meaning
`<span>const int *x</span>`	Pointer to a constant, cannot modify the pointed value
`<span>int * const x</span>`	Constant pointer, address cannot change, value can change
`<span>const int * const x</span>`	Neither value nor address can change
`<span>static int *x</span>`	Static pointer variable
`<span>static const int *x</span>`	Static read-only pointer variable
`<span>static int * const x</span>`	Static constant pointer, address cannot change

8. Output Analysis Example (Comparison of Two Calls)

Example Code:

void demo() {
    static int a = 0;
    int b = 0;
    a++;
    b++;
    printf("a = %d, b = %d\n", a, b);
}

int main() {
    demo();
    demo();
    return 0;
}

Output Result:

a = 1, b = 1
a = 2, b = 1

Explanation:

• a is a static variable, its value will be retained after the first initialization.
• b is an ordinary local variable, reinitialized to 0 with each function call.

9. Summary Overview Table

Keyword	Usage	Lifetime	Scope
`<span>const</span>`	Prevents variable modification (read-only)	Depends on definition location	Local or global
`<span>static</span>`	Extends variable lifetime or limits scope	Throughout the program’s execution	Within function or file
Automatic Variable	Ordinary local variable	During function call	Within function/block
Static Variable	Variable modified by static	Throughout the program’s lifecycle	Function/file level
Global Variable	Variable declared outside functions	Throughout the program’s lifecycle	All files (unless static)

Conclusion

• const ensures variables cannot be modified, increasing code robustness;
• static controls variable lifetime and visibility, a powerful tool for module encapsulation;
• Mastering data scope and lifetime helps avoid issues like “wild pointers” and “variable pollution”;
• Understanding combinations like static int *x, int * const x, and const int * is essential for intermediate C developers.