std::unique_ptr

 

C++

コンパイラサポート

フリースタンディングとホスト

言語

標準ライブラリ

標準ライブラリヘッダー

名前付き要件

機能テストマクロ (C++20)

言語サポートライブラリ

コンセプトライブラリ (C++20)

診断ライブラリ

メモリ管理ライブラリ

メタプログラミングライブラリ (C++11)

汎用ユーティリティライブラリ

コンテナライブラリ

イテレータライブラリ

Rangesライブラリ (C++20)

アルゴリズムライブラリ

文字列ライブラリ

テキスト処理ライブラリ

数値ライブラリ

日付と時刻ライブラリ

入出力ライブラリ

ファイルシステムライブラリ (C++17)

並行サポートライブラリ (C++11)

実行制御ライブラリ (C++26)

Technical specifications (技術仕様)

シンボルインデックス

外部ライブラリ

 

メモリ管理ライブラリ

voidify (説明用*) 未初期化メモリのアルゴリズム uninitialized_copy uninitialized_fill uninitialized_move (C++17) uninitialized_default_construct (C++17) uninitialized_value_construct (C++17) destroy (C++17) destroy_at (C++17) uninitialized_copy_n (C++11) uninitialized_fill_n uninitialized_move_n (C++17) uninitialized_default_construct_n (C++17) uninitialized_value_construct_n (C++17) destroy_n (C++17) construct_at (C++20) 制約付き未初期化 メモリアルゴリズム ranges::uninitialized_copy (C++20) ranges::uninitialized_fill (C++20) ranges::uninitialized_move (C++20) ranges::construct_at (C++20) ranges::destroy (C++20) ranges::destroy_n (C++20) ranges::destroy_at (C++20) ranges::uninitialized_copy_n (C++20) ranges::uninitialized_fill_n (C++20) ranges::uninitialized_move_n (C++20) ranges::uninitialized_default_construct (C++20) ranges::uninitialized_value_construct (C++20) ranges::uninitialized_default_construct_n (C++20)  ranges::uninitialized_value_construct_n (C++20) Cライブラリ malloc calloc realloc aligned_alloc (C++17) free

アロケータ allocator allocator_traits (C++11) allocation_result (C++23) allocator_arg (C++11) uses_allocator (C++11) uses_allocator_construction_args (C++20) make_obj_using_allocator (C++20) uninitialized_construct_using_allocator (C++20)  scoped_allocator_adaptor (C++11) pmr::polymorphic_allocator (C++17) メモリリソース pmr::memory_resource (C++17) pmr::get_default_resource (C++17) pmr::set_default_resource (C++17) pmr::new_delete_resource (C++17) pmr::null_memory_resource (C++17) pmr::synchronized_pool_resource (C++17) pmr::unsynchronized_pool_resource (C++17) pmr::monotonic_buffer_resource (C++17) pmr::pool_options (C++17) ガベージコレクションのサポート declare_reachable (C++11)(C++23まで) undeclare_reachable (C++11)(C++23まで) declare_no_pointers (C++11)(C++23まで) undeclare_no_pointers (C++11)(C++23まで) pointer_safety (C++11)(C++23まで) get_pointer_safety (C++11)(C++23まで) 未初期化ストレージ raw_storage_iterator (C++20まで*) get_temporary_buffer (C++20まで*) return_temporary_buffer (C++20まで*) 明示的な生存期間管理 start_lifetime_asstart_lifetime_as_array (C++23)(C++23)

スマートポインタ unique_ptr (C++11) shared_ptr (C++11) weak_ptr (C++11) auto_ptr (C++17まで*) owner_less (C++11) owner_less<void> (C++17) owner_hash (C++26) owner_equal (C++26) enable_shared_from_this (C++11) bad_weak_ptr (C++11) default_delete (C++11) out_ptr_t (C++23) inout_ptr_t (C++23) 低レベルメモリ 管理 operator new operator new[] operator delete operator delete[] get_new_handler (C++11) set_new_handler launder (C++17) bad_alloc bad_array_new_length (C++11) nothrow_t align_val_t (C++17) destroying_delete_t (C++20) new_handler nothrow その他 pointer_traits (C++11) to_address (C++20) addressof (C++11) align (C++11) assume_aligned (C++20) is_sufficiently_aligned (C++26)

 

std::unique_ptr

メンバ関数

unique_ptr::unique_ptr

unique_ptr::~unique_ptr

unique_ptr::operator=

変更

unique_ptr::release

unique_ptr::reset

unique_ptr::swap

監視

unique_ptr::get

unique_ptr::get_deleter

unique_ptr::operator bool

unique_ptr::operator*unique_ptr::operator->

unique_ptr::operator[]

非メンバ関数

make_uniquemake_unique_for_overwrite (C++14)(C++20)

operator==operator!=operator<operator>operator<=operator>=operator<=> (C++20まで)(C++20以降)

operator<< (C++20)

swap(std::unique_ptr)

ヘルパークラス

hash<std::unique_ptr>

 

ヘッダ <memory> で定義
template<     class T,     class Deleter = std::default_delete<T> > class unique_ptr;	(1)	(C++11以降)
template <     class T,     class Deleter > class unique_ptr<T[], Deleter>;	(2)	(C++11以降)

std::unique_ptr はスマートポインタであり、ポインタを介して別のオブジェクトを所有（責任を負う）および管理し、unique_ptr がスコープを外れるときにそのオブジェクトを破棄します。

オブジェクトは、以下のいずれかの場合に、関連するデリータを使用して破棄されます。

• 管理する unique_ptr オブジェクトが破棄される。
• 管理する unique_ptr オブジェクトに operator= または reset() を介して別のポインタが割り当てられる。

オブジェクトは、潜在的にユーザー提供のデリータを使用して、get_deleter()(ptr) を呼び出すことによって破棄されます。デフォルトのデリータ（std::default_delete）は delete 演算子を使用し、オブジェクトを破棄し、メモリを解放します。

unique_ptr は、オブジェクトを所有しないこともあり、その場合は 空 と表現されます。

unique_ptr には2つのバージョンがあります。

1. 単一のオブジェクトを管理します（例: new で割り当てられたもの）。
2. 動的に割り当てられたオブジェクトの配列を管理します（例: new[] で割り当てられたもの）。

このクラスは MoveConstructible および MoveAssignable の要件を満たしますが、CopyConstructible および CopyAssignable の要件は満たしません。

T* が有効な型でない場合（例: T が参照型の場合）、std::unique_ptr<T, Deleter> の定義をインスタンス化するプログラムは不正です。

型要件

- Deleter は FunctionObject、または FunctionObject への左辺値参照、または関数への左辺値参照でなければならず、unique_ptr<T, Deleter>::pointer 型の引数で呼び出し可能である必要があります。

備考

非 const の unique_ptr のみが、管理対象オブジェクトの所有権を別の unique_ptr に転送できます。オブジェクトの寿命が const std::unique_ptr によって管理されている場合、その寿命はポインタが作成されたスコープに限定されます。

unique_ptr は、オブジェクトの寿命を管理するためによく使用されます。

• 動的な寿命を持つオブジェクトを扱うクラスや関数に、正常終了時と例外による終了時の両方で削除を保証することで、例外安全性を提供します。

• 動的な寿命を持つ一意に所有されるオブジェクトの所有権を関数に渡します。

• 動的な寿命を持つ一意に所有されるオブジェクトの所有権を関数から取得します。

• 動的に割り当てられたオブジェクトへのポインタを保持する（例: ポリモーフィックな振る舞いが望ましい場合）std::vector などのムーブ対応コンテナの要素型として。

unique_ptr は、pImpl イディオムでハンドルとして使用しやすくするために、不完全型 T に対して構築することができます。デフォルトのデリータが使用される場合、デリータが呼び出されるコードのポイント（デストラクタ、ムーブ代入演算子、および unique_ptr の reset メンバ関数で発生します）で T は完全でなければなりません。（対照的に、std::shared_ptr は不完全型への生ポインタから構築できませんが、T が不完全な場所で破棄できます）。T がクラステンプレートの特殊化である場合、!p のような unique_ptr をオペランドとして使用するには、ADL のため、T のパラメータが完全である必要があることに注意してください。

T がある基底クラス B の派生クラスである場合、unique_ptr<T> は unique_ptr<B> に暗黙的に変換可能です。結果として得られる unique_ptr<B> のデフォルトデリータは、B のデストラクタが仮想でない限り、operator delete for B を使用し、未定義の動作につながります。std::shared_ptr は異なる振る舞いをすることに注意してください。std::shared_ptr<B> は、型 T の operator delete を使用し、B のデストラクタが仮想でなくても、所有されるオブジェクトは正しく削除されます。

std::shared_ptr とは異なり、unique_ptr は NullablePointer を満たす任意のカスタムハンドル型を介してオブジェクトを管理できます。これにより、例えば、typedef boost::offset_ptr pointer; または別のファンシーポインタを定義する Deleter を提供することで、共有メモリに配置されたオブジェクトを管理できます。

機能テストマクロ	値	規格	機能
__cpp_lib_constexpr_memory	202202L	(C++23)	constexpr std::unique_ptr

入れ子型

型	定義
pointer	std::remove_reference<Deleter>::type::pointer （その型が存在する場合）、そうでなければ T*。NullablePointer を満たさなければなりません。
element_type	T, この unique_ptr が管理するオブジェクトの型
deleter_type	Deleter, デストラクタから呼び出される関数オブジェクト、または関数への左辺値参照、または関数オブジェクトへの左辺値参照。

メンバ関数

(コンストラクタ)	新しい unique_ptr を構築する (public メンバ関数)
(デストラクタ)	管理対象オブジェクトが存在する場合、それを破棄する (public メンバ関数)
operator=	unique_ptr を代入する (public メンバ関数)
変更
release	管理対象オブジェクトへのポインタを返し、所有権を解放する (public メンバ関数)
reset	管理対象オブジェクトを置き換える (public メンバ関数)
swap	管理対象オブジェクトを交換する (public メンバ関数)
監視
get	管理対象オブジェクトへのポインタを返す (public メンバ関数)
get_deleter	管理対象オブジェクトの破棄に使用されるデリータを返す (public メンバ関数)
operator bool	関連付けられた管理対象オブジェクトがあるかどうかをチェックする (public メンバ関数)
単一オブジェクトバージョン, unique_ptr<T>
operator*operator->	管理対象オブジェクトへのポインタを間接参照する (public メンバ関数)
配列バージョン, unique_ptr<T[]>
operator[]	管理対象配列へのインデックス付きアクセスを提供する (public メンバ関数)

非メンバ関数

make_uniquemake_unique_for_overwrite (C++14)(C++20)	新しいオブジェクトを管理する一意のポインタを作成する (関数テンプレート)
operator==operator!=operator<operator<=operator>operator>=operator<=> (C++20で削除)(C++20)	別の unique_ptr または nullptr と比較する (関数テンプレート)
operator<<(std::unique_ptr) (C++20)	管理対象ポインタの値を出力ストリームに出力する (関数テンプレート)
std::swap(std::unique_ptr) (C++11)	std::swap アルゴリズムを特殊化する (関数テンプレート)

ヘルパークラス

std::hash<std::unique_ptr> (C++11)

std::unique_ptr のハッシュサポート (クラステンプレートの特殊化)

例

このコードを実行

#include <cassert>
#include <cstdio>
#include <fstream>
#include <iostream>
#include <locale>
#include <memory>
#include <stdexcept>
 
// helper class for runtime polymorphism demo below
struct B
{
    virtual ~B() = default;
 
    virtual void bar() { std::cout << "B::bar\n"; }
};
 
struct D : B
{
    D() { std::cout << "D::D\n"; }
    ~D() { std::cout << "D::~D\n"; }
 
    void bar() override { std::cout << "D::bar\n"; }
};
 
// a function consuming a unique_ptr can take it by value or by rvalue reference
std::unique_ptr<D> pass_through(std::unique_ptr<D> p)
{
    p->bar();
    return p;
}
 
// helper function for the custom deleter demo below
void close_file(std::FILE* fp)
{
    std::fclose(fp);
}
 
// unique_ptr-based linked list demo
struct List
{
    struct Node
    {
        int data;
        std::unique_ptr<Node> next;
    };
 
    std::unique_ptr<Node> head;
 
    ~List()
    {
        // destroy list nodes sequentially in a loop, the default destructor
        // would have invoked its “next”'s destructor recursively, which would
        // cause stack overflow for sufficiently large lists.
        while (head)
        {
            auto next = std::move(head->next);
            head = std::move(next);
        }
    }
 
    void push(int data)
    {
        head = std::unique_ptr<Node>(new Node{data, std::move(head)});
    }
};
 
int main()
{
    std::cout << "1) Unique ownership semantics demo\n";
    {
        // Create a (uniquely owned) resource
        std::unique_ptr<D> p = std::make_unique<D>();
 
        // Transfer ownership to “pass_through”,
        // which in turn transfers ownership back through the return value
        std::unique_ptr<D> q = pass_through(std::move(p));
 
        // “p” is now in a moved-from 'empty' state, equal to nullptr
        assert(!p);
    }
 
    std::cout << "\n" "2) Runtime polymorphism demo\n";
    {
        // Create a derived resource and point to it via base type
        std::unique_ptr<B> p = std::make_unique<D>();
 
        // Dynamic dispatch works as expected
        p->bar();
    }
 
    std::cout << "\n" "3) Custom deleter demo\n";
    std::ofstream("demo.txt") << 'x'; // prepare the file to read
    {
        using unique_file_t = std::unique_ptr<std::FILE, decltype(&close_file)>;
        unique_file_t fp(std::fopen("demo.txt", "r"), &close_file);
        if (fp)
            std::cout << char(std::fgetc(fp.get())) << '\n';
    } // “close_file()” called here (if “fp” is not null)
 
    std::cout << "\n" "4) Custom lambda expression deleter and exception safety demo\n";
    try
    {
        std::unique_ptr<D, void(*)(D*)> p(new D, [](D* ptr)
        {
            std::cout << "destroying from a custom deleter...\n";
            delete ptr;
        });
 
        throw std::runtime_error(""); // “p” would leak here if it were a plain pointer
    }
    catch (const std::exception&)
    {
        std::cout << "Caught exception\n";
    }
 
    std::cout << "\n" "5) Array form of unique_ptr demo\n";
    {
        std::unique_ptr<D[]> p(new D[3]);
    } // “D::~D()” is called 3 times
 
    std::cout << "\n" "6) Linked list demo\n";
    {
        List wall;
        const int enough{1'000'000};
        for (int beer = 0; beer != enough; ++beer)
            wall.push(beer);
 
        std::cout.imbue(std::locale("en_US.UTF-8"));
        std::cout << enough << " bottles of beer on the wall...\n";
    } // destroys all the beers
}

実行結果の例

1) Unique ownership semantics demo
D::D
D::bar
D::~D
 
2) Runtime polymorphism demo
D::D
D::bar
D::~D
 
3) Custom deleter demo
x
 
4) Custom lambda-expression deleter and exception safety demo
D::D
destroying from a custom deleter...
D::~D
Caught exception
 
5) Array form of unique_ptr demo
D::D
D::D
D::D
D::~D
D::~D
D::~D
 
6) Linked list demo
1,000,000 bottles of beer on the wall...

欠陥レポート

以下の動作変更を伴う欠陥報告が、以前に公開されたC++標準に遡って適用されました。

DR	適用対象	公開された動作	正しい動作
LWG 4144	C++11	T* は有効な型を形成する必要がなかった	必要

関連項目

shared_ptr (C++11)	オブジェクトの所有権を共有するセマンティクスを持つスマートポインタ (クラステンプレート)
weak_ptr (C++11)	std::shared_ptr によって管理されるオブジェクトへの弱い参照 (クラステンプレート)