c++ - smart - ¿Por qué permitir shared_ptr<T[N]>?

unique pointer

Question

Esta respuesta cita N4082 , que muestra que los próximos cambios en std::shared_ptr permitirán las variantes T[] y T[N] :

A diferencia de la especialización parcial unique_ptr para matrices, tanto shared_ptr<T[]> y shared_ptr<T[N]> serán válidas y ambas harán que se llame a delete[] en la matriz administrada de objetos.

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

Requiere : Y debe ser un tipo completo. La expresión delete[] p , cuando T es un tipo de matriz, o delete p , cuando T no es un tipo de matriz, debe estar bien formada, debe tener un comportamiento bien definido y no debe arrojar excepciones. Cuando T es U[N] , Y(*)[N] será convertible a T* ; cuando T es U[] , Y(*)[] será convertible a T* ; de lo contrario, Y* será convertible a T* .

A menos que me equivoque, una Y(*)[N] solo podría formarse tomando la dirección de una matriz, que claramente no puede ser propiedad o eliminada por un shared_ptr . Tampoco veo ninguna indicación de que N se use de ninguna forma para imponer el tamaño del objeto gestionado.

¿Cuál es la motivación detrás de permitir la sintaxis T[N] ? ¿Reparte algún beneficio real y, de ser así, cómo se usa?

Answer 1

A menos que me equivoque, una Y(*)[N] solo podría formarse tomando la dirección de una matriz, que claramente no puede ser propiedad o eliminada por un shared_ptr .

No olvide que shared_ptr es una utilidad de gestión de recursos genérica y puede construirse con un desglose personalizado:

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

Dicho desasignador proporcionado por el usuario puede realizar una acción que no sea delete / delete[] . Por ejemplo, si la matriz en cuestión es una matriz de descriptores de archivos, el "deallocator" puede cerrarlos todos.

En tales casos, shared_ptr no posee el objeto en el sentido ampliamente utilizado y, por lo tanto, puede vincularse a una matriz existente tomando su dirección.

Answer 2

Puede obtener un puntero a un objeto anidado que comparte la propiedad con std::shared_ptr para el objeto que lo contiene. Si este objeto anidado resulta ser una matriz y desea acceder a él como un tipo de matriz, realmente necesita usar T[N] con T y N adecuados:

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

En el código anterior q solo hay una simple std::queue<std::function<void()>> pero espero que puedas imaginar que podría ser un grupo de subprocesos que descargue el procesamiento a otro subproceso. El procesamiento realmente programado también es trivial, pero, de nuevo, espero que puedas imaginar que en realidad es una cantidad sustancial de trabajo.