c++ - studio - Devolver un vector de unique_ptr de la función

visual studio installer

Question

Actualmente estoy revisando el libro Análisis y diseño orientado a objetos de First First y también estoy acostumbrándome a algunas de las características de C ++ 11 (especialmente unique_ptr y semántica de movimientos) al mismo tiempo. En el libro, dan el diseño de un juego de mesa de estrategia como ejemplo. Tiene una tabla, fichas y unidades en fichas. El código está en Java y estaba intentando reescribirlo en C ++. En Java, la clase de mosaico es la siguiente:

public class Tile
{
    private List units;

    public Tile()
    {
        units = new LinkedList();
    }

    protected void addUnit(Unit unit)
    {
        units.add(unit);
    }

    protected List getUnits()
    {
        return units;
    }
}

Hice lo mismo en c ++ primero usando shared_ptr. Funcionó pero fue muy lento en comparación con mi segunda versión, que usaba punteros crudos. Luego intenté unique_ptr:

class Tile
{

public:
  Tile();
  virtual ~Tile();

  void addUnit()
  {
    mUnits.push_back(std::unique_ptr<Unit>(new Unit());
  }

  std::vector<std::unique_ptr<Unit>> getUnits()
  {
    return mUnits;
  }

private:
  std::vector<std::unique_ptr<Unit>> mUnits;

};

al compilador no le gustan las getUnits. Por lo que entiendo proviene del hecho de que el constructor de copia está deshabilitado en el unique_ptr. ¿Cómo devolverías la lista de vectores? ¡Gracias!

Answer 1

Un valor devuelto en C ++ genera una copia; si eso es lo que desea, no puede usar unique_ptr o tiene que hacer una copia manual y std::move . Sin embargo, considero que solo desea proporcionar acceso a la Unit (por cualquier razón ...), simplemente devuelva una referencia:

std::vector<std::unique_ptr<Unit>> const& getUnits() const
{
  return mUnits;
}

(La const solo es necesaria si no desea otorgar acceso de escritura al vector).

Ahora, aún surgen algunas preguntas: ¿por qué ~Tile virtual ? No veo la necesidad

¿Por qué usas un ptr propietario para señalar las unidades? En el código original de Java, se le entrega una referencia a una Unidad externa y solo se almacena una referencia: si se destruye la Tile en el código de Java, las unidades no son (por lo que puedo ver), siempre que se mencionen en algún lugar más. Para lograr exactamente lo mismo en C ++, tenías razón al usar shared_ptr .

Por supuesto, puede aclarar quién es el verdadero propietario de las unidades y operar en consecuencia; si no es Tile , use un puntero sin formato. Ver también "¿Qué tipo de puntero uso cuando?"