shared_ptrを許可する理由<T[N]>？

Question

This answerstd::shared_ptrに対する今後の変更の両方T[]とT[N]変異体を可能にすることを示している、N4082を引用：アレイのunique_ptr部分特殊異なり

をshared_ptr<T[]>とshared_ptr<T[N]>の両方が有効になり、両方がdelete[]あることになりオブジェクトの管理された配列で呼び出されます。

template<class Y> explicit shared_ptr(Y* p); 

が必要です：Yは完全な型でなければなりません。配列が配列タイプの場合、配列タイプでない場合はとなります。Tは整形式で、十分に定義された振る舞いを持ち、例外をスローしないものとします。 TがU[N]の場合、Y(*)[N]はT*に変換可能です。 TがU[]の場合、Y(*)[]はT*に変換可能です。そうでなければ、Y*はT*に変換可能とする。

私が間違ってる場合を除き、Y(*)[N]は明確shared_ptrが所有または削除することはできません、配列のアドレスを取ることによって形成することができます。また、Nが管理対象オブジェクトのサイズをに適用するという表示はありません。

T[N]の構文を可能にする背景には何がありますか？それは実際の利益をもたらしますか？あれば、どのように使用されますか？

Answer 1

私が間違ってる場合を除き、Y(*)[N]は明確shared_ptrが所有または削除することはできません、配列のアドレス を取ることによって形成することができます。

shared_ptrは、一般的なリソース管理ユーティリティで、カスタムデアロケータを構築することができるということを忘れないでください：

template<class Y, class D> shared_ptr(Y* p, D d); 

このようなユーザー提供のデアロケータはdelete/delete[]以外のアクションを実行することができます。たとえば、問題の配列がファイル記述子の配列である場合、「デアロケータ」はそれらのすべてを閉じることができます。

このような場合、shared_ptrは広く使用されている意味でオブジェクトを所有していないため、そのアドレスを取ることによって既存の配列にバインドすることができます。

Answer 2

所有権を共有するネストされたオブジェクトへのポインタを、包含するオブジェクトにstd::shared_ptrで渡すことができます。このネストされたオブジェクトが配列であることを起こる、あなたは配列型としてアクセスしたい場合は、実際には、適切なTとNでT[N]を使用する必要があります。上記のコードqで

#include <functional> 
#include <iostream> 
#include <iterator> 
#include <memory> 
#include <queue> 
#include <utility> 
#include <vector> 

using queue = std::queue<std::function<void()>>; 

template <typename T> 
struct is_range { 
    template <typename R> static std::false_type test(R*, ...); 
    template <typename R> static std::true_type test(R* r, decltype(std::begin(*r))*); 
    static constexpr bool value = decltype(test(std::declval<T*>(), nullptr))(); 
}; 

template <typename T> 
std::enable_if_t<!is_range<T>::value> process(T const& value) { 
    std::cout << "value=" << value << "\n"; 
} 

template <typename T> 
std::enable_if_t<is_range<T>::value> process(T const &range) { 
    std::cout << "range=["; 
    auto it(std::begin(range)), e(std::end(range)); 
    if (it != e) { 
     std::cout << *it; 
     while (++it != e) { 
      std::cout << ", " << *it; 
     } 
    } 
    std::cout << "]\n"; 
} 

template <typename P, typename T> 
std::function<void()> make_fun(P const& p, T& value) { 
    return [ptr = std::shared_ptr<T>(p, &value)]{ process(*ptr); }; 
          // here ----^ 
} 

template <typename T, typename... M> 
void enqueue(queue& q, std::shared_ptr<T> const& ptr, M... members) { 
    (void)std::initializer_list<bool>{ 
     (q.push(make_fun(ptr, (*ptr).*members)), true)... 
     }; 
} 

struct foo { 
    template <typename... T> 
    foo(int v, T... a): value(v), array{ a... } {} 
    int value; 
    int array[3]; 
    std::vector<int> vector; 
}; 

int main() { 
    queue q; 
    auto ptr = std::make_shared<foo>(1, 2, 3, 4); 
    enqueue(q, ptr, &foo::value, &foo::array, &foo::vector); 
    while (!q.empty()) { 
     q.front()(); 
     q.pop(); 
    } 
} 

だけのシンプルなstd::queue<std::function<void()>>ですが、私はあなたが別のスレッドに処理をオフロードするスレッドプールであるかもしれないと想像できることを願っています。実際にスケジュールされた処理も簡単ですが、実際にはかなりの量の作業であると想像していただければ幸いです。