内容来自：程序员老廖的个人空间

第1章：C++内存模型与对象生命周期

1.1 内存分区：栈、堆、全局/静态存储区、常量区

C++程序的内存布局通常分为以下几个区域，理解它们对写出高效、安全的代码至关重要。

栈 (Stack)

  • 存储内容：局部变量、函数参数、返回地址等

  • 管理方式：由编译器自动分配和释放

  • 特点：LIFO（后进先出）结构，分配速度快，内存大小有限

  • 生长方向：向低地址方向生长

堆 (Heap)

  • 存储内容：动态分配的内存（new/malloc）

  • 管理方式：由程序员手动分配和释放

  • 特点：分配速度相对较慢，内存空间较大，容易产生碎片

  • 生长方向：向高地址方向生长

全局/静态存储区

  • 存储内容：全局变量、静态变量（static）

  • 管理方式：程序开始时分配，程序结束时释放

  • 特点：分为.data段（已初始化）和.bss段（未初始化）

常量区

  • 存储内容：字符串常量、const全局变量

  • 管理方式：只读区域，程序结束时释放

  • 特点：尝试修改会导致段错误

面试真题 1.1.1 【腾讯-后台开发-2025】

题目：请解释以下代码中各个变量存储在哪个内存区域，并说明原因。

#include <iostream>
const int g_const = 10;          // 常量区
int g_var = 20;                  // .data段
static int s_var = 30;           // .data段
char* p_str = "Hello";           // p_str在.data段，"Hello"在常量区
​
void memory_layout_demo() {
    static int local_s_var = 40; // .data段
    int local_var = 50;          // 栈
    const int local_const = 60;  // 栈
    
    int* heap_var = new int(70); // heap_var在栈，指向堆内存
    char arr[] = "World";        // 栈（数组在栈上分配）
    
    std::cout << "g_const: " << &g_const << std::endl;
    std::cout << "g_var: " << &g_var << std::endl;
    std::cout << "s_var: " << &s_var << std::endl;
    std::cout << "p_str: " << &p_str << " -> " << (void*)p_str << std::endl;
    std::cout << "local_s_var: " << &local_s_var << std::endl;
    std::cout << "local_var: " << &local_var << std::endl;
    std::cout << "local_const: " << &local_const << std::endl;
    std::cout << "heap_var: " << &heap_var << " -> " << heap_var << std::endl;
    std::cout << "arr: " << &arr << std::endl;
    
    delete heap_var;
}
​
int main() {
    memory_layout_demo();
    return 0;
}
// 编译运行: g++ -std=c++11 memory_layout.cpp -o memory_layout

参考答案：

  • g_const：存储在常量区，因为是const全局常量

  • g_var：存储在.data段，已初始化的全局变量

  • s_var：存储在.data段，静态全局变量

  • p_str：指针本身在.data段，指向的字符串"Hello"在常量区

  • local_s_var：存储在.data段，静态局部变量

  • local_var：存储在栈，普通局部变量

  • local_const：存储在栈，const局部变量

  • heap_var：指针本身在栈，指向的内存地址在堆

  • arr：存储在栈，数组在栈上分配空间

1.2 对象构造与析构全过程（含VPTR初始化时机）

对象的生命周期包括构造、使用和析构三个阶段。理解这个过程对于避免资源泄漏和未定义行为至关重要。

构造过程

  1. 分配内存：在栈或堆上为对象分配内存空间

  2. 初始化虚表指针：如果类有虚函数，首先初始化vptr指向正确的虚函数表

  3. 调用基类构造函数：按照继承顺序调用基类的构造函数

  4. 初始化成员变量：按照声明顺序初始化成员变量

  5. 执行构造函数体：执行构造函数体内的代码

析构过程

  1. 执行析构函数体：执行析构函数体内的代码

  2. 调用成员析构函数：按照声明逆序析构成员变量

  3. 调用基类析构函数：按照继承逆序调用基类的析构函数

  4. 重置虚表指针：将vptr设置为nullptr或指向基类的虚表

  5. 释放内存：释放对象占用的内存空间

VPTR初始化时机

虚表指针（vptr）在构造函数的最开始阶段被初始化，这也是为什么在构造函数中调用虚函数不会发生多态的原因。

#include <iostream>
​
class Base {
public:
    Base() {
        std::cout << "Base constructor" << std::endl;
        // 此时vptr指向Base的虚表
        virtual_func(); // 调用Base::virtual_func()
    }
    
    virtual void virtual_func() {
        std::cout << "Base virtual_func" << std::endl;
    }
    
    virtual ~Base() {
        std::cout << "Base destructor" << std::endl;
        // 此时vptr指向Base的虚表
        virtual_func(); // 调用Base::virtual_func()
    }
};
​
class Derived : public Base {
public:
    Derived() {
        std::cout << "Derived constructor" << std::endl;
        // 此时vptr已指向Derived的虚表
        virtual_func(); // 调用Derived::virtual_func()
    }
    
    void virtual_func() override {
        std::cout << "Derived virtual_func" << std::endl;
    }
    
    ~Derived() override {
        std::cout << "Derived destructor" << std::endl;
        // 此时vptr还指向Derived的虚表
        virtual_func(); // 调用Derived::virtual_func()
    }
};
​
void vptr_init_demo() {
    Derived d;
    // 构造顺序: 分配内存 -> 初始化vptr -> Base构造 -> Derived构造
    // 析构顺序: Derived析构 -> Base析构 -> 重置vptr -> 释放内存
}
// 编译运行: g++ -std=c++11 vptr_init.cpp -o vptr_init

面试真题 1.2.1 【字节跳动-基础架构-2025】

题目：为什么在构造函数和析构函数中调用虚函数不会发生多态？请从vptr的初始化时机解释。

参考答案：

在构造函数中，vptr的初始化发生在构造函数体执行之前。当基类构造函数执行时，vptr指向基类的虚函数表，因此调用的虚函数是基类的版本。即使后续派生类的构造函数会重新设置vptr指向派生类的虚函数表，但在基类构造函数执行期间，多态机制还没有完全建立。

同样地，在析构函数中，当派生类的析构函数执行完毕后，vptr会被重新设置为指向基类的虚函数表，然后在基类析构函数中调用虚函数时，只能调用到基类的版本。

这是一种安全机制，确保在对象构造和析构的不完整状态下，不会调用到尚未初始化或已经销毁的派生类成员。

1.3 深入理解RAII：从概念到最佳实践

RAII（Resource Acquisition Is Initialization）是C++最重要的编程理念之一，它将资源的管理与对象的生命周期绑定。

RAII的核心思想

  • 资源获取即初始化：在构造函数中获取资源

  • 资源释放即析构：在析构函数中释放资源

  • 异常安全：即使发生异常，资源也能正确释放

RAII的典型应用

  1. 智能指针（std::unique_ptr, std::shared_ptr）

  2. 文件操作（std::fstream）

  3. 锁管理（std::lock_guard, std::unique_lock）

  4. 内存管理（自定义内存池）

  5. 数据库连接

#include <iostream>
#include <memory>
#include <mutex>
#include <fstream>
​
// 1. 智能指针 - 内存管理
void smart_pointer_demo() {
    std::unique_ptr<int> ptr(new int(42));
    // 不需要手动delete，离开作用域自动释放
}
​
// 2. 锁管理 - 互斥锁自动释放
std::mutex mtx;
​
void lock_guard_demo() {
    std::lock_guard<std::mutex> lock(mtx);
    // 临界区代码
    // 离开作用域自动释放锁
}
​
// 3. 文件操作 - 文件自动关闭
void file_operation_demo() {
    std::ofstream file("test.txt");
    file << "Hello, RAII!" << std::endl;
    // 文件在离开作用域时自动关闭
}
​
// 4. 自定义RAII类 - 数据库连接管理
class DatabaseConnection {
public:
    DatabaseConnection() {
        std::cout << "Acquiring database connection..." << std::endl;
        // 模拟获取数据库连接
    }
    
    void execute(const std::string& query) {
        std::cout << "Executing query: " << query << std::endl;
    }
    
    ~DatabaseConnection() {
        std::cout << "Releasing database connection..." << std::endl;
        // 模拟释放数据库连接
    }
};
​
void database_demo() {
    DatabaseConnection db;
    db.execute("SELECT * FROM users");
    // 离开作用域自动释放数据库连接
}
​
// 5. RAII与异常安全
void exception_safe_demo() {
    DatabaseConnection db;  // 无论是否发生异常，db都会正确释放
    throw std::runtime_error("Something went wrong!");
    // 即使抛出异常，db的析构函数也会被调用
}
​
int main() {
    std::cout << "=== Smart Pointer Demo ===" << std::endl;
    smart_pointer_demo();
    
    std::cout << "\n=== Lock Guard Demo ===" << std::endl;
    lock_guard_demo();
    
    std::cout << "\n=== File Operation Demo ===" << std::endl;
    file_operation_demo();
    
    std::cout << "\n=== Database Demo ===" << std::endl;
    database_demo();
    
    std::cout << "\n=== Exception Safety Demo ===" << std::endl;
    try {
        exception_safe_demo();
    } catch (const std::exception& e) {
        std::cout << "Caught exception: " << e.what() << std::endl;
    }
    
    return 0;
}
// 编译运行: g++ -std=c++11 raii_demo.cpp -o raii_demo

面试真题 1.3.1 【百度-智能驾驶-2025】

题目：请实现一个简单的RAII包装类，用于管理使用malloc分配的内存，确保内存不会泄漏。

#include <iostream>
#include <cstdlib>
​
class MallocRAII {
public:
    // 构造函数，分配指定大小的内存
    explicit MallocRAII(size_t size) : ptr_(malloc(size)) {
        if (!ptr_) {
            throw std::bad_alloc();
        }
        std::cout << "Allocated " << size << " bytes at " << ptr_ << std::endl;
    }
    
    // 获取原始指针
    void* get() const { return ptr_; }
    
    // 重载->运算符，方便访问
    void* operator->() const { return ptr_; }
    
    // 禁止拷贝
    MallocRAII(const MallocRAII&) = delete;
    MallocRAII& operator=(const MallocRAII&) = delete;
    
    // 允许移动
    MallocRAII(MallocRAII&& other) noexcept : ptr_(other.ptr_) {
        other.ptr_ = nullptr;
    }
    
    MallocRAII& operator=(MallocRAII&& other) noexcept {
        if (this != &other) {
            free(ptr_);
            ptr_ = other.ptr_;
            other.ptr_ = nullptr;
        }
        return *this;
    }
    
    // 析构函数，释放内存
    ~MallocRAII() {
        if (ptr_) {
            std::cout << "Freeing memory at " << ptr_ << std::endl;
            free(ptr_);
        }
    }
​
private:
    void* ptr_;
};
​
void malloc_raii_demo() {
    try {
        MallocRAII memory(100);  // 分配100字节
        // 使用内存
        int* data = static_cast<int*>(memory.get());
        data[0] = 42;
        
        std::cout << "Data: " << data[0] << std::endl;
        
        // 离开作用域自动释放内存
    } catch (const std::bad_alloc& e) {
        std::cerr << "Memory allocation failed: " << e.what() << std::endl;
    }
}
​
int main() {
    malloc_raii_demo();
    return 0;
}
// 编译运行: g++ -std=c++11 malloc_raii.cpp -o malloc_raii

评分要点：

  1. 在构造函数中分配内存，析构函数中释放内存

  2. 处理分配失败的情况（抛出异常）

  3. 禁止拷贝构造和拷贝赋值（避免重复释放）

  4. 提供移动语义支持

  5. 提供访问原始指针的方法

  6. 异常安全性保证

本章总结：

本章深入探讨了C++的内存模型和对象生命周期管理，这是写出高效、安全C++代码的基础。理解内存分区可以帮助我们优化程序性能，理解对象构造析构过程可以避免资源泄漏，掌握RAII理念可以写出更健壮的代码。

这些知识不仅是面试中的高频考点，更是实际开发中必须掌握的核心概念。在后续章节中，我们会继续深入探讨C++的其他重要特性。

内容太多，需要以下章节内容的可以观看以下视频自行领取完整的学习文档

C++少走弯路系列1-C++语法要学到什么程度，《腾讯/字节/阿里C++深度剖析与面试核心》告诉你答案https://www.bilibili.com/video/BV1JWp8zZE88/

第2章：类型系统与类型推导

第3章：面向对象编程深度解析

第4章：异常处理与安全性

第5章：重载与模板基础

第6章：移动语义与完美转发

第7章：智能指针与资源管理

第8章：Lambda表达式与函数对象

第9章：STL容器与算法深度剖析

第10章：模板元编程与高级泛型

第11章：并发编程基础

第12章：内存模型与原子操作

第13章：系统级编程与性能优化

第14章：C++17核心特性解析

第15章：C++20/23新特性概览

# c++
Logo
2048 AI社区

有“AI”的1024 = 2048，欢迎大家加入2048 AI社区

更多推荐

cover

AI 算力加速指南：Figma AI/Canva AI 全场景优化，从 “闪退卡顿” 到 “流畅创作”（一）

avatar 2048 AI社区
cover

用 AI 搭 AI 导航页：老框架 ThinkPHP 与新工具的协作笔记

avatar 2048 AI社区

Python 生成器与迭代器：节省内存的代码实现技巧

await async2() // 这一句会同步执行，返回 Promise ，其中的 `console.log('async2')` 也会同步执行。Promise.resolve().then(() => { // 返回 rejected 状态的 promise。Promise.resolve().then(() => { // 返回 rejected 状态的 promise。console.lo

avatar 2048 AI社区