C++ 基础知识（二）：volatile、static、inline 等核心概念详解

C++ 基础知识（二）：volatile、static、inline 等核心概念详解 | 极客日志

// 硬件寄存器：GPIOA 的输出数据寄存器（地址固定）
#define GPIOA_ODR (*(volatile uint32_t*)0x40020014)
void led_toggle() {
    // 必须用 volatile：GPIOA_ODR 的值可能被硬件修改，且每次读写都要直接操作内存
    GPIOA_ODR ^= (1 << 5); // 翻转 PA5 引脚电平（控制 LED）
}

#include <iostream>
#include <signal.h>
#include <unistd.h>

// 信号标志位：必须用 volatile 修饰，否则编译器会优化掉对它的读取
volatile sig_atomic_t stop_flag = 0;

// 信号处理函数：异步修改 stop_flag
void handle_sigint(int sig) {
    stop_flag = 1;
}

int main() {
    signal(SIGINT, handle_sigint); // 注册 Ctrl+C 信号处理函数
    // 主循环：检测 stop_flag 是否被修改
    while (!stop_flag) {
        std::cout << "运行中...按 Ctrl+C 停止" << std::endl;
        sleep(1);
    }
    std::cout << "程序停止" << std::endl;
    return 0;
}

// 测试空循环耗时：如果不加 volatile，编译器会直接优化掉整个循环
volatile int i;
for (i = 0; i < 100000000; i++);

// 多线程中错误使用 volatile
volatile int count = 0;

// 线程 1
void thread1() {
    for (int i=0; i<10000; i++) count++; // 非原子操作，会导致计数错误
}

// 线程 2
void thread2() {
    for (int i=0; i<10000; i++) count++;
}

// 在.cpp 文件中定义（不要写在头文件！）
static int g_static_num = 10; // static 全局变量

// file1.cpp
static int num = 10; // 仅 file1.cpp 可见
void func1() { num++; }

// file2.cpp
static int num = 20; // 仅 file2.cpp 可见，和 file1 的 num 互不干扰
void func2() { num++; }

// 在.cpp 文件中定义
static int add(int a, int b) { // static 函数
    return a + b;
}

// main.cpp
extern int max(int a, int b); // 声明
int main() {
    max(3,5); // 链接错误：undefined reference to 'max(int, int)'
    return 0;
}

// math1.cpp
static int max(int a, int b) {
    return a > b ? a : b;
} // 仅 math1.cpp 可用

// math2.cpp
static int max(int a, int b) {
    return a >= b ? a : b;
} // 仅 math2.cpp 可用

// 头文件：MyClass.h
class MyClass {
public:
    // 类内声明 static 成员变量
    static int count; // 统计对象创建的数量
};

// 源文件：MyClass.cpp
// 类外初始化（必须！否则链接错误）
int MyClass::count = 0; // 初始化值可选，默认 0

class MyClass {
    // C++17 前合法（const static 整型）
    const static int MAX = 100;
    // C++17 后合法（inline static）
    inline static int min = 0;
};

class MyClass {
    int a; // 普通成员（4 字节）
    static int b; // static 成员（不占对象内存）
};
cout << sizeof(MyClass) << endl; // 输出 4，仅包含普通成员 a

#include "MyClass.h"
int main() {
    MyClass obj1;
    MyClass::count++; // 通过类名访问（推荐）
    MyClass obj2;
    obj2.count++; // 也可通过对象访问（不推荐）
    // obj1 和 obj2 共享 count，此时 count=2
    cout << MyClass::count << endl; // 输出 2
    return 0;
}

// 头文件：MyClass.h
class MyClass {
public:
    // 类内声明 static 成员函数
    static void print_count();
    static int add(int a, int b); // 工具类静态函数
private:
    static int count; // 静态成员变量
};

// 源文件：MyClass.cpp
#include "MyClass.h"
int MyClass::count = 0; // 类外实现 static 成员函数（无需加 static！）
void MyClass::print_count() {
    cout << "对象数量：" << count << endl; // 可访问静态成员变量
    // cout << a << endl; // 错误：不能访问非静态成员（无 this 指针）
}
int MyClass::add(int a, int b) {
    return a + b;
}

// 单例模式示例
class Singleton {
private:
    static Singleton* instance;
    Singleton() {}
public:
    // 静态函数：全局唯一获取实例的入口
    static Singleton* get_instance() {
        if (instance == nullptr) {
            instance = new Singleton();
        }
        return instance;
    }
};
Singleton* Singleton::instance = nullptr;

#include "MyClass.h"
int main() {
    // 直接通过类名调用（推荐）
    MyClass::print_count(); // 输出 0
    int sum = MyClass::add(3,5); // 输出 8
    // 也可通过对象调用（不推荐，易混淆）
    MyClass obj;
    obj.print_count();
    return 0;
}

// 加了 inline，但编译器不会内联（递归）
inline int factorial(int n) {
    if (n == 0) return 1;
    return n * factorial(n-1); // 递归调用
}

// 加了 inline，但取地址后无法内联
inline int add(int a, int b) {
    return a + b;
}
int main() {
    // 取 add 的地址，编译器必须保留函数的实际地址，无法内联
    int (*func_ptr)(int, int) = add;
    func_ptr(3,5);
    return 0;
}

// 错误示例：头文件 my_math.h 中写普通函数实现
#ifndef MY_MATH_H
#define MY_MATH_H
// 普通函数实现写在头文件，多个.cpp 包含会重复定义
int add(int a, int b) {
    return a + b;
}
#endif

// 正确示例：头文件 my_math.h 中写 inline 函数实现
#ifndef MY_MATH_H
#define MY_MATH_H
// inline 函数：允许多个.cpp 包含，链接时不会重复定义
inline int add(int a, int b) {
    return a + b;
}
#endif

// 适合 inline 的小函数（编译器大概率会内联）
inline int min(int a, int b) {
    return a < b ? a : b;
}

// 头文件中定义类
class MyClass {
public:
    // 隐式 inline：无需手动加 inline，链接时不会重复定义
    void print() {
        std::cout << "hello" << std::endl;
    }
};

// 库 A 的代码（libA.h）
void print(const char* msg) { // 库 A 的打印逻辑
}

// 库 B 的代码（libB.h）
void print(const char* msg) { // 库 B 的打印逻辑
}

// 你的代码（main.cpp）
#include "libA.h"
#include "libB.h"
// 引入后，全局作用域有两个 print 函数
int main() {
    print("hello"); // 编译/链接错误：ambiguous reference to 'print'
    return 0;
}

// 库 A 的代码（libA.h）
namespace LibA {
    // 定义命名空间 LibA
    void print(const char* msg) {
        printf("LibA: %s\n", msg);
    }
}

// 库 B 的代码（libB.h）
namespace LibB {
    // 定义命名空间 LibB
    void print(const char* msg) {
        printf("LibB: %s\n", msg);
    }
}

// 你的代码（main.cpp）
#include "libA.h"
#include "libB.h"
int main() {
    LibA::print("hello"); // 调用 LibA 的 print，输出：LibA: hello
    LibB::print("hello"); // 调用 LibB 的 print，输出：LibB: hello
    return 0;
}

// 项目中的网络模块
namespace Network {
    // 网络相关常量
    constexpr int TIMEOUT = 5000;
    // 网络相关函数
    bool connect(const char* ip, int port);
    // 网络相关类
    class TcpClient {};
}

// 项目中的工具模块
namespace Utils {
    // 工具相关函数
    std::string to_string(int num);
    // 工具相关类
    class Logger {};
}

// 调用时一目了然
int main() {
    Network::connect("127.0.0.1", 8080);
    Utils::Logger::log("连接成功");
    return 0;
}

// 旧版本
namespace MyLib_v1 {
    int add(int a, int b) {
        return a + b;
    }
}

// 新版本
namespace MyLib_v2 {
    int add(int a, int b) {
        return (a + b) * 2;
    }
}

// 按需使用
int main() {
    MyLib_v1::add(3,5); // 8
    MyLib_v2::add(3,5); // 16
    return 0;
}

#include <iostream>

// 方式 1：using 声明（推荐）——仅引入特定符号
using std::cout;
using std::endl;
cout << "hello" << endl; // 无需写 std::

// 方式 2：using 指令（谨慎使用）——引入整个命名空间
using namespace std;
cout << "hello" << endl; // 更简洁，但可能引发冲突

// 方式 3：命名空间别名（简化长命名空间）
namespace Net = Network;
Net::connect("127.0.0.1", 8080);

// 自定义 string 类（全局作用域）
class string {
    // 自己的实现
};
int main() {
    string my_str; // 调用自定义 string
    std::string std_str; // 调用标准库 string
    return 0;
}

// 语法：#define 标识符 替换文本
#define PI 3.1415926 // 常量别名（文本替换）
#define INT_PTR int* // 试图定义指针类型别名
#define MAX(a,b) ((a)>(b)?(a):(b)) // 宏函数（文本替换）
int main() {
    double area = PI * 2 * 2; // 预处理后：3.1415926 * 2 * 2
    INT_PTR a, b; // 预处理后：int* a, b; → 坑！a 是 int*，b 是 int
    int max_val = MAX(3,5); // 预处理后：((3)>(5)?(3):(5))
    return 0;
}

// 语法：typedef 原类型 别名;
typedef int Int; // 内置类型别名
typedef int* IntPtr; // 指针类型别名
typedef std::vector<int> IntVec;// 自定义/库类型别名

// 结构体/类别名（C 风格常用）
typedef struct {
    int x;
    int y;
} Point;

int main() {
    Int a = 10; // 等价于 int a=10
    IntPtr p1, p2; // 等价于 int* p1, int* p2（无替换陷阱）
    IntVec vec = {1,2,3}; // 等价于 std::vector<int> vec
    Point pt = {1,2}; // 等价于 struct {int x;int y;} pt
    return 0;
}

// 语法：using 别名 = 原类型;
using Int = int; // 等价于 typedef int Int;
using IntPtr = int*; // 等价于 typedef int* IntPtr;
using IntVec = std::vector<int>;// 等价于 typedef std::vector<int> IntVec;
int main() {
    Int a = 10;
    IntPtr p = &a;
    return 0;
}

// 模板别名：定义'任意类型的 vector 指针'别名
template <typename T>
using VecPtr = std::vector<T>*;

int main() {
    VecPtr<int> p1 = new std::vector<int>{1,2,3}; // 等价于 std::vector<int>* p1
    VecPtr<std::string> p2 = new std::vector<std::string>{"a","b"}; // 等价于 std::vector<string>* p2
    return 0;
}

// 函数指针类型：返回 int，参数为 int 和 int
// typedef 写法（反向，可读性差）：
// typedef int (*FuncPtr)(int, int);

// using 写法（正向，可读性好）：
using FuncPtr = int (*)(int, int);

int add(int a, int b) {
    return a+b;
}

int main() {
    FuncPtr fp = add;
    fp(3,5); // 输出 8
    return 0;
}

特性	`#define`	`typedef`	`using`（C++11）
处理阶段	预处理阶段（文本替换）	编译阶段（类型别名）	编译阶段（类型别名）
类型检查	无（替换后才检查）	有	有
文本替换陷阱	有（如指针别名）	无	无
作用域限制	无（全局替换）	有（全局/命名空间/类内）	有（同 typedef）
模板别名支持	不支持	不支持	支持（核心优势）
语法可读性	差（无类型语义）	中（反向语法）	优（正向语法）
适用场景	简单常量/文本替换	普通类型别名（C++03 及前）	所有类型别名（现代 C++ 首选）

#include <iostream>
using namespace std;
int main() {
    int a = 10;
    // sizeof 在编译期计算，a++不会执行（a 仍为 10）
    size_t s = sizeof(a++);
    cout << "sizeof(a++) = " << s << endl; // 输出 4（int 的大小）
    cout << "a = " << a << endl; // 输出 10（a++未执行）
    string str = "hello world";
    // sizeof(string)和字符串长度无关，编译期确定（如 64 位系统占 32 字节）
    cout << "sizeof(str) = " << sizeof(str) << endl;
    return 0;
}

#include <iostream>
#include <vector>
using namespace std;
int main() {
    vector<int> v1; // 空 vector
    vector<int> v2{1,2,3,4}; // 含 4 个元素的 vector
    vector<string> v3; // 存储 string 的 vector
    // 64 位系统下，三者的 sizeof 均为 24（和元素无关）
    cout << "sizeof(v1) = " << sizeof(v1) << endl; // 24
    cout << "sizeof(v2) = " << sizeof(v2) << endl; // 24
    cout << "sizeof(v3) = " << sizeof(v3) << endl; // 24
    return 0;
}

#include <iostream>
using namespace std;
int main() {
    char* p1 = "hello";
    int* p2 = nullptr;
    vector<int>* p3 = new vector<int>();
    // 64 位系统下，三者的 sizeof 均为 8
    cout << "sizeof(char*) = " << sizeof(p1) << endl; // 8
    cout << "sizeof(int*) = " << sizeof(p2) << endl; // 8
    cout << "sizeof(vector<int>*) = " << sizeof(p3) << endl; // 8
    return 0;
}

class Empty {}; // 空类
Empty a, b; // 若 sizeof(Empty)=0，a 和 b 会占用同一个地址，违反标准

class Base {}; // sizeof(Base)=1
class Derived : public Base {}; // sizeof(Derived)=1（仍为 1 字节，未额外占用）

class A {}; // sizeof(A)=1
class B { int num; }; // sizeof(B)=4（int 占 4 字节，占位符被覆盖）
class C { A a; int b; }; // sizeof(C)=8（A 的 1 字节 +3 字节填充+int4 字节，内存对齐）

// 示例 1：struct 的默认 public
struct S {
    int num; // 默认 public，外部可直接访问
    void print() { // 默认 public，外部可直接调用
        cout << num << endl;
    }
};

// 示例 2：class 的默认 private
class C {
    int num; // 默认 private，外部无法直接访问
    void print() { // 默认 private，外部无法直接调用
        cout << num << endl;
    }
};

int main() {
    S s;
    s.num = 10; // 合法：struct 成员默认 public
    s.print(); // 合法
    C c;
    c.num = 10; // 错误：class 成员默认 private，外部不可访问
    c.print(); // 错误
    return 0;
}

// 基类：含 public 成员
struct Base {
    int num = 10;
};

// 示例 1：struct 继承 Base → 默认 public 继承
struct DerivedS : Base {};

// 示例 2：class 继承 Base → 默认 private 继承
class DerivedC : Base {};

int main() {
    DerivedS ds;
    ds.num = 20; // 合法：public 继承，基类 public 成员仍为 public
    DerivedC dc;
    dc.num = 20; // 错误：private 继承，基类 public 成员变为 private
    return 0;
}

// 存储坐标数据：仅数据，无复杂逻辑，用 struct
struct Point {
    int x;
    int y;
    // 可选：简单的辅助函数（如计算距离）
    double distance(const Point& other) {
        return sqrt(pow(x-other.x,2) + pow(y-other.y,2));
    }
};

// 面向对象的类：封装数据和行为，隐藏实现
class Circle {
private:
    double radius; // 私有数据，外部不可直接修改
public:
    Circle(double r) : radius(r) {}
    double get_area() const { // 对外接口：计算面积
        return M_PI * radius * radius;
    }
    void set_radius(double r) { // 对外接口：修改半径（可加校验）
        if (r > 0) radius = r;
    }
};

// struct 也可以有虚函数、继承，实现多态
struct Shape {
    virtual double get_area() const = 0; // 纯虚函数
    virtual ~Shape() = default;
};

struct Rectangle : Shape {
    // struct 继承 struct
    int width, height;
    double get_area() const override { // 重写虚函数
        return width * height;
    }
};

int main() {
    Shape* s = new Rectangle{3,4};
    cout << s->get_area() << endl; // 输出 12，多态生效
    delete s;
    return 0;
}

#include <iostream>
using namespace std;

// 定义 union：包含 char(1 字节)、int(4 字节)、double(8 字节)
union Data {
    char c; // 1 字节
    int i; // 4 字节
    double d; // 8 字节
};

int main() {
    Data u;
    // 1. 所有成员的首地址相同
    cout << "union 起始地址：" << &u << endl;
    cout << "char c 地址：" << &u.c << endl;
    cout << "int i 地址：" << &u.i << endl;
    cout << "double d 地址：" << &u.d << endl;
    // 输出：所有地址完全一致
    
    // 2. 内存大小：最大成员是 double(8 字节)，对齐要求 8 字节 → 总大小 8
    cout << "sizeof(Data) = " << sizeof(Data) << endl; // 输出 8（64 位/32 位均为 8）
    
    // 3. 成员覆盖：修改一个成员会影响其他成员
    u.c = 'A'; // 给 c 赋值（ASCII 码 65）
    cout << "u.c = " << u.c << endl; // 输出 A
    cout << "u.i = " << u.i << endl; // 输出 65（低字节是 65，高字节为 0）
    
    u.i = 0x12345678; // 给 i 赋值（4 字节）
    cout << "u.i = " << hex << u.i << endl; // 输出 12345678
    cout << "u.c = " << dec << (int)u.c << endl; // 输出 120（0x78 的十进制，仅低字节有效）
    
    u.d = 3.1415926; // 给 d 赋值（8 字节）
    cout << "u.d = " << u.d << endl; // 输出 3.1415926
    cout << "u.i = " << hex << u.i << endl; // 输出垃圾值（被 double 覆盖）
    return 0;
}

// 示例：union 包含 char(1)、short(2)、int(4)
union AlignTest {
    char a; // 1 字节，对齐要求 1
    short b; // 2 字节，对齐要求 2
    int c; // 4 字节，对齐要求 4
};
// 最大成员是 int(4)，对齐要求 4 → 总大小 4
cout << sizeof(AlignTest) << endl; // 输出 4

// 示例：union 包含 char(1)、long long(8)
union AlignTest2 {
    char x; // 1 字节
    long long y; // 8 字节，对齐要求 8
};
// 最大成员 8，对齐要求 8 → 总大小 8
cout << sizeof(AlignTest2) << endl; // 输出 8

// 示例：union 包含 char(1)、struct（需对齐）
struct Sub {
    char a;
    int b; // struct Sub 的大小：1+3 填充 +4=8，对齐要求 4
};
union AlignTest3 {
    char x;
    Sub s; // Sub 大小 8，对齐要求 4
};
// 最大成员 8，对齐要求 4 → 总大小 8
cout << sizeof(AlignTest3) << endl; // 输出 8

union U {
    int i;
    float f;
};
U u;
u.i = 0x41480000; // 手动赋值 float 12.0 的二进制表示
cout << u.f << endl; // 输出 12.0（合法：手动控制内存布局）

int main() {
    // 匿名 union
    union {
        int i;
        char c;
    };
    i = 100;
    cout << c << endl; // 输出 d（ASCII 100）
    return 0;
}

特性	union（共用体）	struct（结构体）
内存布局	所有成员共享同一块内存	成员按顺序叠加存储（各占独立空间）
总大小	最大成员大小 + 对齐填充	所有成员大小之和 + 对齐填充
成员有效性	同一时间仅一个成员有效	所有成员同时有效
地址特性	所有成员首地址相同	成员首地址依次递增

// struct：叠加存储，大小=1+3 填充 +4=8
struct S {
    char c;
    int i;
};
cout << sizeof(S) << endl; // 输出 8

// union：共享存储，大小=4（最大成员 int）
union U {
    char c;
    int i;
};
cout << sizeof(U) << endl; // 输出 4

C++ 基础知识（二）：volatile、static、inline 等核心概念详解

8.1、先搞懂：volatile 的核心语义（为什么它没被淘汰）

8.2、现代编程中 volatile 的核心意义（适用场景）

1、嵌入式/硬件编程（最核心、不可替代）

2、信号处理（Unix/Linux 编程）

3、内存映射 I/O、进程间共享内存

4、避免编译器优化掉'看似无用'的代码

8.3、为什么有人觉得 volatile'没用'？（核心误区）

8.4、现代 C++ 对 volatile 的补充（没有废弃，反而增强）

九、static 关键字

9.1、static 修饰全局变量

1、核心含义

2、语法

3、关键特性 & 示例

9.1、static 修饰函数

1、核心含义

2、语法

3、关键特性 & 示例

9.3、static 修饰类成员（静态成员变量）

1、核心含义

2、语法（必须'类内声明，类外初始化'）

3、关键特性 & 示例

9.4、static 修饰类成员函数（静态成员函数）

1、核心含义

2、语法

3、关键特性 & 示例

十、inline 一定会内联吗？inline 的真正作用是什么？

10.1、先澄清：inline 不一定会让函数'内联展开'

1、什么是'内联展开'（新手的直观认知）

2、编译器拒绝内联的常见场景

10.2、inline 的真正核心作用：改变链接属性，解决重复定义

1、回顾之前的痛点：头文件写函数实现会报重复定义

2、inline 如何解决这个问题？（核心作用）

10.3、inline 的使用场景（结合核心作用）

1、头文件中定义函数（核心场景）

2、给编译器提供'内联优化建议'（次要场景）

3、类内定义的成员函数（隐式 inline）

10.4、关键误区澄清

十一、C++ 为什么要有命名空间？

11.1、核心根源：没有命名空间的'命名污染'灾难

11.2、命名空间的核心作用：划分作用域，隔离名字

1、解决名字冲突（最核心价值）

2、模块化管理代码（工程化价值）

3、兼容旧代码/版本控制

4、简化代码（using 声明/指令）

11.3、C++ 标准库的 std 命名空间（最典型应用）

11.4、关键注意事项

十二、using alias define 和 typedef 是什么以及它们的区别

12.1、先明确每个概念的定义、语法和特性

1、#define：预处理阶段的'文本替换'（非真正的类型别名）

2、核心特性

12.2、typedef：C 风格的'类型别名'（编译期，有类型检查）

1、语法 & 示例

2、核心特性

12.3、using（C++11）：现代版'类型别名'（typedef 的超集）

1、普通类型别名（和 typedef 等价，语法更清晰）

2、模板别名（typedef 无法实现，核心优势）

3、函数指针别名（可读性远优于 typedef）

4、核心特性

12.4、核心区别对比表

12.5、关键注意事项

十三、sizeof 关键字

13.1、sizeof 是运行期还是编译期？

13.2、sizeof (vector) 是多少？

13.3、sizeof (char") 是多少？

13.4、为什么空类的 sizeof 是 1？

十四、struct 和 class 的区别

14.1、核心语法区别（仅 2 点，最关键）

1、默认访问权限（最核心区别）

2、默认继承方式

14.2、语义层面的约定（工程实践，非语法规则）

1、struct：侧重'数据聚合'（C 风格延续）

2、class：侧重'面向对象封装'

14.3、澄清误区：struct 和 class 完全一致的特性

十五、union 的内存模型

15.1、union 的核心内存模型：共享式存储

1、所有成员共享同一段内存，首地址完全相同

2、同一时间只有一个成员'有效'

15.2、union 内存模型的关键规则（附示例）

1、内存大小计算规则

九、`static 关键字`

`十、`inline 一定会内联吗？inline 的真正作用是什么？

1、`#define`：预处理阶段的'文本替换'（非真正的类型别名）

12.2、`typedef`：C 风格的'类型别名'（编译期，有类型检查）

12.3、`using`（C++11）：现代版'类型别名'（typedef 的超集）