嵌入式的C/C++：深入理解 static、const 与 volatile 的用法与特点

一、static

1、static 修饰局部变量

2、 static 修饰全局变量

3、static 修饰函数

4、static 修饰类成员

5、小结

二、const

1、const 修饰普通变量

2、const 修饰指针

3、const 修饰函数参数

4. const 修饰函数返回值

5. const 修饰类成员

6. const 与 #define 的比较

7. 小结

三、 volatile

1、volatile 的作用

2、volatile 的典型应用场景

3、volatile 的特性与限制

4、volatile 的用法

5、小结

在嵌入式的C/C++ 编程中，关键字不仅仅是语法结构的一部分，更是语言核心特性的体现。static、const 和 volatile 是三个常见且重要的关键字，广泛应用于变量管理、优化控制、代码安全性和硬件编程等领域。然而，很多开发者在使用它们时，往往只了解表面作用，而忽视了深入理解可能带来的性能优化和代码维护收益。本篇博客将通过细致的分类讲解和实用的示例，带你全面掌握这三个关键字的用法、特性和应用场景。

一、static

static 关键字有多种用途。在函数内部声明的变量前使用 static 关键字，可以让该变量在整个程序运行期间都保持其值，而不是在每次调用函数时重新初始化。对于全局变量或函数，static 可以限制它们的作用域到声明它们的文件内，即其他文件无法访问这些变量或函数。

1、`static` 修饰局部变量

作用：将局部变量的 生命周期 扩展为整个程序的运行期间，但 作用域 仍局限于函数内部

特点：初始化只会发生一次。再次调用函数时，保留变量上一次的值。

示例：

#include <stdio.h>
void counter() {
    static int count = 0;  // 静态局部变量，初始化只执行一次
    count++;
    printf("Count: %d\n", count);
}

int main() {
    counter();  // 输出：Count: 1
    counter();  // 输出：Count: 2
    counter();  // 输出：Count: 3
    return 0;
}

分析：

count 是静态局部变量，第一次调用时初始化为 0。
每次调用 counter 函数后，count 的值都会被保留，而不是销毁。
如果没有 static，count 每次调用都会重新初始化为 0。

2、 `static` 修饰全局变量

作用：将全局变量的 作用域 限制在当前文件中，使得其他文件无法直接访问该变量。

特点：全局变量默认具有整个程序可见性，但加上 static 后，仅对声明它的文件可见。有助于模块化和避免命名冲突。

示例：

// file1.c
#include <stdio.h>
static int global_var = 100; // 静态全局变量，仅限于本文件

void display() {
    printf("global_var: %d\n", global_var);
}

// file2.c
#include <stdio.h>
extern int global_var; // 错误！无法访问 file1.c 中的静态全局变量

int main() {
    display(); // 只能通过函数间接访问
    return 0;
}

分析：

global_var 是静态全局变量，仅 file1.c 可访问，file2.c 无法通过 extern 引用。
模块化设计中，通过隐藏不必要的全局变量，减少模块间的耦合。

3、`static` 修饰函数

作用：将函数的作用域限制在当前文件中，避免外部文件调用该函数，起到“私有化”的作用。

特点：函数默认具有外部可见性，加上 static 后仅对当前文件可见。有助于避免命名冲突。

示例：

// file1.c
#include <stdio.h>
static void privateFunction() {
    printf("This is a static function.\n");
}

void publicFunction() {
    privateFunction(); // 内部可以正常调用
}

// file2.c
extern void privateFunction(); // 错误！无法访问 file1.c 中的静态函数

int main() {
    publicFunction(); // 通过非静态函数间接调用
    return 0;
}

分析：

privateFunction 是静态函数，仅 file1.c 内部可调用，file2.c 无法通过 extern 声明使用。
这种机制可以防止外部文件误调用函数，起到保护作用。

4、`static` 修饰类成员

4.1 静态成员变量

特点：属于整个类而非某个对象。在所有对象中共享，仅在程序中初始化一次。

示例：

#include <iostream>
class MyClass {
public:
    static int count; // 静态成员变量
    MyClass() { count++; }
};

int MyClass::count = 0; // 静态成员变量初始化

int main() {
    MyClass obj1, obj2, obj3;
    std::cout << "Object count: " << MyClass::count << std::endl; // 输出：3
    return 0;
}

4.2 静态成员函数

特点：不能访问非静态成员（因为没有对象实例）。可通过类名直接调用，而无需实例化对象。

示例：

#include <iostream>
class MyClass {
public:
    static void display() {
        std::cout << "This is a static member function." << std::endl;
    }
};

int main() {
    MyClass::display(); // 静态成员函数直接通过类名调用
    return 0;
}

5、小结

static 关键字在模块化、性能优化和作用域管理中起到非常重要的作用。

二、const

const 关键字用于指定一个对象是常量，即它的值不能通过普通的赋值操作来改变。它可以应用于变量、指针、函数参数等。用于定义不可修改的值或具有只读属性的变量。它在程序设计中用于增强代码的安全性和可维护性。

1、`const` 修饰普通变量

作用：定义一个只读的变量，不能对其赋新值。

特点：变量的值在程序中固定。编译器会在尝试修改 const 变量时报错。

示例：

#include <stdio.h>
int main() {
    const int x = 10;  // 定义只读变量
    printf("x = %d\n", x);
    // x = 20; // 错误：不能修改 const 变量
    return 0;
}

注意：const 修饰的变量必须初始化，否则会报错

2、`const` 修饰指针

在指针的定义中，const 的位置决定了指针的只读属性是指针本身还是指针指向的值。

2.1 指向的值是只读的

const int *p = &x; // 或 int const *p = &x;

含义：指针指向的值不能修改，但指针本身可以改变指向的地址。

示例：

#include <stdio.h>
int main() {
    int x = 10, y = 20;
    const int *p = &x;  // 指针指向的值不可修改
    // *p = 15; // 错误：不能修改 p 指向的值
    p = &y;   // 合法：可以修改 p 的指向
    printf("p points to: %d\n", *p);
    return 0;
}

2.2 指针本身是只读的

int * const p = &x;

含义：指针本身不能修改指向的地址，但指针指向的值可以改变。

示例：

#include <stdio.h>
int main() {
    int x = 10;
    int *const p = &x;  // 指针本身不可修改
    *p = 20;            // 合法：可以修改 p 指向的值
    // p = &y;          // 错误：不能改变指针的指向
    printf("x = %d\n", *p);
    return 0;
}

2.3 指针本身和指向的值都是只读的

const int * const p = &x;

含义：指针本身和指向的值都不可修改。

3、`const` 修饰函数参数

作用：保护函数的输入参数，防止在函数内部被修改。

应用场景：适用于传入参数的值不应被修改的情况（例如输入只读配置、避免意外修改等）。

3.1 修饰值传递参数

void func(const int x) {
    // x = 20; // 错误：x 是只读的
    printf("x = %d\n", x);
}
int main() {
    func(10);
    return 0;
}

3.2 修饰指针参数

如果函数需要读取指针指向的值，但不能修改该值：

void display(const int *p) {
    // *p = 20; // 错误：不能修改 p 指向的值
    printf("Value: %d\n", *p);
}

如果函数不能修改指针本身的地址：

void display(int * const p) {
    // p = &y; // 错误：不能修改指针 p 本身的地址
    *p = 20; // 合法：可以修改 p 指向的值
}

4. `const` 修饰函数返回值

作用：防止函数返回值被修改。

4.1 修饰返回普通值

const int getValue() {
    return 10;
}
int main() {
    const int x = getValue();
    // x = 20; // 错误：不能修改 x 的值
    return 0;
}

4.2 修饰返回指针

如果函数返回一个指针，但指针指向的值不可修改：

const int* getPointer() {
    static int x = 10;
    return &x;
}
int main() {
    const int *p = getPointer();
    // *p = 20; // 错误：不能修改 p 指向的值
    return 0;
}

5. `const` 修饰类成员

5.1 修饰类成员变量

作用：类的成员变量定义为只读，必须在构造函数初始化列表中初始化。

#include <iostream>
class MyClass {
public:
    const int value; // const 成员变量
    MyClass(int v) : value(v) {} // 必须在构造函数初始化列表中初始化
};

int main() {
    MyClass obj(10);
    // obj.value = 20; // 错误：不能修改 const 成员变量
    std::cout << "Value: " << obj.value << std::endl;
    return 0;
}

5.2 修饰类成员函数

作用：表示该函数不会修改类的成员变量。

语法：在函数定义后加 const。

#include <iostream>
class MyClass {
private:
    int data;
public:
    MyClass(int d) : data(d) {}
    int getData() const {  // const 成员函数
        return data;
    }
    // void setData(int d) const { data = d; } // 错误：const 函数不能修改成员变量
};

int main() {
    MyClass obj(10);
    std::cout << "Data: " << obj.getData() << std::endl;
    return 0;
}

6. `const` 与 `#define` 的比较

示例对比：

#define PI 3.14
const double pi = 3.14;

int main() {
    // PI = 3.15; // 错误：#define 定义的值是文本替换，不是变量
    // pi = 3.15; // 错误：const 定义的值不能修改
    return 0;
}

7. 小结

const 的作用：

保护变量：限制变量或指针的可修改性，增强安全性。
优化函数：保护函数参数，避免意外修改。
增强表达力：通过 const 声明，提高代码的可读性和维护性。
C++ 专用特性：在类中可修饰成员变量和成员函数，支持更复杂的只读逻辑。

const 是代码中保证不变性的强有力工具，在安全性、优化和可维护性方面至关重要。

三、 volatile

volatile 关键字用来修饰那些可能被意想不到地改变的变量，例如硬件寄存器中的值或并发线程中共享的变量。它告诉编译器不要对涉及这些变量的操作进行优化，确保每次读取都是从内存中读取最新的值。

1、`volatile` 的作用

防止编译器优化：
编译器在优化代码时，可能会将变量的值缓存在寄存器中，导致程序无法感知变量的实时变化。volatile 保证变量的值总是从内存中读取，而不是从寄存器缓存读取。

编译器在优化代码时，可能会做以下处理：

将变量的值缓存到寄存器中，避免重复访问内存。

在循环中，认为变量值不变，将其优化为常量。

volatile 禁止编译器对变量进行这些优化。

确保正确性：
对于可能被其他线程、中断服务程序（ISR）、硬件设备等修改的变量，volatile 确保程序访问的是最新值。

2、`volatile` 的典型应用场景

2.1 多线程编程

当一个变量可能被多个线程修改时，需要用 volatile 声明，以防止编译器优化。

volatile int flag = 0;

void thread1() {
    while (flag == 0) {
        // 等待其他线程修改 flag
    }
    // 继续执行
}
void thread2() {
    flag = 1;  // 修改 flag
}

如果没有 volatile，编译器可能会将 flag == 0 优化为一个死循环，因为它认为 flag 的值不会改变。

2.2 硬件寄存器访问

与硬件交互时，寄存器的值可能在程序之外发生变化，必须使用 volatile 确保程序访问到最新值。

#define STATUS_REGISTER *((volatile int *)0x40000000)

void checkStatus() {
    while ((STATUS_REGISTER & 0x01) == 0) {
        // 等待硬件设置状态寄存器的第 0 位
    }
    // 状态已改变
}

2.3 中断服务程序 (ISR)

中断服务程序可能会修改主程序中的变量，因此这些变量需要声明为 volatile。

volatile int timer_flag = 0;

void ISR() {
    timer_flag = 1;  // 中断发生时修改变量
}

int main() {
    while (timer_flag == 0) {
        // 等待中断
    }
    // 中断已发生
    return 0;
}

3、`volatile` 的特性与限制

作用：告诉编译器变量可能会被外部事件（硬件或线程）修改，因此每次访问变量时必须从内存中读取。

内存可见性：volatile 保证了 单线程环境 中的变量内存可见性，即从内存中读取最新值，但 不提供线程安全性（需要配合锁或原子操作）。

无法保证线程安全：
volatile 仅保证变量值从内存中读取，但无法保证多个线程对同一变量的原子操作。例如：

volatile int counter = 0;

void increment() {
    counter++;  // 非线程安全，可能发生数据竞争
}

此时需要使用 互斥锁 。

无法控制操作顺序：
例如在多核处理器中，内存屏障（memory barrier）需要单独使用，volatile 无法确保操作的顺序。

4、`volatile` 的用法

4.1修饰普通变量

volatile int counter = 0;

void modifyCounter() {
    counter++;  // 确保每次操作都从内存读取
}

4.2 修饰指针

指针本身是 volatile：

int * volatile p;

含义：指针地址可能发生变化，但指针指向的值可以改变。

指针指向的值是 volatile：

volatile int *p;

含义：指针指向的值是可变的，必须从内存读取。

指针本身和指向的值都是 volatile：

volatile int * volatile p;

含义：指针本身和指针指向的值都可能被外部修改。

4.3缓存优化问题

假设没有使用 volatile：

int flag = 0;

void waitForFlag() {
    while (flag == 0) {
        // 循环等待
    }
}

在某些编译器中，while (flag == 0) 可能被优化为：

if (flag == 0) {
    while (true) {} // 死循环
}

因为编译器假定 flag 不会被外部修改。

添加 volatile 后：

volatile int flag = 0;

void waitForFlag() {
    while (flag == 0) {
        // 每次读取最新的 flag 值
    }
}

4.4硬件寄存器问题

#define STATUS_REG *((volatile int *)0x40000000)

void pollStatus() {
    while ((STATUS_REG & 0x01) == 0) {
        // 等待硬件设置状态寄存器的第 0 位
    }
}

如果没有 volatile，编译器可能优化为：

int reg = STATUS_REG;
while ((reg & 0x01) == 0) {
    // 死循环，无法感知硬件变化
}

5、小结

注意事项：

对于需要确保线程安全的操作，需要配合 互斥锁 或 原子操作。
硬件编程中，寄存器值必须声明为 volatile，否则可能导致严重的逻辑错误。

volatile 是嵌入式系统和并发编程中不可或缺的关键字，在适当的场景下使用它能够显著提高代码的正确性和健壮性。