网站需要多大的空间,做网站网站庄家,用html做班级网站,网站建设的种类目录
一、static
1、static 修饰局部变量 2、 static 修饰全局变量
3、static 修饰函数
4、static 修饰类成员
5、小结
二、const
1、const 修饰普通变量
2、const 修饰指针
3、const 修饰函数参数
4. const 修饰函数返回值
5. const 修饰类成员
6. const 与 #defi…目录
一、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: 1counter(); // 输出Count: 2counter(); // 输出Count: 3return 0;
}
分析
count 是静态局部变量第一次调用时初始化为 0。每次调用 counter 函数后count 的值都会被保留而不是销毁。如果没有 staticcount 每次调用都会重新初始化为 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; // 输出3return 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 是嵌入式系统和并发编程中不可或缺的关键字在适当的场景下使用它能够显著提高代码的正确性和健壮性。
