std::unique_ptr (c++11)

1-1. その1

最初にシンプルな unique_ptr 使用例を紹介します。

unique_ptr を直接使用する例を記載します。

int 型の生成は、以下のように使用します。

std::unique_ptr up(new int);

値の初期化を一緒に行いたい場合、以下のように使用します。下記例は 10 で初期化しています。

std::unique_ptr up(new int(10));

配列を確保する場合は、以下のように使用します。

std::unique_ptr arr_up(new int[5]);

配列の値を初期化と一緒に行いたい場合、以下のように使用します。下記例は {1,2,3,4,5} で初期化しています。

std::unique_ptr arr_up(new int[5]{1,2,3,4,5});

make_unique による例を記載します。

int 型の生成は、以下のように使用します。

auto up = std::make_unique(77);

値の初期化を一緒に行いたい場合、以下のように使用します。下記例は 10 で初期化しています。

auto up = std::make_unique(77);

配列を確保する場合、以下のように使用します。下記例では、配列数 5 です。
make_unique を使って初期化を一緒に行うことはできないようです。

auto arr_up = std::make_unique(5); // 要素はデフォルト初期化（ゼロでない場合あり）
for (int i = 0; i < 5; ++i) {
    arr_up[i] = (i + 1) * 10;
}

上記内容を含む c++ プログラムを以下で紹介します。

ソースコード：

["unique_ptr_01.cpp"]

#include <iostream>     // for std::cout
#include <new>          // for std::nothrow, placement new
#include <memory>       // for std::make_unique
 
/**
 * @brief new/delete のシンプルなサンプル（構造体/クラスを使用しない）
 *
 * - 組み込み型（int）を使って `new` / `delete` / `new[]` / `delete[]` を示す
 * - `std::nothrow` と placement new の簡単な例を含む
 */
 
int main() {
    std::cout << "-- uqique_ptr simple examples start --\n";

    // 1) 単一 int の std::unique_ptr
    {
        std::unique_ptr<int> up(new int(10));
        std::cout << "*up = " << *up << "\n";
        // delete は自動的に行われる
    }

    // 2) int 配列の std::unique_ptr
    {
        std::unique_ptr<int[]> arr_up(new int[5]{1,2,3,4,5});
        for (int i = 0; i < 5; ++i) {
            std::cout << "arr_up[" << i << "] = " << arr_up[i] << "\n";
        }
        // delete[] は自動的に行われる
    }

    // 3) 単一 int 生成、std::make_unique 版
    {
        auto up = std::make_unique<int>(77);
        std::cout << "unique_ptr owns = " << *up << "\n";
        // delete は自動的に行われる
    }

    // 4) 配列 int 生成、std::make_unique 配列版（C++14 以降）
    {
        auto arr_up = std::make_unique<int[]>(5); // 要素はデフォルト初期化（ゼロでない場合あり）
        for (int i = 0; i < 5; ++i) {
            arr_up[i] = (i + 1) * 10;
        }
        std::cout << "make_unique<int[]> contents:";
        for (int i = 0; i < 5; ++i) {
            std::cout << ' ' << arr_up[i];
        }
        std::cout << '\n';
        // delete[] は自動的に行われる
    }

    std::cout << "-- uqique_ptr simple examples end --\n";
    return 0;
}

ビルド方法：

g++ -std=c++17 -Wall -Wextra -O2 unique_ptr_01.cpp -o unique_ptr_01.out

実行結果：

$ ./unique_ptr_01.out 
-- uqique_ptr simple examples start --
*up = 10
arr_up[0] = 1
arr_up[1] = 2
arr_up[2] = 3
arr_up[3] = 4
arr_up[4] = 5
unique_ptr owns = 77
make_unique<int[]> contents: 10 20 30 40 50
-- uqique_ptr simple examples end --
$ 

1-2. その2

前の節で unique_ptr の簡単な使用方法について記載しました。

でも「本当に解放処理を自動的にやってくれてるのか心配」ですよね。

本節では、unique_ptr で class インスタンスを生成して、delete 無しで自動的にデストラクタが実行されることを確認してみます。

[環境]

[ソースコード： "unique_ptr.cpp"]

#include <iostream>     // cout, endl
#include <string>       // string
#include <memory>       // unique_ptr
#include <cstdlib>      // EXIT_SUCCESS

class Person {
private:
    std::string name_;
    std::string phone_;

public:
    /**
     * @brief デフォルトコンストラクタ
     *        空の名前と電話番号で委譲コンストラクタを呼ぶ
     */
    Person()
        : Person("", "")                // 委譲コンストラクタ
    {
    }

    /**
     * @brief コピーコンストラクタ
     * @param rhs コピー元
     */
    Person(const Person& rhs)
        : Person(rhs.name_, rhs.phone_)
    {
    }

    /**
     * @brief 値を指定するコンストラクタ
     * @param name 氏名
     * @param phone 電話番号
     */
    Person(std::string name, std::string phone)
        : name_(std::move(name)), phone_(std::move(phone))
    {
        std::cout << "Person::Person()" << std::endl;
    }

    /**
     * @brief デストラクタ
     */
    virtual ~Person()
    {
        std::cout << "Person::~Person()" << std::endl;
    }

    /**
     * @brief 名前を取得する
     * @return 名前への参照
     */
    const std::string& getName() const
    {
        return name_;
    }

    /**
     * @brief 電話番号を取得する
     * @return 電話番号への参照
     */
    const std::string& getPhone() const
    {
        return phone_;
    }
};


// Person を出力する演算子オーバーロード
std::ostream& operator<<(std::ostream& os, const Person& p)
{
    return (os << '(' << p.getName() << ',' << p.getPhone() << ')');
}

/**
 * @brief Person をコンソール出力する（null 安全）
 * @param person 出力対象の unique_ptr
 */
void coutPerson(const std::unique_ptr<Person>& person)
{
    if (person) {
        std::cout << *person << std::endl;
    } else {
        std::cout << "(null)" << std::endl;
    }
}

/**
 * @brief unique_ptr が指す Person を差し替える（所有権は引数で渡された参照側に残る）
 * @param person 差し替え対象の unique_ptr への参照
 */
void replacePerson(std::unique_ptr<Person>& person)
{
    person = std::make_unique<Person>("bar_2", "090-****-????");
}

int main()
{
    // unique_ptr 生成
    std::unique_ptr<Person> foo = std::make_unique<Person>("foo", "090-****-0123");
    std::unique_ptr<Person> bar = std::make_unique<Person>("bar", "090-****-5555");
    std::unique_ptr<Person> hoge;

    // コンソール出力
    coutPerson(foo);        // (foo,090-****-0123)
    coutPerson(bar);        // (bar,090-****-5555)
    coutPerson(hoge);       // (null)

    // Person 差し替え
    replacePerson(bar);
    coutPerson(bar);        // (bar_2,090-****-????)

    // 所有権の移動
    hoge = std::move(foo);
    // hoge = foo;          // これはコンパイルエラーになる
    coutPerson(foo);        // (null)
    coutPerson(hoge);       // (foo,090-****-0123)

    return EXIT_SUCCESS;
}

ビルド(例)：

$ g++ -Wall -g make_unique.cpp -o make_unique.out

実行結果：

$ ./make_unique.out 
Person::Person()
Person::Person()
(foo,090-****-0123)
(bar,090-****-5555)
(null)
Person::Person()
Person::~Person()
(bar_2,090-****-????)
(null)
(foo,090-****-0123)
Person::~Person()
Person::~Person()
$ 

3箇所でクラス Person のデストラクタが実行されている（"Person::~Person()" の部分）ことから、unique_ptr が期待通りに解放処理を行っていることがわかります。