C++如何使用智能指针与容器结合管理内存

new

std::unique_ptr

std::shared_ptr

std::unique_ptr

std::unique_ptr

std::vector

std::list

std::deque

#include <vector>
#include <memory>
#include <iostream>

class Base {
public:
    virtual void greet() const { std::cout << "Hello from Base!" << std::endl; }
    virtual ~Base() { std::cout << "Base destructor called." << std::endl; }
};

class Derived : public Base {
public:
    void greet() const override { std::cout << "Hello from Derived!" << std::endl; }
    ~Derived() { std::cout << "Derived destructor called." << std::endl; }
};

// 示例：使用 unique_ptr 存储多态对象
std::vector<std::unique_ptr<Base>> objects;
objects.push_back(std::make_unique<Derived>()); // 推荐使用 make_unique
objects.push_back(std::make_unique<Base>());

for (const auto& obj_ptr : objects) {
    obj_ptr->greet();
}
// 当 objects 离开作用域时，所有 Base 和 Derived 对象都会被正确销毁

std::shared_ptr

std::shared_ptr

std::map

std::set

#include <map>
#include <memory>
#include <string>
#include <iostream>

class Resource {
public:
    std::string name;
    Resource(std::string n) : name(std::move(n)) {
        std::cout << "Resource " << name << " created." << std::endl;
    }
    ~Resource() {
        std::cout << "Resource " << name << " destroyed." << std::endl;
    }
};

// 示例：使用 shared_ptr 存储共享资源
std::map<std::string, std::shared_ptr<Resource>> shared_resources;

// 创建一个共享资源
auto r1 = std::make_shared<Resource>("DatabaseConnection");
shared_resources["db_conn_1"] = r1;
shared_resources["db_conn_2"] = r1; // 两个键共享同一个 Resource 对象

std::cout << "Reference count for r1: " << r1.use_count() << std::endl;

// 另一个 shared_ptr 也可以指向它
std::shared_ptr<Resource> another_ref = shared_resources["db_conn_1"];
std::cout << "Reference count for r1 after another_ref: " << r1.use_count() << std::endl;

// 当所有 shared_ptr 都离开作用域或被重置时，Resource 才会被销毁

std::make_unique

std::make_shared

unique_ptr

unique_ptr

std::unique_ptr

std::shared_ptr

shared_ptr

std::weak_ptr

shared_ptr

unique_ptr

unique_ptr

shared_ptr

std::unique_ptr

unique_ptr

#include <memory>
#include <cstdio> // For FILE* and fclose
#include <iostream>
#include <vector>

// 1. 使用函数对象（Lambda表达式）作为删除器
auto file_closer = [](FILE* f) {
    if (f) {
        std::cout << "Closing file with lambda deleter." << std::endl;
        fclose(f);
    }
};
using FilePtr = std::unique_ptr<FILE, decltype(file_closer)>;

// 2. 使用结构体（仿函数）作为删除器
struct SocketCloser {
    void operator()(int* sock_fd) const { // 注意这里，通常传递原始指针类型
        if (sock_fd && *sock_fd != -1) {
            std::cout << "Closing socket with functor deleter: " << *sock_fd << std::endl;
            // 假设这是一个真实的套接字关闭函数
            // close(*sock_fd);
            delete sock_fd; // 释放原始指针本身
        }
    }
};
using SocketPtr = std::unique_ptr<int, SocketCloser>; // 假设 int 是文件描述符

void demo_unique_ptr_custom_deleter() {
    // 示例1: 管理文件句柄
    FILE* f = fopen("test.txt", "w");
    if (f) {
        FilePtr managed_file(f, file_closer);
        fprintf(f, "Hello from unique_ptr!\n");
        // managed_file 离开作用域时，file_closer 会被调用
    } else {
        std::cerr << "Failed to open file." << std::endl;
    }

    // 示例2: 管理一个假想的套接字描述符
    int* sock_fd = new int(123); // 假设这是从某个 API 获取的
    SocketPtr managed_socket(sock_fd, SocketCloser{});
    // managed_socket 离开作用域时，SocketCloser() 会被调用
}

unique_ptr

std::shared_ptr

shared_ptr

shared_ptr

#include <memory>
#include <iostream>
#include <vector>

// 1. 使用函数指针作为删除器
void custom_array_deleter(int* p) {
    std::cout << "Custom array deleter called. Deleting int array." << std::endl;
    delete[] p;
}

// 2. 使用 Lambda 表达式作为删除器
void demo_shared_ptr_custom_deleter() {
    // 示例1: 管理C风格动态数组
    std::shared_ptr<int> arr_ptr(new int[10], custom_array_deleter);
    arr_ptr.get()[0] = 100;
    std::cout << "Array element: " << arr_ptr.get()[0] << std::endl;
    // arr_ptr 离开作用域时，custom_array_deleter 会被调用

    // 示例2: 管理一个通过 C API 分配的内存
    // 假设有一个 C 函数 `void* allocate_buffer(size_t size)`
    // 和一个 `void free_buffer(void* ptr)`
    auto c_buffer_deleter = [](void* p) {
        std::cout << "Custom C buffer deleter called." << std::endl;
        // free_buffer(p); // 假设调用 C API 的释放函数
        std::free(p); // 这里用 std::free 模拟
    };

    void* raw_buffer = std::malloc(128); // 模拟 C API 分配
    std::shared_ptr<void> managed_buffer(raw_buffer, c_buffer_deleter);
    // managed_buffer 离开作用域时，c_buffer_deleter 会被调用
}