C++中如何安全地传递对象所有权 移动语义与智能指针结合使用

&&

std::move

unique_ptr

unique_ptr

std::move

shared_ptr

shared_ptr

std::unique_ptr

std::move

unique_ptr

=

unique_ptr

unique_ptr

unique_ptr

std::move

unique_ptr

std::move

unique_ptr

unique_ptr

unique_ptr

unique_ptr

nullptr

unique_ptr

unique_ptr

unique_ptr

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

class MyResource {
public:
    int id;
    MyResource(int i) : id(i) { std::cout << "MyResource " << id << " created.\n"; }
    ~MyResource() { std::cout << "MyResource " << id << " destroyed.\n"; }
    void do_something() { std::cout << "MyResource " << id << " doing something.\n"; }
};

// 函数接收 unique_ptr 并接管所有权
void process_resource(std::unique_ptr<MyResource> res) {
    if (res) {
        res->do_something();
        // res 在函数结束时自动销毁其管理的对象
    } else {
        std::cout << "No resource to process.\n";
    }
}

// 函数返回 unique_ptr
std::unique_ptr<MyResource> create_resource(int id) {
    return std::make_unique<MyResource>(id); // 返回时自动移动
}

int main() {
    std::cout << "--- unique_ptr ownership transfer example ---\n";

    // 1. 创建一个 unique_ptr
    std::unique_ptr<MyResource> ptr1 = std::make_unique<MyResource>(101);
    ptr1->do_something();

    // 2. 尝试拷贝，会编译错误
    // std::unique_ptr<MyResource> ptr_copy = ptr1; // 错误：unique_ptr 不能被拷贝

    // 3. 使用 std::move 转移所有权
    std::unique_ptr<MyResource> ptr2 = std::move(ptr1); // ptr1 的所有权转移给 ptr2
    if (ptr1) {
        std::cout << "ptr1 still holds resource? This should not happen.\n";
    } else {
        std::cout << "ptr1 is now empty after move.\n";
    }
    ptr2->do_something(); // ptr2 现在是资源的唯一所有者

    // 4. 将所有权传递给函数
    std::unique_ptr<MyResource> ptr3 = std::make_unique<MyResource>(102);
    process_resource(std::move(ptr3)); // ptr3 的所有权转移给函数参数 res
    if (!ptr3) {
        std::cout << "ptr3 is empty after passing to function.\n";
    }

    // 5. 从函数接收所有权
    std::unique_ptr<MyResource> ptr4 = create_resource(103);
    ptr4->do_something();

    std::cout << "--- End of unique_ptr example ---\n";
    return 0;
}

unique_ptr

std::move

std::shared_ptr

shared_ptr

shared_ptr

shared_ptr

shared_ptr

shared_ptr

shared_ptr

shared_ptr

unique_ptr

unique_ptr

shared_ptr

shared_ptr

weak_ptr

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

class DataProcessor {
public:
    int id;
    DataProcessor(int i) : id(i) { std::cout << "DataProcessor " << id << " created.\n"; }
    ~DataProcessor() { std::cout << "DataProcessor " << id << " destroyed.\n"; }
    void process() { std::cout << "DataProcessor " << id << " processing data.\n"; }
};

void consumer_a(std::shared_ptr<DataProcessor> p) {
    if (p) {
        std::cout << "Consumer A is using DataProcessor " << p->id << ". Ref count: " << p.use_count() << "\n";
        p->process();
    }
}

void consumer_b(std::shared_ptr<DataProcessor> p) {
    if (p) {
        std::cout << "Consumer B is using DataProcessor " << p->id << ". Ref count: " << p.use_count() << "\n";
        p->process();
    }
}

int main() {
    std::cout << "--- shared_ptr ownership sharing example ---\n";

    // 创建一个 shared_ptr
    std::shared_ptr<DataProcessor> shared_data = std::make_shared<DataProcessor>(201);
    std::cout << "Initial ref count: " << shared_data.use_count() << "\n";

    // 多个 shared_ptr 实例共享同一个对象
    std::shared_ptr<DataProcessor> another_ref = shared_data; // 拷贝，引用计数增加
    std::cout << "After another_ref created, ref count: " << shared_data.use_count() << "\n";

    consumer_a(shared_data); // 传递 shared_ptr，引用计数在函数内部临时增加
    std::cout << "After consumer_a, ref count: " << shared_data.use_count() << "\n";

    consumer_b(another_ref); // 再次传递，引用计数再次增加
    std::cout << "After consumer_b, ref count: " << shared_data.use_count() << "\n";

    // 当 shared_data 和 another_ref 都超出作用域时，DataProcessor 才会被销毁
    std::cout << "Exiting main scope. DataProcessor will be destroyed when all shared_ptr instances are gone.\n";

    return 0;
} // shared_data 和 another_ref 在这里销毁，引用计数降为0，DataProcessor 201 被销毁

shared_ptr

shared_data

another_ref

DataProcessor

std::shared_ptr

shared_ptr

shared_ptr

shared_ptr

shared_ptr

shared_ptr

shared_ptr

std::weak_ptr

shared_ptr

weak_ptr

weak_ptr

lock()

lock()

std::shared_ptr

shared_ptr

lock()

shared_ptr

shared_ptr

lock()

shared_ptr

weak_ptr

weak_ptr

shared_ptr

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

class B; // 前向声明

class A {
public:
    std::shared_ptr<B> b_ptr; // 可能会导致循环引用
    int id;

    A(int i) : id(i) { std::cout << "A " << id << " created.\n"; }
    ~A() { std::cout << "A " << id << " destroyed.\n"; }

    void set_b(std::shared_ptr<B> b) {
        b_ptr = b;
    }
};

class B {
public:
    std::weak_ptr<A> a_ptr; // 使用 weak_ptr 打破循环引用
    int id;

    B(int i) : id(i) { std::cout << "B " << id << " created.\n"; }
    ~B() { std::cout << "B " << id << " destroyed.\n"; }

    void set_a(std::shared_ptr<A> a) {
        a_ptr = a;
    }

    void access_a() {
        if (auto shared_a = a_ptr.lock()) { // 尝试提升为 shared_ptr
            std::cout << "B " << id << " successfully accessed A " << shared_a->id << ".\n";
        } else {
            std::cout << "B " << id << " tried to access A, but A has been destroyed.\n";
        }
    }
};

int main() {
    std::cout << "--- shared_ptr circular reference example with weak_ptr ---\n";

    { // 限制作用域，观察析构行为
        std::shared_ptr<A> my_a = std::make_shared<A>(301);
        std::shared_ptr<B> my_b = std::make_shared<B>(302);

        std::cout << "A ref count: " << my_a.use_count() << ", B ref count: " << my_b.use_count() << "\n";

        // 建立双向引用
        my_a->set_b(my_b); // A 持有 B 的 shared_ptr
        my_b->set_a(my_a); // B 持有 A 的 weak_ptr (关键！)

        std::cout << "After setting links:\n";
        std::cout << "A ref count: " << my_a.use_count() << ", B ref count: " << my_b.use_count() << "\n";
        // 此时 A 的引用计数为 1 (my_a) + 1 (my_b->a_ptr.lock() if it were shared_ptr)
        // 实际上 my_a 引用计数为 1 (my_a), my_b 引用计数为 2 (my_b, my_a->b_ptr)

        my_b->access_a(); // B 尝试访问 A

    } // my_a 和 my_b 在这里超出作用域

    std::cout << "--- End of weak_ptr example ---\n";
    // 如果 B 使用的是 shared_ptr<A> 而不是 weak_ptr<A>，