C++智能指针与数组管理深度解析

1. C/C++中的智能指针深度解析

智能指针是现代C++中管理动态内存的核心工具，它们通过RAII（Resource Acquisition Is Initialization）机制自动管理内存生命周期。在实际项目中，智能指针能显著减少内存泄漏和悬空指针问题。

1.1 unique_ptr的数组管理特性

unique_ptr是C++11引入的独占所有权智能指针，对数组有专门的支持：

cpp复制std::unique_ptr<int[]> arr(new int[10]);
arr[0] = 42;  // 直接支持下标操作

关键特性：

• 不支持*和->运算符（因为指向的是数组而非单个对象）
• 自动调用delete[]释放内存
• 可通过release()放弃所有权
• 移动语义允许所有权转移

注意：不要将数组形式的unique_ptr（unique_ptr<T[]>)与非数组形式（unique_ptr<T>）混用，这会导致未定义行为。

1.2 shared_ptr处理数组的注意事项

shared_ptr默认不支持数组管理，需要额外处理：

cpp复制// 正确用法：自定义deleter
std::shared_ptr<int> arr(new int[10], [](int* p) { delete[] p; });

常见问题解决方案：

1. 访问元素：只能通过get()获取原始指针后操作

   cpp复制arr.get()[0] = 42;  // 通过原始指针访问
   

2. 自定义deleter的三种方式：

   • Lambda表达式（最常用）
   • 函数对象
   • std::default_delete<T[]>()

3. 替代方案：使用std::vector作为托管对象

   cpp复制std::shared_ptr<std::vector<int>> vec_ptr = 
       std::make_shared<std::vector<int>>(10);
   

1.3 五种智能指针管理数组的方法对比

2. C与C++中的数组与指针对比

2.1 数组声明的本质差异

C语言方式：

c复制int arr[10];  // 栈上分配
int* arr = malloc(10 * sizeof(int));  // 堆上分配

C++现代风格：

cpp复制std::array<int, 10> arr;  // 栈上，安全封装
auto arr = std::make_unique<int[]>(10);  // 堆上，自动管理

关键区别：

• C数组会退化为指针（失去长度信息）
• C++的std::array保持容器特性
• C++17起支持std::size()获取数组长度

2.2 指针运算的陷阱与技巧

cpp复制int arr[5] = {1,2,3,4,5};
int* p = arr;

// 以下表达式等价
*(p+2) == p[2] == 2[arr]  // 都返回3

常见错误：

1. 指针越界：C/C++都不检查边界

   cpp复制int val = arr[10];  // 未定义行为
   

2. 数组名与指针的区别：

   cpp复制sizeof(arr);  // 返回数组总字节数(20)
   sizeof(p);    // 返回指针大小(4或8)
   

3. 多维数组处理：

   cpp复制int matrix[3][4];
   // 以下指针类型不同
   int (*ptr1)[4] = matrix;  // 指向含4个int的数组
   int* ptr2 = matrix[0];    // 指向单个int
   

3. 函数指针与函数对象

3.1 C风格函数指针

c复制// 声明函数类型
typedef int (*ComputeFunc)(int, int);

// 实际函数
int add(int a, int b) { return a + b; }

// 使用
ComputeFunc func = add;
int result = func(2, 3);  // 返回5

3.2 C++中的多种可调用对象

现代C++推荐做法：

cpp复制#include <functional>

std::function<int(int,int)> callback;

// 可接受任何可调用对象
callback = [](int a, int b) { return a * b; };

4. 内存管理机制对比

4.1 内存分配方式

4.2 典型内存问题对比

C语言常见问题：

c复制// 内存泄漏
void leak() {
    int* p = malloc(10 * sizeof(int));
    return;  // 忘记free
}

// 悬空指针
int* dang() {
    int x = 10;
    return &x;  // 返回局部变量地址
}

C++解决方案：

cpp复制// 使用智能指针避免泄漏
void safe() {
    auto p = std::make_unique<int[]>(10);
    return;  // 自动释放
}

// 使用shared_ptr共享所有权
std::shared_ptr<int> share() {
    return std::make_shared<int>(42);
}

4.3 自定义内存管理

重载new/delete示例：

cpp复制class MemoryPool {
public:
    static void* operator new(size_t size) {
        void* p = myPoolAlloc(size);
        if(!p) throw std::bad_alloc();
        return p;
    }
    
    static void operator delete(void* p) {
        myPoolFree(p);
    }
};

5. 实战经验与性能考量

5.1 智能指针性能影响

实测数据（VS2022 x64 Release模式）：

优化建议：

1. 性能敏感场景优先用unique_ptr
2. 避免频繁创建shared_ptr
3. 使用std::make_shared减少内存分配次数

5.2 多线程安全策略

cpp复制// 安全共享数据的方式
std::shared_ptr<std::mutex> mtx = std::make_shared<std::mutex>();
std::shared_ptr<int> data = std::make_shared<int>(0);

auto task = [=]() {
    std::lock_guard<std::mutex> lock(*mtx);
    *data += 1;
};

5.3 常见陷阱排查指南

1. 循环引用问题：

   cpp复制struct Node {
       std::shared_ptr<Node> next;
       // 应使用weak_ptr打破循环
   };
   

2. 混合使用new/malloc：

   cpp复制int* p = new int[10];
   free(p);  // 错误！应用delete[]
   

3. 智能指针与this指针：

   cpp复制class Widget {
       std::shared_ptr<Widget> getShared() {
           return shared_from_this();  // 需继承enable_shared_from_this
       }
   };
   

4. 数组越界检测技巧：

   cpp复制#define ARRAY_BOUNDS_CHECK(index, size) \
       assert((index) >= 0 && (index) < (size) && "Array index out of bounds")