una - Inicialización de matriz C++ 11 con un tipo no copiable con constructor explícito

matriz en c++ codigo

Question

Tengo una clase (de terceros) que no se puede copiar. Me gustaría inicializar una matriz de ellos. Este es mi mejor intento:

#include <array>

class Thing
{
public:
  explicit Thing(int) {}
  Thing(const Thing&) = delete;
};

int main()
{
  std::array<Thing, 1> things{{{100}}}; // error here
};

GCC 4.7.2 dice:

error: la conversión a ''std :: array :: value_type {aka Thing}'' de la lista de inicializadores usaría el constructor explícito ''Thing :: Thing (int)''

OK, pero eso es exactamente lo que quiero: usar el constructor explícito. ¿Cómo puedo expresar eso? Si invoco al constructor yo mismo, entonces aparece un error sobre la eliminación del constructor de copia. Y no puedo usar std::move() porque Thing no se puede mover (y no puedo modificarlo).

La única alternativa que he encontrado hasta ahora es https://stackoverflow.com/a/15962814/4323, pero esto es indeseable porque es un montón de código adicional, además necesito echar el "almacenamiento" donde sea que lo use (o mantener un puntero por separado, que agrega direccionamiento indirecto que no quiero).

Quiero una solución que ofrezca el máximo rendimiento cuando se usan las Cosas sin muchos repinches desagradables.

Answer 1

Intenté agregar el operador predeterminado de mover movimiento y mover asignación, cambié la inicialización un poco y compila:

#include <array>

class Thing
{
public:
  explicit Thing(int) {}
  Thing(const Thing&) = delete;
  Thing(Thing&&) = default;
  Thing& operator=(Thing&&) = default;
};

int main()
{
    std::array<Thing, 1> things {{ Thing(100) }}; // error gone
}

EDITAR: me había perdido la parte de "terceros". Lo siento si esto no ayuda :)

Answer 2

Puedes usar un std::vector :

std::vector<Thing> things;
things.reserve(1);
things.emplace_back(100);

o para un solo boost::optional elemento boost::optional :

boost::optional<Thing> thing;
thing.emplace(100);

Answer 3

Una vez más, la elisión de copia garantizada de C ++ 17 viene al rescate: una expresión como Thing{100} ya no crea un objeto sino que simplemente especifica cómo se creará otro objeto (su elemento de matriz).