¿Hay algún uso para unique_ptr con matriz?

Question 1

std::unique_ptr tiene soporte para arreglos, por ejemplo:

std::unique_ptr<int[]> p(new int[10]);

pero es necesario? probablemente sea más conveniente usar std::vector o std::array.

¿Encuentras algún uso para esa construcción?

Question 2

Algunas personas no pueden darse el lujo de usar std::vector, incluso con asignadores. Algunas personas necesitan una matriz de tamaño dinámico, por lo que std::array Está fuera. Y algunas personas obtienen sus matrices de otro código que se sabe que devuelve una matriz; y ese código no se va a reescribir para devolver un vector o algo.

Al permitir unique_ptr<T[]>usted atiende esas necesidades.

En resumen, usas unique_ptr<T[]> Cuando usted necesitar para. Cuando las alternativas simplemente no van a funcionar para usted. Es una herramienta de último recurso.

Question 3

Hay compensaciones, y usted elige la solución que coincida con lo que desea. La parte superior de mi cabeza:

Tamaño inicial

vector y unique_ptr<T[]> permitir que el tamaño se especifique en tiempo de ejecución
array solo permite especificar el tamaño en tiempo de compilación

Cambiar el tamaño

array y unique_ptr<T[]> no permitir cambiar el tamaño
vector lo hace

Almacenamiento

vector y unique_ptr<T[]> almacenar los datos fuera del objeto (típicamente en el montón)
array almacena los datos directamente en el objeto

Proceso de copiar

array y vector permitir copiar
unique_ptr<T[]> no permite copiar

intercambiar/mover

vector y unique_ptr<T[]> tener O(1) tiempo swap y mover operaciones
array tiene tiempo O(n) swap y mover operaciones, donde n es el número de elementos en la matriz

Invalidación de puntero/referencia/iterador

array garantiza que los punteros, las referencias y los iteradores nunca se invalidarán mientras el objeto esté activo, incluso en swap()
unique_ptr<T[]> no tiene iteradores; punteros y referencias sólo son invalidados por swap() mientras el objeto está activo. (Después del intercambio, los punteros apuntan a la matriz con la que intercambió, por lo que aún son “válidos” en ese sentido).
vector puede invalidar punteros, referencias e iteradores en cualquier reasignación (y proporciona algunas garantías de que la reasignación solo puede ocurrir en ciertas operaciones).

Compatibilidad con conceptos y algoritmos

array y vector ambos son contenedores
unique_ptr<T[]> no es un contenedor

Debo admitir que esto parece una oportunidad para refactorizar con un diseño basado en políticas.

Question 4

Una de las razones por las que podría usar un unique_ptr es si no quiere pagar el costo del tiempo de ejecución de inicialización de valor la matriz

std::vector<char> vec(1000000); // allocates AND value-initializes 1000000 chars

std::unique_ptr<char[]> p(new char[1000000]); // allocates storage for 1000000 chars

los std::vector constructor y std::vector::resize() inicializará el valor T – pero new no hare eso si T es un POD.

Consulte Objetos inicializados por valor en C++ 11 y constructor std::vector

Tenga en cuenta que vector::reserve no es una alternativa aquí: ¿Es seguro acceder al puntero sin formato después de std::vector::reserve?

Es la misma razón por la que un programador de C podría elegir malloc sobre calloc.

Question 5

Un std::vector se puede copiar, mientras que unique_ptr<int[]> permite expresar la propiedad única de la matriz. std::arraypor otro lado, requiere que el tamaño se determine en tiempo de compilación, lo que puede ser imposible en algunas situaciones.

Question 6

Scott Meyers tiene esto que decir en Eficaz Modern C++

La existencia de std::unique_ptr porque las matrices deberían ser solo de interés intelectual para usted, porque std::array,
std::vector, std::string son prácticamente siempre mejores opciones de estructura de datos que las matrices sin formato. Acerca de la única situación que puedo concebir cuando un std::unique_ptr<T[]> tendría sentido sería cuando está utilizando una API similar a C que devuelve un puntero sin procesar a una matriz de montón de la que asume la propiedad.

Sin embargo, creo que la respuesta de Charles Salvia es relevante: que std::unique_ptr<T[]> es la única forma de inicializar una matriz vacía cuyo tamaño no se conoce en tiempo de compilación. ¿Qué diría Scott Meyers sobre esta motivación para usar std::unique_ptr<T[]>?

Question 7

Contrariamente a std::vector y std::array, std::unique_ptr puede poseer un puntero NULL.
Esto es útil cuando se trabaja con API de C que esperan una matriz o NULL:

void legacy_func(const int *array_or_null);

void some_func() {    
    std::unique_ptr<int[]> ptr;
    if (some_condition) {
        ptr.reset(new int[10]);
    }

    legacy_func(ptr.get());
}

Question 8

No puedo estar en desacuerdo con el espíritu de la respuesta aceptada lo suficiente. ¿”Una herramienta de último recurso”? ¡Lejos de ahi!

A mi modo de ver, una de las características más sólidas de C++ en comparación con C y otros lenguajes similares es la capacidad de expresar restricciones para que se puedan verificar en el momento de la compilación y se pueda evitar el mal uso accidental. Entonces, cuando diseñe una estructura, pregúntese qué operaciones debe permitir. Todos los demás usos deben estar prohibidos, y es mejor si tales restricciones se pueden implementar de forma estática (en tiempo de compilación) para que el mal uso resulte en una falla de compilación.

Entonces, cuando se necesita una matriz, las respuestas a las siguientes preguntas especifican su comportamiento: 1. ¿Su tamaño es a) dinámico en tiempo de ejecución, o b) estático, pero solo conocido en tiempo de ejecución, o c) estático y conocido en tiempo de compilación? 2. ¿Se puede asignar la matriz en la pila o no?

Y según las respuestas, esto es lo que veo como la mejor estructura de datos para una matriz de este tipo:

       Dynamic     |   Runtime static   |         Static
Stack std::vector      unique_ptr<T[]>          std::array
Heap  std::vector      unique_ptr<T[]>     unique_ptr<std::array>

si, creo unique_ptr<std::array> también debe considerarse, y tampoco es una herramienta de último recurso. Piensa qué encaja mejor con tu algoritmo.

Todos estos son compatibles con las API de C simples a través del puntero sin procesar a la matriz de datos (vector.data() / array.data() / uniquePtr.get()).

PD Además de las consideraciones anteriores, también hay una de propiedad: std::array y std::vector tienen semántica de valor (tienen soporte nativo para copiar y pasar por valor), mientras que unique_ptr<T[]> solo se puede mover (hace cumplir la propiedad única). Cualquiera de los dos puede ser útil en diferentes escenarios. Por el contrario, los arreglos estáticos simples (int[N]) y matrices dinámicas simples (new int[10]) no ofrecen ninguno y, por lo tanto, deben evitarse si es posible, lo que debería ser posible en la gran mayoría de los casos. Si eso no fuera suficiente, las matrices dinámicas simples tampoco ofrecen ninguna forma de consultar su tamaño: una oportunidad adicional para la corrupción de la memoria y los agujeros de seguridad.

¿Ha sido útil esta solución?