C++的std::unique_ptr作为函数参数或返回值时应该怎么传递

std::unique_ptr

const std::unique_ptr<T>&amp;amp;amp;amp;amp;

std::unique_ptr<T>

std::move

std::unique_ptr<T>

std::unique_ptr

unique_ptr

unique_ptr

const std::unique_ptr<T>&amp;amp;amp;amp;amp;

const std::unique_ptr<T>&amp;amp;amp;amp;amp;

class DataProcessor {
public:
    void process_data(const std::unique_ptr<std::string>& data_source) {
        if (data_source) {
            std::cout << "Processing data: " << *data_source << std::endl;
            // 尝试修改 data_source 会导致编译错误，这很好
            // *data_source = "new data"; // 如果 string 是 const，这里会报错
        } else {
            std::cout << "No data source to process." << std::endl;
        }
    }

    void analyze_data_length(const std::unique_ptr<std::vector<int>>& numbers) {
        if (numbers) {
            std::cout << "Vector size: " << numbers->size() << std::endl;
            // numbers->push_back(100); // 编译错误，因为 numbers 是 const 引用
        }
    }
};

// 使用示例
int main() {
    auto my_string_ptr = std::make_unique<std::string>("Hello C++");
    auto my_vector_ptr = std::make_unique<std::vector<int>>(std::initializer_list<int>{1, 2, 3});

    DataProcessor processor;
    processor.process_data(my_string_ptr);
    processor.analyze_data_length(my_vector_ptr);

    // my_string_ptr 和 my_vector_ptr 仍然有效，所有权未变
    std::cout << "Original string after processing: " << *my_string_ptr << std::endl;
    return 0;
}

const&

const MyClass&

unique_ptr

unique_ptr

if (ptr)

unique_ptr

const std::unique_ptr<T>&amp;amp;amp;amp;amp;

std::unique_ptr<T>

unique_ptr

unique_ptr

unique_ptr

unique_ptr

nullptr

// 假设有一个资源管理类
class ResourceManager {
public:
    // 接收一个 unique_ptr，表示将资源添加到管理器中
    void add_resource(std::unique_ptr<SomeResource> resource) {
        if (resource) {
            std::cout << "Resource " << resource->get_id() << " added to manager." << std::endl;
            resources_.push_back(std::move(resource)); // 将所有权转移到 vector 中
        } else {
            std::cout << "Attempted to add a null resource." << std::endl;
        }
    }

    // 假设可以根据ID查找并移除资源，并返回其所有权
    std::unique_ptr<SomeResource> remove_resource(int id) {
        for (auto it = resources_.begin(); it != resources_.end(); ++it) {
            if (*it && (*it)->get_id() == id) {
                std::cout << "Resource " << id << " removed from manager." << std::endl;
                std::unique_ptr<SomeResource> removed_res = std::move(*it); // 转移所有权
                resources_.erase(it);
                return removed_res;
            }
        }
        std::cout << "Resource " << id << " not found." << std::endl;
        return nullptr; // 如果没找到，返回空指针
    }

private:
    std::vector<std::unique_ptr<SomeResource>> resources_;
};

class SomeResource {
public:
    SomeResource(int id) : id_(id) { std::cout << "SomeResource " << id_ << " constructed." << std::endl; }
    ~SomeResource() { std::cout << "SomeResource " << id_ << " destructed." << std::endl; }
    int get_id() const { return id_; }
    void do_work() { std::cout << "Resource " << id_ << " doing work." << std::endl; }
private:
    int id_;
};

int main() {
    ResourceManager manager;

    std::unique_ptr<SomeResource> res1 = std::make_unique<SomeResource>(101);
    std::unique_ptr<SomeResource> res2 = std::make_unique<SomeResource>(102);

    std::cout << "Before adding, res1 is " << (res1 ? "valid" : "null") << std::endl;
    manager.add_resource(std::move(res1)); // 必须使用 std::move
    std::cout << "After adding, res1 is " << (res1 ? "valid" : "null") << std::endl; // res1 变为空

    manager.add_resource(std::move(res2)); // res2 也变为空

    std::unique_ptr<SomeResource> retrieved_res = manager.remove_resource(101);
    if (retrieved_res) {
        retrieved_res->do_work();
    }

    // retrieved_res 在 main 结束时被销毁
    return 0;
}

std::unique_ptr

unique_ptr

class Product {
public:
    Product(int id) : id_(id) { std::cout << "Product " << id_ << " constructed." << std::endl; }
    ~Product() { std::cout << "Product " << id_ << " destructed." << std::endl; }
    void show_info() const { std::cout << "This is Product " << id_ << std::endl; }
private:
    int id_;
};

// 工厂函数：创建一个 Product 对象并返回其所有权
std::unique_ptr<Product> create_product(int id) {
    std::cout << "Inside create_product(" << id << ")" << std::endl;
    // 这里创建一个本地的 unique_ptr
    auto p = std::make_unique<Product>(id);
    // 编译器会优化这里的返回，通常不会有移动操作
    return p;
}

// 另一个函数，接收一个 unique_ptr，处理后返回一个新的 unique_ptr (或原始的)
std::unique_ptr<Product> transform_product(std::unique_ptr<Product> original_product, int new_id) {
    std::cout << "Inside transform_product. Original product ID: ";
    if (original_product) {
        std::cout << original_product->id_ << std::endl;
        // 假设我们在这里销毁旧的，创建一个新的
        // 实际上也可以修改 original_product 并返回
    } else {
        std::cout << "null" << std::endl;
    }
    return std::make_unique<Product>(new_id); // 返回一个新的产品
}


int main() {
    std::cout << "--- Creating product ---" << std::endl;
    // 调用工厂函数，获取一个 Product 的所有权
    std::unique_ptr<Product> my_product = create_product(1);
    if (my_product) {
        my_product->show_info();
    }

    std::cout << "\n--- Transforming product ---" << std::endl;
    // 将 my_product 的所有权转移给 transform_product，并接收新的所有权
    std::unique_ptr<Product> transformed_product = transform_product(std::move(my_product), 2);
    // 此时 my_product 已经为空
    if (transformed_product) {
        transformed_product->show_info();
    }

    // transformed_product 在 main 结束时自动销毁
    std::cout << "\n--- End of main ---" << std::endl;
    return 0;
}

T*

shared_ptr

unique_ptr