第10章 内存模型和名称空间

内存模型

内存区域

C++程序的内存通常分为以下几个区域：

  1. 代码区（Text Segment）：存储程序的可执行指令
  2. 全局/静态区（Data Segment）：存储全局变量和静态变量
  3. 常量区（Constant Area）：存储常量数据
  4. 堆区（Heap）：动态分配的内存，由程序员管理
  5. 栈区（Stack）：存储局部变量和函数参数，由编译器自动管理

内存布局详细信息

内存区域详解

  1. 代码区（Text Segment）：

    • 存储程序的可执行指令
    • 通常是只读的，防止程序意外修改指令
    • 包含函数体的二进制代码
    • 大小在编译时确定

  2. 常量区（Constant Area）：

    • 存储常量数据，如字符串字面量、const变量
    • 通常是只读的
    • 字符串字面量存储在这里
    • 大小在编译时确定

  3. 全局/静态区（Data Segment）：

    • 初始化数据区（Initialized Data Segment）：存储已初始化的全局变量和静态变量
    • 未初始化数据区（BSS Segment）：存储未初始化的全局变量和静态变量，程序启动时会被初始化为0
    • 大小在编译时确定

  4. 堆区（Heap）：

    • 动态分配的内存，由程序员管理
    • 向上生长（地址从低到高）
    • 大小在运行时动态变化
    • 由内存分配器管理（如malloc/free、new/delete）

  5. 栈区（Stack）：

    • 存储局部变量、函数参数、返回地址
    • 向下生长（地址从高到低）
    • 大小在编译时确定（但可配置）
    • 由编译器自动管理，函数调用时分配，函数返回时释放

  6. 命令行参数和环境变量：

    • 存储命令行参数和环境变量
    • 位于栈区之上

内存布局示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
高地址
┌─────────────────────────────────────────┐
│           命令行参数和环境变量           │
├─────────────────────────────────────────┤
│                 栈区                    │
│           （向下生长）                   │
│  ┌─────────────────────────────────────┐ │
│  │  函数返回地址                       │ │
│  ├─────────────────────────────────────┤ │
│  │  函数参数                           │ │
│  ├─────────────────────────────────────┤ │
│  │  局部变量                           │ │
│  └─────────────────────────────────────┘ │
├─────────────────────────────────────────┤
│                 堆区                    │
│           （向上生长）                   │
│  ┌─────────────────────────────────────┐ │
│  │  动态分配的内存块                   │ │
│  ├─────────────────────────────────────┤ │
│  │  动态分配的内存块                   │ │
│  └─────────────────────────────────────┘ │
├─────────────────────────────────────────┤
│             全局/静态区                  │
│  ┌─────────────────────────────────────┐ │
│  │  初始化的全局变量和静态变量         │ │
│  ├─────────────────────────────────────┤ │
│  │  未初始化的全局变量和静态变量（BSS） │ │
│  └─────────────────────────────────────┘ │
├─────────────────────────────────────────┤
│             常量区                      │
│  ┌─────────────────────────────────────┐ │
│  │  字符串字面量                       │ │
│  ├─────────────────────────────────────┤ │
│  │  const 全局变量                     │ │
│  └─────────────────────────────────────┘ │
├─────────────────────────────────────────┤
│             代码区                      │
│  ┌─────────────────────────────────────┐ │
│  │  函数体的二进制代码                 │ │
│  └─────────────────────────────────────┘ │
└─────────────────────────────────────────┘
低地址

内存对齐

内存对齐是指变量在内存中的存储位置必须是其大小的整数倍，这是为了提高内存访问效率：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// 内存对齐示例
struct Example {
    char c;     // 1字节
    int i;      // 4字节（通常对齐到4字节边界）
    double d;   // 8字节（通常对齐到8字节边界）
};

// 结构体大小计算
// 在32位系统上，通常大小为16字节（1+3填充+4+8）
// 在64位系统上，通常大小为16字节（1+7填充+8）
std::cout << sizeof(Example) << std::endl;

// 强制对齐
#pragma pack(push, 1) // 按1字节对齐
struct PackedExample {
    char c;
    int i;
    double d;
};
#pragma pack(pop)

// 大小为13字节（1+4+8）
std::cout << sizeof(PackedExample) << std::endl;

不同类型变量的存储位置

变量类型存储位置生命周期作用域
全局变量全局/静态区程序开始到结束全局
静态全局变量全局/静态区程序开始到结束文件
静态局部变量全局/静态区程序开始到结束局部
局部变量栈区函数调用到返回局部
函数参数栈区函数调用到返回函数参数
动态分配变量堆区手动分配到释放指针作用域
字符串字面量常量区程序开始到结束全局
const 全局变量常量区程序开始到结束全局
const 局部变量栈区（通常）函数调用到返回局部

存储类别

auto 存储类别

  • 默认存储类别：局部变量的默认存储类别
  • 生命周期：函数调用时创建，函数返回时销毁
  • 作用域：局部作用域（定义它的代码块）
  • 可见性：只在定义它的代码块内可见
1
2
3
4
void function() {
    auto int x = 10; // 等同于 int x = 10;
    int y = 20; // 默认是 auto 存储类别
}

static 存储类别

  • 生命周期：程序开始时创建，程序结束时销毁
  • 作用域：
    • 全局静态变量：文件作用域
    • 局部静态变量：局部作用域
  • 可见性：
    • 全局静态变量：只在定义它的文件内可见
    • 局部静态变量：只在定义它的代码块内可见
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// 全局静态变量
static int globalStatic = 100;

void function() {
    // 局部静态变量
    static int localStatic = 0;
    localStatic++;
    std::cout << "Local static: " << localStatic << std::endl;
}

int main() {
    function(); // 输出 1
    function(); // 输出 2
    function(); // 输出 3
    return 0;
}

extern 存储类别

  • 生命周期：程序开始时创建，程序结束时销毁
  • 作用域：全局作用域
  • 可见性：整个程序可见（通过声明）
1
2
3
4
5
6
7
8
9
// file1.cpp
extern int globalVar; // 声明外部变量

void function() {
    std::cout << globalVar << std::endl;
}

// file2.cpp
int globalVar = 100; // 定义全局变量

register 存储类别

  • 生命周期：同 auto 存储类别
  • 作用域：同 auto 存储类别
  • 可见性：同 auto 存储类别
  • 特点：建议编译器将变量存储在寄存器中，以提高访问速度
1
2
3
4
5
6
7
void function() {
    register int counter = 0; // 建议存储在寄存器中
    // 频繁使用的变量
    for (int i = 0; i < 1000000; i++) {
        counter++;
    }
}

注意：现代编译器会自动优化变量存储，register 关键字的作用已经不大。

C++20新特性：constinit和consteval

constinit关键字

constinit关键字确保变量在编译时初始化，避免了静态初始化顺序问题：

1
2
3
4
5
6
7
8
9
10
11
12
13
// 全局变量，在编译时初始化
constinit int global_value = 42;

// 静态变量，在编译时初始化
void function() {
    static constinit int static_value = 100;
}

// 注意：constinit只保证初始化在编译期，不保证变量是const
constinit int counter = 0;
void increment() {
    counter++; // 正确，counter不是const
}

consteval关键字

consteval关键字用于函数，表示该函数必须在编译时执行：

1
2
3
4
5
6
7
8
9
10
11
// consteval函数
consteval int factorial(int n) {
    return n <= 1 ? 1 : n * factorial(n - 1);
}

// 编译期计算
constexpr int result = factorial(5); // 正确，编译期计算

// 运行期计算会报错
// int n = 5;
// int result = factorial(n); // 错误，n是运行期变量

作用域

全局作用域

  • 定义：在所有函数外部定义的标识符
  • 可见性：从定义点开始，到文件结束
  • 生命周期：程序开始到程序结束
1
2
3
4
5
6
7
8
9
10
11
int globalVar = 100; // 全局作用域

void function() {
    std::cout << globalVar << std::endl; // 可以访问
}

int main() {
    std::cout << globalVar << std::endl; // 可以访问
    function();
    return 0;
}

局部作用域

  • 定义：在函数内部定义的标识符
  • 可见性：从定义点开始，到函数结束
  • 生命周期：函数调用开始到函数返回
1
2
3
4
5
6
7
8
9
10
void function() {
    int localVar = 50; // 局部作用域
    std::cout << localVar << std::endl; // 可以访问
}

int main() {
    // std::cout << localVar << std::endl; // 错误：不可访问
    function();
    return 0;
}

块作用域

  • 定义：在代码块内部定义的标识符
  • 可见性：从定义点开始，到代码块结束
  • 生命周期：代码块开始执行到代码块执行结束
1
2
3
4
5
6
7
8
void function() {
    int x = 10;
    {
        int y = 20; // 块作用域
        std::cout << x << " " << y << std::endl; // 可以访问
    }
    // std::cout << y << std::endl; // 错误：不可访问
}

函数原型作用域

  • 定义：函数原型中的参数名
  • 可见性：只在函数原型中可见
1
2
3
4
5
void function(int x); // x 是函数原型作用域

void function(int y) { // y 是局部作用域
    std::cout << y << std::endl;
}

类作用域

  • 定义：类的成员
  • 可见性：通过类的对象或类名访问
1
2
3
4
5
6
7
8
9
10
11
12
13
14
class MyClass {
public:
    int memberVar; // 类作用域
    void memberFunc() { // 类作用域
        std::cout << memberVar << std::endl;
    }
};

int main() {
    MyClass obj;
    obj.memberVar = 100; // 通过对象访问
    obj.memberFunc(); // 通过对象访问
    return 0;
}

命名空间作用域

  • 定义：在命名空间中定义的标识符
  • 可见性：通过命名空间名或 using 声明访问
1
2
3
4
5
6
7
8
namespace MyNamespace {
    int namespaceVar = 200; // 命名空间作用域
}

int main() {
    std::cout << MyNamespace::namespaceVar << std::endl; // 通过命名空间名访问
    return 0;
}

链接性

外部链接性

  • 定义：可以在多个文件中访问的标识符
  • 示例：非静态的全局变量和函数
1
2
3
4
5
6
7
8
// file1.cpp
int globalVar = 100; // 外部链接性

// file2.cpp
extern int globalVar; // 声明外部变量
void function() {
    std::cout << globalVar << std::endl; // 可以访问
}

内部链接性

  • 定义：只能在定义它的文件中访问的标识符
  • 示例：静态全局变量和静态函数
1
2
3
4
5
// file1.cpp
static int staticGlobalVar = 200; // 内部链接性

// file2.cpp
extern int staticGlobalVar; // 错误：不可访问，因为它是内部链接性

无链接性

  • 定义：只能在定义它的作用域中访问的标识符
  • 示例：局部变量和函数参数
1
2
3
4
5
6
7
8
9
void function() {
    int localVar = 300; // 无链接性
}

int main() {
    // std::cout << localVar << std::endl; // 错误：不可访问
    function();
    return 0;
}

动态内存管理

堆内存分配

new 运算符

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
// 分配单个对象
int* pInt = new int;
*pInt = 100;
std::cout << *pInt << std::endl;

// 分配并初始化
int* pInt2 = new int(200);
std::cout << *pInt2 << std::endl;

// 分配数组
int* pArray = new int[5];
for (int i = 0; i < 5; i++) {
    pArray[i] = i;
}

// 分配并初始化数组（C++11+）
int* pArray2 = new int[5]{1, 2, 3, 4, 5};

// 分配对象
class MyClass {
public:
    MyClass(int v) : value(v) {}
    int value;
};

MyClass* pObj = new MyClass(300);
std::cout << pObj->value << std::endl;

delete 运算符

1
2
3
4
5
6
7
8
9
10
11
// 释放单个对象
delete pInt;
pInt = nullptr; // 避免悬空指针

// 释放数组
delete[] pArray;
pArray = nullptr; // 避免悬空指针

// 释放对象
delete pObj;
pObj = nullptr; // 避免悬空指针

常见的动态内存错误

内存泄漏

1
2
3
4
5
6
7
8
9
10
11
12
13
// 错误：内存泄漏
void function() {
    int* p = new int(100);
    // 没有 delete p;
}

// 正确：释放内存
void function() {
    int* p = new int(100);
    // 使用 p
    delete p;
    p = nullptr;
}

悬空指针

1
2
3
4
5
6
7
8
9
10
11
12
13
// 错误：悬空指针
int* p = new int(100);
delete p;
// p 现在是悬空指针
std::cout << *p << std::endl; // 未定义行为

// 正确：设置为 nullptr
int* p = new int(100);
delete p;
p = nullptr; // 避免悬空指针
if (p != nullptr) {
    std::cout << *p << std::endl; // 不会执行
}

重复释放

1
2
3
4
5
6
7
8
9
10
// 错误：重复释放
int* p = new int(100);
delete p;
delete p; // 未定义行为

// 正确：释放后设置为 nullptr
int* p = new int(100);
delete p;
p = nullptr;
delete p; // 安全，delete nullptr 是合法的

数组和单个对象释放混淆

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 错误：使用 delete 释放数组
int* p = new int[5];
delete p; // 未定义行为

// 错误：使用 delete[] 释放单个对象
int* p = new int;
delete[] p; // 未定义行为

// 正确：匹配使用
int* pArray = new int[5];
delete[] pArray; // 正确

int* pObj = new int;
delete pObj; // 正确

智能指针（C++11+）

unique_ptr

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#include <memory>

// unique_ptr：独占所有权的智能指针
std::unique_ptr<int> p1(new int(100));
std::cout << *p1 << std::endl;

// 转移所有权
std::unique_ptr<int> p2 = std::move(p1);
// p1 现在为空
if (p1) {
    std::cout << *p1 << std::endl;
} else {
    std::cout << "p1 is empty" << std::endl;
}
std::cout << *p2 << std::endl;

// 使用 make_unique（C++14+）
auto p3 = std::make_unique<int>(200);
std::cout << *p3 << std::endl;

// 数组版本
auto pArray = std::make_unique<int[]>(5);
for (int i = 0; i < 5; i++) {
    pArray[i] = i;
}

shared_ptr

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// shared_ptr：共享所有权的智能指针
std::shared_ptr<int> p1(new int(100));
std::cout << *p1 << std::endl;
std::cout << "Use count: " << p1.use_count() << std::endl; // 1

// 复制，增加引用计数
std::shared_ptr<int> p2 = p1;
std::cout << "Use count: " << p1.use_count() << std::endl; // 2
std::cout << "Use count: " << p2.use_count() << std::endl; // 2

// 使用 make_shared
auto p3 = std::make_shared<int>(200);
std::cout << *p3 << std::endl;
std::cout << "Use count: " << p3.use_count() << std::endl; // 1

weak_ptr

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// weak_ptr：不增加引用计数的智能指针
std::shared_ptr<int> p1 = std::make_shared<int>(100);
std::weak_ptr<int> wp = p1; // 不增加引用计数
std::cout << "Use count: " << p1.use_count() << std::endl; // 1

// 检查 weak_ptr 是否有效
if (auto p2 = wp.lock()) { // lock() 返回 shared_ptr
    std::cout << *p2 << std::endl;
    std::cout << "Use count: " << p2.use_count() << std::endl; // 2
} else {
    std::cout << "wp is expired" << std::endl;
}

// 当所有 shared_ptr 被销毁后，weak_ptr 会过期
p1.reset();
if (auto p2 = wp.lock()) {
    std::cout << *p2 << std::endl;
} else {
    std::cout << "wp is expired" << std::endl;
}

名称空间

命名空间的定义

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
// 基本命名空间
namespace MyNamespace {
    int value = 100;
    void function() {
        std::cout << "MyNamespace::function()" << std::endl;
    }
}

// 嵌套命名空间
namespace Outer {
    int outerValue = 200;
    namespace Inner {
        int innerValue = 300;
    }
}

// 内联命名空间（C++11+）
inline namespace InlineNS {
    int inlineValue = 400;
}

// 匿名命名空间
namespace {
    int anonymousValue = 500; // 等同于 static int anonymousValue = 500;
}

命名空间的使用

作用域解析运算符

1
2
3
4
5
6
7
// 使用作用域解析运算符
std::cout << MyNamespace::value << std::endl;
MyNamespace::function();
std::cout << Outer::innerValue << std::endl; // 错误：需要指定完整路径
std::cout << Outer::Inner::innerValue << std::endl; // 正确
std::cout << InlineNS::inlineValue << std::endl;
std::cout << anonymousValue << std::endl; // 匿名命名空间的内容直接可见

using 声明

1
2
3
4
5
6
7
8
9
10
11
12
13
// using 声明
using MyNamespace::value;
using MyNamespace::function;

std::cout << value << std::endl; // 可以直接使用
function(); // 可以直接使用

// 多个 using 声明
using Outer::outerValue;
using Outer::Inner::innerValue;

std::cout << outerValue << std::endl;
std::cout << innerValue << std::endl;

using 指令

1
2
3
4
5
6
7
8
9
10
11
12
// using 指令
using namespace MyNamespace;

std::cout << value << std::endl; // 可以直接使用
function(); // 可以直接使用

// 多个 using 指令
using namespace Outer;
using namespace std; // 常用的 using 指令

cout << outerValue << endl;
cout << Inner::innerValue << endl;

命名空间的别名

1
2
3
4
5
6
// 命名空间别名
namespace MN = MyNamespace;
namespace OI = Outer::Inner;

std::cout << MN::value << std::endl;
std::cout << OI::innerValue << std::endl;

标准命名空间

1
2
3
4
5
6
7
8
9
10
11
// 标准命名空间 std
std::cout << "Hello, world!" << std::endl;

// 使用 using 声明
using std::cout;
using std::endl;
cout << "Hello, world!" << endl;

// 使用 using 指令
using namespace std;
cout << "Hello, world!" << endl;

注意：在头文件中应避免使用 using namespace std;，以防止命名冲突。

名称查找

名称查找规则

  1. 局部作用域：首先在当前作用域查找
  2. 外层作用域：如果局部作用域没有找到，在外层作用域查找
  3. 命名空间作用域：如果外层作用域没有找到，在使用的命名空间中查找
  4. 全局作用域：如果命名空间作用域没有找到，在全局作用域查找
  5. :: 作用域：如果指定了作用域解析运算符，则在指定的作用域中查找

名称隐藏

1
2
3
4
5
6
7
8
9
10
11
12
int x = 100; // 全局变量

void function() {
    int x = 200; // 局部变量，隐藏全局变量
    std::cout << x << std::endl; // 输出 200
    std::cout << ::x << std::endl; // 输出 100（使用全局作用域）
}

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

命名空间的名称查找

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
namespace A {
    int x = 10;
}

namespace B {
    int x = 20;
    void function() {
        using namespace A;
        std::cout << x << std::endl; // 输出 20，B::x 隐藏 A::x
        std::cout << A::x << std::endl; // 输出 10
    }
}

int main() {
    B::function();
    return 0;
}

内存模型和名称空间的最佳实践

内存管理最佳实践

  1. 优先使用自动存储：对于局部变量，优先使用自动存储（栈内存）
  2. 使用智能指针：对于动态内存，优先使用智能指针（std::unique_ptr、std::shared_ptr）
  3. 避免手动内存管理：尽量避免使用 new 和 delete 手动管理内存
  4. 内存分配检查：在分配内存后检查是否成功（对于 new(nothrow)）
  5. 释放内存：确保每个 new 都有对应的 delete，每个 new[] 都有对应的 delete[]
  6. 避免悬空指针：释放内存后将指针设置为 nullptr
  7. 避免重复释放：不要重复释放同一块内存

命名空间最佳实践

  1. 合理使用命名空间：使用命名空间组织代码，避免名称冲突
  2. 避免 using 指令的滥用：在头文件中避免使用 using namespace std;
  3. 使用 using 声明：对于常用的标识符，使用 using 声明
  4. 命名空间命名：使用有意义的命名空间名称
  5. 嵌套命名空间：合理使用嵌套命名空间组织代码
  6. 匿名命名空间：对于只在当前文件中使用的内容，使用匿名命名空间

C++20新特性：模块系统

C++20引入了模块系统，提供了一种更高效、更可靠的代码组织方式，替代传统的头文件包含机制：

模块的基本概念

  • 模块：一个独立的代码单元，包含声明和定义
  • 导出：将模块中的符号暴露给其他模块使用
  • 导入：使用其他模块导出的符号

模块的使用示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
// math.cppm - 模块接口文件
module; // 全局模块片段

#include <cmath>

export module math; // 模块声明

export double add(double a, double b) {
    return a + b;
}

export double square(double x) {
    return x * x;
}

export double sqrt(double x) {
    return std::sqrt(x);
}

// main.cpp - 使用模块
import math; // 导入math模块
import std; // 导入标准库模块（C++23）

int main() {
    double a = 3.0;
    double b = 4.0;
    
    double sum = add(a, b);
    double squared = square(sum);
    double root = sqrt(squared);
    
    std::cout << "Sum: " << sum << std::endl;
    std::cout << "Squared: " << squared << std::endl;
    std::cout << "Square root: " << root << std::endl;
    
    return 0;
}

模块的优点

  1. 编译速度：模块只编译一次，避免了头文件的重复包含和编译
  2. 依赖管理：明确的导入/导出机制，避免了隐式依赖
  3. 名称冲突：模块提供了命名空间的隔离，减少了名称冲突
  4. 安全性：模块的接口更加清晰，减少了错误的使用方式
  5. 可维护性：代码组织更加模块化，易于维护和理解

常见错误和陷阱

内存管理错误

  1. 内存泄漏：忘记释放动态分配的内存
  2. 悬空指针：使用已释放的内存
  3. 重复释放：多次释放同一块内存
  4. 数组和单个对象释放混淆：使用错误的 delete 形式
  5. 内存碎片：频繁分配和释放小块内存导致内存碎片

命名空间错误

  1. 命名空间冲突：不同命名空间中的名称冲突
  2. using 指令的滥用：在头文件中使用 using 指令导致的命名冲突
  3. 名称查找歧义：多个命名空间中存在相同名称的标识符
  4. 命名空间嵌套过深：过度嵌套命名空间导致代码可读性下降

作用域错误

  1. 变量隐藏：局部变量隐藏全局变量
  2. 作用域混淆：误解变量的作用域范围
  3. 生命周期错误：使用已销毁的对象

小结

本章介绍了C++的内存模型和名称空间，包括：

  1. 内存模型：内存区域划分、内存布局
  2. 存储类别：auto、static、extern、register
  3. 作用域：全局作用域、局部作用域、块作用域、函数原型作用域、类作用域、命名空间作用域
  4. 链接性：外部链接性、内部链接性、无链接性
  5. 动态内存管理：new/delete、智能指针（unique_ptr、shared_ptr、weak_ptr）
  6. 名称空间：命名空间的定义、使用、别名
  7. 名称查找：名称查找规则、名称隐藏
  8. 最佳实践：内存管理和命名空间的使用建议
  9. 常见错误和陷阱：内存管理错误、命名空间错误、作用域错误

理解C++的内存模型和名称空间对于编写高效、可靠的程序至关重要。通过合理管理内存和使用命名空间，可以提高代码的可读性、可维护性和安全性。在实际编程中，应优先使用智能指针管理动态内存，避免手动内存管理的错误；合理使用命名空间组织代码，避免名称冲突。

在后续章节中，我们将学习面向对象编程、类和对象、继承和多态等更高级的C++特性，这些特性将与内存模型和名称空间结合使用，帮助我们构建更复杂、更强大的程序。