Home / Questions / 98503
Accepted
eferion
Asked: 2020-08-31 03:26:12 +0800 CST 2020-08-31 03:26:12 +0800 CST

Avoid unnecessary copies

  • 772

I have an object that internally stores a pretty heavy collection of objects. This collection is populated on demand, i.e. if the collection is not needed it will not be populated for life:

class Objeto
{
  std::vector<int> coleccion;

  // Solo una factoría puede crear objetos de este tipo
  Objeto();

  void RellenarColeccion()
  { /* ... */ }

public:

  // No se admiten copias
  Objeto(Objeto const&) = delete;

  // Constructor move
  Objeto(Objeto &&) = default;

  std::vector<int> const& Coleccion()
  {
    if( coleccion.empty() )
      RellenarColeccion();

     return coleccion;
  }
};

The class works perfectly. Returning a reference to the collection prevents copies and the program ends up working reasonably well... until the need arises to copy the collection from the object.

This need arises in a particular situation in which the only thing that matters about the object is its internal collection:

Objeto NuevoObjeto() // Función que emula la factoría
{ return Objeto; }

int main()
{
  // Se invoca la sintaxis move y la copia es bastante liviana
  Objeto o1 = NuevoObjeto();

  // Obtenemos la colección vía referencia. Evitamos la copia
  auto& v1 = o1.Coleccion();

  // El problema lo tenemos cuando del objeto solo queremos su coleccion
  // La copia es demasiado pesada
  auto v2 = NuevoObjeto().Coleccion();

  // Y no nos podemos quedar con la referencia
  auto& v3 = NuevoObjeto().Coleccion(); // Referencia a objeto destruido
}

Is there a solution that allows you to take advantage of the move syntax by making changes only to Objeto? The expected would be the following:

int main()
{
  // caso 1: se accede por referencia
  Objeto o1 = NuevoObjeto();
  auto& v1 = o1.Coleccion();

  // caso 2: Se llama a la sintaxis move para evitar la copia del vector
  auto v2 = NuevoObjeto().Coleccion();
}
c++

2 Answers

  1. Best Answer

    It is possible to mark a member function to be called when it is applied to a temporary object (or right-value type object) by appending it &&to the end of the function signature, this is known as " reference qualifiers " or " reference to right-value for*this ", if you use these functions to your Objeto:

    std::vector<int> const& Coleccion() &
{
    if( coleccion.empty() )
        RellenarColeccion();

    return coleccion;
}

// Esta version de Coleccion sera llamada cuando el objeto sea un temporal
std::vector<int> Coleccion() &&
{
    if( coleccion.empty() )
        RellenarColeccion();

    return std::move(coleccion);
 // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ <-- movemos la coleccion fuera del temporal
}

    In the version that uses a right-value reference for *this, we use std::moveto transform the coleccioninternal of the temporary object into a right-value vector, which will be used to construct the std::vector<int>result that, being given a right-value, will move the content instead to copy it 1 . To see if this works as you need, I've made a few changes to your example class:

    class Objeto
{
    using type_t = chivato;
    ::vector<type_t> coleccion;

    Objeto() { std::cout << this << ' ' << __FUNCTION__ << '\n'; }

    friend Objeto NuevoObjeto(); // Otorgamos acceso a los miembros privados para la factoria

    void RellenarColeccion()
    { coleccion.emplace_back(); } // Anyadimos un objeto como prueba

public:
    ~Objeto() { std::cout << this << ' ' << __FUNCTION__ << '\n'; } // mostramos mensaje al destruir

    Objeto(Objeto const&) = delete;
    Objeto(Objeto &&) = default;

    std::vector<type_t> const& Coleccion() &
    {
        std::cout << "No temporal\n";
        if( coleccion.empty() )
            RellenarColeccion();

        return coleccion;
    }


    std::vector<type_t> Coleccion() &&
    {
        std::cout << "Temporal\n";
        if( coleccion.empty() )
            RellenarColeccion();

        return std::move(coleccion);
    }
};

    I have added some messages on the construction and destruction of Objetoand changed the type of the object contained in the collection to this:

    struct chivato
{
    chivato() { std::cout << this << ' ' << __FUNCTION__ << '\n'; }
    ~chivato() { std::cout << this << ' ' << __FUNCTION__ << '\n'; }
};

    With these changes, if we execute this code in main:

    std::cout << "Objeto en main\n";
Objeto o1 = NuevoObjeto();
std::cout << "Referencia a coleccion\n";
auto& v1 = o1.Coleccion();

std::cout << "\nObjeto temporal del que se obtiene coleccion\n";
auto v2 = NuevoObjeto().Coleccion();
std::cout << "Despues\n";

    We have this output 2 :

    Objeto en main
0x000000000001 Objeto
Referencia a coleccion
No temporal
0x0000001 chivato

Objeto temporal del que se obtiene coleccion
0x000000000002 Objeto
Temporal
0x0000002 chivato
0x000000000002 ~Objeto
Despues
0x0000002 ~chivato
0x000000000001 ~Objeto
0x0000001 ~chivato

    We see that the first Objeto( 0x000000000001) creates a collection with the element 0x0000001and that collection is read through the function Coleccionthat is not applied on temporary, we do not see that the element 0x0000001is destroyed.

    In the second part a Objetotemporary ( 0x000000000002) is created that contains the element 0x0000002and immediately afterwards the is destroyed Objetowithout the element ( 0x0000002) being destroyed, that means that the collection has been moved, we can also see that the version of Coleccionthat has been called calls about storms.

    After the message Después, the destructors of the temporarily created collection element are called Objetofrom the factory ( 0x0000002), then the destructor of the first Objeto( 0x000000000001) created is called, which calls the destructor of its only element ( 0x0000001).

    This behavior shows us that there has been no copy of the collection obtained from the temporary (if there had been a copy, an additional construction-destruction of collection elements would be seen).

    You can see the code working .En Wandbox 三へ( へ՞ਊ ՞)へ ﾊｯﾊｯ

    1 Warning, using std::movein an instruction returnprevents optimization of the return value .

    2 I have edited the memory addresses, for clarity and because in different runs they are different values.

    • 2

  2. Ok, what you have is the following:

      std::vector<int> const& Coleccion()
  {
    if( coleccion.empty() )
      RellenarColeccion();

     return coleccion;
  }

    As you can see, there you return a list, so a copy will be made when creating v2. What you can do is return a pointer to that collection, so you're just passing an address instead of a whole list.

    You could do this by returning a void *and then casting your std::vector:

    int *coleccion = (int*)coleccion; //siendo coleccion lo que te ha retornado Coleccion()
std::vector<int > v(coleccion, coleccion+ len); //len es el tamaño de tu std::vector original

    The modification I propose to your Collection() method would look like this:

      void * const& Coleccion()
  {
    if( coleccion.empty() )
      RellenarColeccion();

     return (void*)&coleccion[0];  //retornamos la dirección de la primera posición
  }

    So what you do is work with references and not copies of data. Hope this can help you.

    • 0