为什么允许shared_ptr<T[N]>？

Why allow shared_ptr<T[N]>?

本文关键字：gt lt shared ptr 为什么      更新时间：2023-10-16

这个答案引用了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]语法背后的动机是什么?它是否产生任何实际的好处，如果有，它是如何使用的?

您可以获得一个指向嵌套对象的指针，该指针与指向包含对象的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()>>，但我希望你能想象它可能是一个线程池，将处理卸载到另一个线程。实际调度的处理也很琐碎，但是，我希望您能再次想象到它实际上是相当多的工作。

除非我弄错了，Y(*)[N]只能通过获取地址来形成一个数组，显然不能被shared_ptr拥有或删除。

不要忘记shared_ptr是一个通用的资源管理实用程序，可以用自定义的deallocator来构建:

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

这样一个用户提供的deallocator可以执行delete/delete[]以外的操作。例如，如果所讨论的数组是一个文件描述符数组，那么"deallocator"可以关闭所有的文件描述符。

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

相关文章：