How do I pass a unique_ptr argument to a constructor or a function?

When passing a unique_ptr parameter to a constructor or function, you have several approaches to consider, depending on how you want the function or constructor to manage the pointer. unique_ptr is a smart pointer that owns the object it points to and ensures exclusive ownership. Consequently, unique_ptr is non-copyable and can only be moved. This leads to our main strategies:

1. Passing unique_ptr via Move Semantics

This is the most common approach, as it maintains the ownership semantics of unique_ptr. By passing unique_ptr using move semantics, you transfer ownership from one object to another. This is typically achieved when the function or constructor accepts a unique_ptr as a rvalue reference.

Example Code:

cpp
#include <memory>
#include <iostream>

class Resource {
public:
    Resource() { std::cout << "Resource acquired\n"; }
    ~Resource() { std::cout << "Resource destroyed\n"; }
};

class MyClass {
private:
    std::unique_ptr<Resource> res;

public:
    MyClass(std::unique_ptr<Resource>&& _res) : res(std::move(_res)) {}
    void useResource() { std::cout << "Using resource\n"; }
};

int main() {
    std::unique_ptr<Resource> res = std::make_unique<Resource>();
    MyClass obj(std::move(res));

    obj.useResource();
    return 0;
}

In this example, the Resource class represents a resource requiring careful management. The MyClass constructor accepts a unique_ptr<Resource> and takes ownership via move semantics. In the main function, we create a unique_ptr for Resource and move it into an instance of MyClass.

2. Passing as Raw Pointer or Reference

If you do not want to transfer unique_ptr ownership but still need access to the resource it manages, you can pass a raw pointer or reference to the object it points to.

Example Code:

cpp
#include <memory>
#include <iostream>

class Resource {
public:
    Resource() { std::cout << "Resource acquired\n"; }
    ~Resource() { std::cout << "Resource destroyed\n"; }
};

class MyClass {
private:
    Resource* res;

public:
    MyClass(Resource* _res) : res(_res) {}
    void useResource() { std::cout << "Using resource\n"; }
};

int main() {
    std::unique_ptr<Resource> res = std::make_unique<Resource>();
    MyClass obj(res.get());

    obj.useResource();
    return 0;
}

In this example, the MyClass constructor accepts a Resource* pointer. We obtain the raw pointer using get() from the unique_ptr and pass it to MyClass. This approach does not affect unique_ptr ownership.

Summary

The key to choosing these methods lies in your ownership requirements. If you need to transfer ownership, use the first approach; if you only need access to the resource without transferring ownership, use the second approach. When designing interfaces, clearly defining ownership and lifecycle management is crucial. In C++, std::unique_ptr is a smart pointer that owns the object it points to and guarantees exclusive ownership, meaning it is non-copyable and can only be moved. When passing std::unique_ptr to a constructor or function, always use move semantics to transfer ownership safely and efficiently.

Passing std::unique_ptr to a Constructor

To accept a std::unique_ptr parameter in a constructor, typically use move semantics. This is achieved via std::move, which converts the object to a rvalue reference, triggering the move constructor or move assignment.

Here is an example:

cpp
#include <iostream>
#include <memory>

class Resource {
public:
    Resource() { std::cout << "Resource created\n"; }
    ~Resource() { std::cout << "Resource destroyed\n"; }
};

class Consumer {
public:
    std::unique_ptr<Resource> ptr;

    // Constructor accepting a std::unique_ptr parameter
    Consumer(std::unique_ptr<Resource> p) : ptr(std::move(p)) {}

    void useResource() {
        std::cout << "Using resource\n";
    }
};

int main() {
    std::unique_ptr<Resource> res = std::make_unique<Resource>();
    Consumer cons(std::move(res));

    cons.useResource();

    return 0;
}

In this example, the Consumer constructor accepts a std::unique_ptr<Resource> parameter and transfers ownership to the member variable ptr using std::move. This ensures resource ownership moves from res to Consumer's ptr.

Using std::unique_ptr in Functions

When passing std::unique_ptr as a parameter to a regular function, use move semantics similarly.

For example:

cpp
void processResource(std::unique_ptr<Resource> res) {
    std::cout << "Processing resource\n";
}

int main() {
    std::unique_ptr<Resource> res = std::make_unique<Resource>();
    processResource(std::move(res));

    if (!res) {
        std::cout << "Resource has been transferred\n";
    }

    return 0;
}

In this example, the processResource function accepts a std::unique_ptr<Resource> parameter. When calling the function, std::move transfers ownership from res to the function's parameter. After the move, the original res becomes nullptr, indicating it no longer owns the resource.

Summary

When passing std::unique_ptr to a constructor or function, always use std::move to transfer ownership. This is necessary because std::unique_ptr is designed to be non-copyable and movable only. This approach ensures safe resource management and optimal performance.