1. 什么是 RAII（资源获取即初始化）？

1. 核心思想： RAII是一种C++编程技术，将资源的生命周期与对象的生命周期绑定，在构造函数中获取资源，在析构函数中释放资源，利用C++栈对象自动销毁的特性确保资源一定被释放。

2. 主要优势： 自动管理资源无需手动释放，异常安全（即使抛出异常析构函数也会被调用），代码简洁避免忘记释放资源，是现代C++内存管理的基石。

3. 典型应用： 智能指针（unique_ptr、shared_ptr）、互斥锁（lock_guard、unique_lock）、文件句柄（fstream）、数据库连接等都是RAII的应用。

4. 实现要点： 在构造函数中分配资源，在析构函数中释放资源，通常禁止拷贝或实现移动语义，确保资源所有权清晰。

// RAII示例：自动管理锁
class LockGuard {
    std::mutex& mtx;
public:
    LockGuard(std::mutex& m) : mtx(m) { mtx.lock(); }
    ~LockGuard() { mtx.unlock(); }
};

void thread_safe() {
    std::mutex mtx;
    LockGuard lock(mtx);  // 自动加锁
    // 临界区代码
}  // 自动解锁，即使异常也安全

2. 如何避免 C++ 中的内存泄漏？

1. 使用智能指针： 优先使用unique_ptr和shared_ptr代替裸指针，避免手动new/delete，智能指针会自动管理内存释放，是防止泄漏的最有效方法。

2. 遵循RAII原则： 用对象管理资源，利用析构函数自动释放，使用STL容器（vector、string）代替手动内存管理，容器会自动处理内存分配和释放。

3. 注意异常安全： 在可能抛出异常的代码中使用RAII确保资源释放，避免在异常路径上忘记释放资源，使用try-catch时确保所有分支都正确释放。

4. 避免循环引用： shared_ptr的循环引用会导致引用计数永远不为0造成泄漏，使用weak_ptr打破循环，定期使用Valgrind或AddressSanitizer等工具检测泄漏。

// 避免泄漏的正确做法
void no_leak() {
    auto ptr = std::make_unique<int>(42);  // 智能指针
    std::vector<int> vec{1,2,3};           // 容器自动管理
    
    if (error) return;  // 即使提前返回也自动释放
}

// 打破循环引用
class Node {
    std::shared_ptr<Node> next;   // 强引用
    std::weak_ptr<Node> prev;     // 弱引用打破循环
};

3. C++ 中如何使用智能指针？

1. unique_ptr（独占所有权）： 独占资源不能拷贝只能移动，零开销性能等同裸指针，适用于明确的单一所有者场景，使用make_unique创建，通过std::move转移所有权。

2. shared_ptr（共享所有权）： 使用引用计数实现多个指针共享同一资源，最后一个指针销毁时释放资源，有一定开销（引用计数、线程安全），适用于所有权不明确需要共享的场景，使用make_shared创建效率更高。

3. weak_ptr（弱引用）： 不增加引用计数，用于打破shared_ptr的循环引用，使用前需要通过lock()转换为shared_ptr检查对象是否还存在，常用于观察者模式和缓存场景。

4. 使用原则： 优先使用unique_ptr性能最好，需要共享时使用shared_ptr，避免循环引用时使用weak_ptr，避免使用裸指针和手动delete，使用make_unique/make_shared而不是new。

// unique_ptr：独占所有权
auto ptr1 = std::make_unique<int>(42);
auto ptr2 = std::move(ptr1);  // 转移所有权

// shared_ptr：共享所有权
auto sp1 = std::make_shared<int>(100);
auto sp2 = sp1;  // 引用计数=2

// weak_ptr：打破循环
std::weak_ptr<int> wp = sp1;
if (auto sp = wp.lock()) {  // 转换为shared_ptr使用
    std::cout << *sp;
}

4. 什么是内存池（Memory Pool）？

1. 基本概念： 内存池是预先分配一大块内存然后按需分配小块内存的技术，避免频繁调用系统分配函数，通过维护空闲链表实现快速分配和回收，适合频繁分配释放相同大小对象的场景。

2. 主要优势： 性能提升（减少系统调用分配速度快10-100倍），减少内存碎片（固定大小分配内存连续），可预测性（分配时间固定适合实时系统），缓存友好（内存连续提高缓存命中率）。

3. 实现方式： 固定大小内存池（所有块大小相同最简单），多级内存池（不同大小的池适应不同需求），对象池（专门管理特定类型对象），slab分配器（Linux内核使用的高级内存池）。

4. 适用场景： 游戏引擎（频繁创建销毁游戏对象），高性能服务器（网络连接对象池），实时系统（避免不确定的分配延迟），嵌入式系统（内存受限需要精确控制），STL容器的allocator也是内存池的应用。

// 简单内存池示例
template<typename T>
class ObjectPool {
    union Node { T obj; Node* next; };
    Node* freeList = nullptr;
public:
    T* allocate() {
        if (!freeList) expandPool();
        Node* node = freeList;
        freeList = freeList->next;
        return &node->obj;
    }
    void deallocate(T* ptr) {
        Node* node = reinterpret_cast<Node*>(ptr);
        node->next = freeList;
        freeList = node;
    }
};

5. C++ 中如何管理内存？

1. 栈内存管理： 局部变量自动分配在栈上，作用域结束自动释放，速度快但空间有限（通常1-8MB），适合小对象和临时变量，栈溢出会导致程序崩溃。

2. 堆内存管理： 使用new/delete或malloc/free手动管理，空间大但速度慢，容易泄漏和碎片化，现代C++推荐用智能指针代替手动管理，避免直接使用new/delete。

3. 静态/全局内存： 程序启动时分配程序结束时释放，生命周期贯穿整个程序，适合全局配置和单例对象，过度使用会增加内存占用和启动时间。

4. 现代C++最佳实践： 优先使用栈内存和RAII，使用智能指针管理堆内存，使用STL容器代替手动数组，避免裸指针和手动内存管理，使用内存池优化频繁分配，定期使用工具检测泄漏和越界。

// 内存管理最佳实践
void memory_management() {
    int stack_var = 42;                    // 栈：自动管理
    auto heap_ptr = std::make_unique<int>(100);  // 堆：智能指针
    std::vector<int> vec{1,2,3};           // 容器：自动管理
    static int static_var = 0;             // 静态：程序生命周期
}

6. C++ 中的内存对齐（Memory Alignment）是什么？

1. 基本概念： 内存对齐是指数据在内存中的起始地址必须是某个值的整数倍，CPU访问对齐的数据效率更高，未对齐访问可能导致性能下降甚至硬件异常，编译器会自动插入填充字节实现对齐。

2. 对齐规则： 基本类型对齐到自身大小（char 1字节、int 4字节、double 8字节），结构体对齐到最大成员的对齐值，结构体大小是最大对齐值的整数倍，可以用alignof查询对齐值用alignas指定对齐。

3. 性能影响： 对齐访问一次读取，未对齐可能需要多次读取和拼接，某些CPU架构（ARM）未对齐访问会触发异常，缓存行对齐（64字节）可以避免false sharing提高多线程性能。

4. 控制对齐： 使用#pragma pack控制结构体对齐，使用alignas指定对齐值，使用std::aligned_storage分配对齐内存，注意对齐会增加内存占用需要权衡空间和性能。

struct Unaligned {
    char a;   // 1字节
    int b;    // 4字节，填充3字节
    char c;   // 1字节，填充3字节
};  // 总共12字节

struct Aligned {
    int b;    // 4字节
    char a;   // 1字节
    char c;   // 1字节，填充2字节
};  // 总共8字节，重排后更紧凑

alignas(64) struct CacheAligned {  // 缓存行对齐
    int data[16];
};

7. 如何通过 std::move 实现高效的内存管理？

1. 移动语义概念： std::move将左值转换为右值引用，允许资源所有权转移而不是拷贝，避免深拷贝提高性能，移动后的对象处于有效但未定义状态不应再使用。

2. 性能优势： 移动大对象（vector、string）只转移指针不拷贝数据，时间复杂度从O(n)降到O(1)，返回局部对象时编译器自动使用移动避免拷贝，unique_ptr只能移动不能拷贝确保唯一所有权。

3. 实现移动语义： 定义移动构造函数和移动赋值运算符，转移资源所有权并将源对象置空，使用noexcept声明避免异常影响性能，遵循Rule of Five（析构、拷贝构造、拷贝赋值、移动构造、移动赋值）。

4. 使用场景： 返回大对象时使用移动避免拷贝，容器插入时移动临时对象，unique_ptr转移所有权，swap操作使用移动提高效率，注意移动后不要再使用源对象。

class Buffer {
    char* data;
    size_t size;
public:
    // 移动构造
    Buffer(Buffer&& other) noexcept : data(other.data), size(other.size) {
        other.data = nullptr;  // 转移所有权
        other.size = 0;
    }
    
    // 移动赋值
    Buffer& operator=(Buffer&& other) noexcept {
        if (this != &other) {
            delete[] data;
            data = other.data;
            size = other.size;
            other.data = nullptr;
        }
        return *this;
    }
};

// 使用示例
Buffer b1(1024);
Buffer b2 = std::move(b1);  // 移动，不拷贝

8. 如何减少 C++ 程序中的内存碎片？

1. 碎片产生原因： 频繁分配释放不同大小的内存块导致空闲内存不连续，虽然总空闲内存足够但无法满足大块分配请求，长时间运行的程序碎片化严重影响性能和稳定性。

2. 使用内存池： 预分配固定大小的内存块避免碎片，对象池管理相同类型对象，多级内存池适应不同大小需求，STL的allocator可以自定义内存池。

3. 减少动态分配： 优先使用栈内存和静态内存，使用reserve预分配容器空间避免多次扩容，使用小对象优化（SSO）避免小字符串动态分配，批量分配一次性分配大块内存。

4. 内存整理策略： 使用紧凑型分配器（compacting allocator）定期整理内存，使用区域分配器（arena allocator）统一释放整个区域，避免长生命周期和短生命周期对象混合分配，定期重启服务释放碎片。

// 使用内存池减少碎片
class FixedAllocator {
    std::vector<void*> blocks;
    std::vector<void*> freeList;
public:
    void* allocate(size_t size) {
        if (freeList.empty()) {
            void* block = ::operator new(size * 100);  // 批量分配
            blocks.push_back(block);
            // 切分成小块加入freeList
        }
        void* ptr = freeList.back();
        freeList.pop_back();
        return ptr;
    }
};

// 预分配避免碎片
std::vector<int> vec;
vec.reserve(1000);  // 预分配，避免多次扩容

9. C++ 中的垃圾回收与手动内存管理有什么区别？

1. 手动内存管理： C++默认使用手动管理，程序员显式分配和释放内存，性能高可预测但容易出错（泄漏、悬空指针、重复释放），需要程序员仔细管理资源生命周期。

2. 垃圾回收特点： 自动检测和回收不再使用的内存，程序员无需手动释放简化开发，但有性能开销（GC暂停、内存占用高），回收时机不可控可能影响实时性，Java、C#等语言使用GC。

3. C++的选择： C++不内置GC保持高性能和可预测性，通过RAII和智能指针实现自动内存管理，既有自动管理的便利又保持手动管理的性能，适合系统编程和性能敏感场景。

4. 混合方案： C++可以使用第三方GC库（Boehm GC）但很少使用，智能指针的引用计数是一种确定性的"GC"，现代C++推荐RAII+智能指针而不是真正的GC，在需要GC的场景可以考虑使用其他语言。

// C++手动管理（不推荐）
int* ptr = new int(42);
delete ptr;  // 必须手动释放

// C++智能指针（推荐）
auto ptr = std::make_unique<int>(42);  // 自动释放

// Java GC（对比）
// Integer obj = new Integer(42);  // 自动回收，无需delete

10. 如何优化 C++ 中的内存访问模式？

1. 缓存友好访问： 按顺序访问连续内存利用CPU缓存，避免随机访问和指针跳转，使用数组代替链表提高缓存命中率，结构体成员按访问频率排列热数据放一起。

2. 数据局部性： 时间局部性（短时间内重复访问同一数据），空间局部性（访问相邻地址的数据），使用SoA（Structure of Arrays）代替AoS（Array of Structures）提高向量化效率。

3. 避免false sharing： 多线程访问不同变量但在同一缓存行会导致缓存失效，使用alignas(64)对齐到缓存行，使用thread_local避免共享，在结构体中添加padding分隔热数据。

4. 预取和预分配： 使用__builtin_prefetch预取数据到缓存，使用reserve预分配容器空间避免重新分配，批量处理数据提高缓存利用率，使用内存池保持内存连续性。

// 缓存友好：按行访问
for (int i = 0; i < rows; i++)
    for (int j = 0; j < cols; j++)
        sum += matrix[i][j];  // 连续访问

// 避免false sharing
struct alignas(64) ThreadData {  // 缓存行对齐
    int counter;
    char padding[60];  // 填充到64字节
};

// SoA vs AoS
struct AoS { int x, y, z; };  // 交错存储
AoS data[1000];

struct SoA {  // 分离存储，向量化友好
    int x[1000];
    int y[1000];
    int z[1000];
};