为什么要让shared_ptr <T[N]>？

Question

This answer援引N4082，其示出了即将对std::shared_ptr变化将允许T[]和T[N]的变体：

不同于用于阵列unique_ptr部分特，既shared_ptr<T[]>和shared_ptr<T[N]>将是有效的，都将导致delete[]是调用托管的对象数组。

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

需要：Y应是一个完整的类型。表达式delete[] p，当T是数组类型时，或delete p，当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[]执行其他的操作。例如，如果问题数组是一个文件描述符数组，“deallocator”可以关闭所有这些数组。

在这种情况下，shared_ptr不拥有广泛使用的意义上的对象，因此可以通过获取其地址绑定到现有的数组。

Answer 2

您可以获取一个指向共享所有权的嵌套对象的指针，std::shared_ptr指向包含对象。如果该嵌套的对象恰好是一个数组，你要访问它作为一个数组类型，你实际上需要用合适的T和N使用T[N]：

#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(); 
    } 
} 

在上面的代码q仅仅是一个简单的std::queue<std::function<void()>>但我希望你可以想象它可能是一个线程池将处理卸载到另一个线程。实际预定的处理也是微不足道的，但我希望你可以想象它实际上是一些大量的工作。