shared_ptr クラス

参照カウント スマート ポインターを、動的に割り当てられたオブジェクトにラップします。

template<class Ty>
   class shared_ptr {
public:
    typedef Ty element_type;

    shared_ptr();
    shared_ptr(nullptr_t); 
    shared_ptr(const shared_ptr& sp);
    shared_ptr(shared_ptr&& sp);
    template<class Other>
        explicit shared_ptr(Other * ptr);
    template<class Other, class D>
        shared_ptr(Other * ptr, D dtor);
    template<class D>
        shared_ptr(nullptr_t, D dtor);
    template<class Other, class D, class A>
        shared_ptr(Other *ptr, D dtor, A alloc);
    template<class D, class A>
        shared_ptr(nullptr_t, D dtor, A alloc);
    template<class Other>
        shared_ptr(const shared_ptr<Other>& sp);
    template<class Other>
        shared_ptr(const shared_ptr<Other>&& sp);
    template<class Other>
        explicit shared_ptr(const weak_ptr<Other>& wp);
    template<class Other>
        shared_ptr(auto_ptr<Other>& ap);
    template<class Other, class D>
        shared_ptr(unique_ptr<Other, D>&& up);
    template<class Other>
        shared_ptr(const shared_ptr<Other>& sp, Ty *ptr);
    ~shared_ptr();
    shared_ptr& operator=(const shared_ptr& sp);
    template<class Other> 
        shared_ptr& operator=(const shared_ptr<Other>& sp);
    shared_ptr& operator=(shared_ptr&& sp);
    template<class Other> 
        shared_ptr& operator=(shared_ptr<Other>&& sp);
    template<class Other> 
        shared_ptr& operator=(auto_ptr< Other >&& ap);
    template <class Other, class D> 
        shared_ptr& operator=(const unique_ptr< Other, D>& up) = delete;
    template <class Other, class D>
        shared_ptr& operator=(unique_ptr<Other, D>&& up);
    void swap(shared_ptr& sp);
    void reset();
    template<class Other>
        void reset(Other *ptr);
    template<class Other, class D>
        void reset(Other *ptr, D dtor);
    template<class Other, class D, class A>
        void reset(Other *ptr, D dtor, A alloc);
    Ty *get() const;
    Ty& operator*() const;
    Ty *operator->() const;
    long use_count() const;
    bool unique() const;
    operator bool() const;

    template<class Other>
        bool owner_before(shared_ptr<Other> const& ptr) const;
    template<class Other>
        bool owner_before(weak_ptr<Other> const& ptr) const;
    template<class D, class Ty> 
        D* get_deleter(shared_ptr<Ty> const& ptr);
};

パラメーター

• Ty
  共有ポインターによって制御される型。

• Other
  引数ポインターによって制御される型。

• ptr
  コピーするポインター。

• D
  削除子の型。

• A
  アロケーターの型。

• dtor
  削除子。

• alloc
  アロケーター。

• sp
  コピーまたは移動するスマート ポインター。

• wp
  コピーまたは移動するウィーク ポインター。

• ap
  コピーまたは移動する自動ポインター。

• up
  移動する一意のポインター。

解説

このテンプレート クラスは、参照カウントを使ってリソースを管理するオブジェクトを表します。 shared_ptr オブジェクトは、所有しているリソースへのポインターまたは null ポインターを効率的に保持します。 複数の shared_ptr オブジェクトが 1 つのリソースを所有することもできます。その場合、特定のリソースを所有する最後の shared_ptr オブジェクトが破棄された時点で、リソースが解放されます。

shared_ptr は、再割り当てまたはリセットされるとリソースの所有を停止します。

テンプレートの引数 Ty は、特定のメンバー関数について注記がある場合を除き、不完全な型になる場合があります。

shared_ptr<Ty> オブジェクトを G* 型のリソース ポインターまたは shared_ptr<G> から構築する場合、ポインターの型 G* は Ty* に変換可能であることが必要です。 この条件が満たされていない場合、コードはコンパイルされません。 たとえば、次のようになります。

class F {};
class G : public F {};

#include <memory>

using namespace std;

shared_ptr<G> sp0(new G);   // okay, template parameter G and argument G*
shared_ptr<G> sp1(sp0);     // okay, template parameter G and argument shared_ptr<G>
shared_ptr<F> sp2(new G);   // okay, G* convertible to F*
shared_ptr<F> sp3(sp0);     // okay, template parameter F and argument shared_ptr<G>
shared_ptr<F> sp4(sp2);     // okay, template parameter F and argument shared_ptr<F>
shared_ptr<int> sp5(new G); // error, G* not convertible to int*
shared_ptr<int> sp6(sp2);   // error, template parameter int and argument shared_ptr<F>

shared_ptr オブジェクトがリソースを所有するためには、次のいずれかの条件を満たしている必要があります。

• そのリソースへのポインターを使って構築されている。

• そのリソースを所有する shared_ptr オブジェクトから構築されている。

• そのリソースを指し示す weak_ptr クラス オブジェクトから構築されている。

• そのリソースの所有権が、shared_ptr::operator= またはメンバー関数 shared_ptr::reset の呼び出しのいずれかによって割り当てられている。

リソースを所有する shared_ptr オブジェクトは、コントロール ブロックを共有します。 コントロール ブロックは以下の情報を保持します。

• リソースを所有する shared_ptr オブジェクトの数。

• リソースを指す weak_ptr オブジェクトの数。

• リソースの削除子 (存在する場合)

• コントロール ブロックのカスタム アロケーター (存在する場合)

null ポインターを使用して初期化される shared_ptr オブジェクトにはコントロール ブロックが存在し、空ではありません。 shared_ptr オブジェクトがリソースを所有するのは、そのリソースが解放されるまでの間です。 weak_ptr オブジェクトがリソースを指しているのは、そのリソースが解放されるまでの間です。

リソースを所有する shared_ptr オブジェクトの数がゼロになると、リソースを削除するか、リソースのアドレスを削除子に渡すことによって、リソースが解放されます。どちらの方法で解放されるかは、最初にリソースの所有権が作成された方法によって決定されます。 リソースを所有する shared_ptr オブジェクトの数がゼロになり、そのリソースを指す weak_ptr オブジェクトの数がゼロになると、コントロール ブロックのカスタム アロケーターを使用して (存在する場合)、コントロール ブロックが解放されます。

空の shared_ptr オブジェクトは、リソースを一切所有せず、コントロール ブロックも持ちません。

削除子は、メンバー関数 operator() を持つ関数オブジェクトです。 この型はコピーによって構築可能であること、また、コピー コンストラクターおよびデストラクターによって例外がスローされないことが必要です。 削除子は、削除するオブジェクトを指定する 1 つのパラメーターを受け入れます。

一部の関数では、結果として生成される shared_ptr<Ty> または weak_ptr<Ty> オブジェクトのプロパティを定義する引数リストが使用されます。 その場合、引数リストは次のような方法で指定できます。

引数なし: 結果として生成されるオブジェクトは、空の shared_ptr オブジェクトまたは空の weak_ptr オブジェクトです。

ptr -- 管理対象リソースへの Other* 型のポインター。 Ty は完全な型である必要があります。 コントロール ブロックを割り当てることができないため関数が失敗した場合、delete ptr という式が評価されます。

ptr, dtor: 管理対象リソースに対する Other* 型のポインターおよびそのリソースの削除子です。 コントロール ブロックを割り当てることができなかったことが原因で関数が失敗した場合、dtor(ptr) が呼び出されます (明確に定義されていることが必要)。

ptr, dtor, alloc -- 管理対象リソース、そのリソースの削除子、および割り当てと解放を行う必要があるすべてのストレージを管理するためのアロケーターへの Other* 型のポインター。 コントロール ブロックを割り当てることができなかったことが原因で関数が失敗した場合、dtor(ptr) が呼び出されます (明確に定義されていることが必要)。

sp: 管理対象のリソースを所有する shared_ptr<Other> オブジェクトです。

wp: 管理対象のリソースを指し示す weak_ptr<Other> オブジェクトです。

ap: 管理対象のリソースへのポインターを保持する auto_ptr<Other> オブジェクトです。 関数が成功した場合は、ap.release() が呼び出されます。関数が失敗した場合は、ap は変更されません。

いずれの場合も、ポインターの型 Other* は Ty* に変換可能である必要があります。

スレッド セーフ

複数のスレッドが異なる shared_ptr オブジェクト (所有権を共有するコピーである場合も含めて) に対する読み取りと書き込みを同時に行うことができます。

メンバー

コンストラクター

メソッド

演算子

必要条件

ヘッダー: <memory>

名前空間: std

参照

関連項目

weak_ptr クラス

C++ 標準ライブラリ内のスレッド セーフ

その他の技術情報

<memory> メンバー