Come eludere la copia durante il concatenamento?

Sto creando una classe di tipo concatenamento, come il piccolo esempio di seguito. Sembra che quando si concatenano funzioni membro, viene invocato il costruttore di copie. C'è un modo per sbarazzarsi della chiamata del costruttore della copia? Nel mio esempio di giocattolo qui sotto, è ovvio che ho a che fare solo con i provvisori e quindi "dovrebbe" (forse non secondo gli standard, ma logicamente) essere un'elezione. La seconda scelta migliore, per copiare l'elisione, sarebbe quella di chiamare il costruttore di mosse, ma non è così.

class test_class {
    private:
    int i = 5;
    public:
    test_class(int i) : i(i) {}
    test_class(const test_class& t) {
        i = t.i;
        std::cout << "Copy constructor"<< std::endl;
    }
    test_class(test_class&& t) {
        i = t.i;
        std::cout << "Move constructor"<< std::endl;
    }
    auto& increment(){
        i++;
        return *this;
    }
};
int main()
{
    //test_class a{7};
    //does not call copy constructor
    auto b = test_class{7};
    //calls copy constructor
    auto b2 = test_class{7}.increment();
    return 0;
}

Modifica: alcuni chiarimenti. 1. Questo non dipende dal livello di ottimizzazione. 2. Nel mio codice reale, ho oggetti più complessi (ad es. Allocazione di heap) rispetto agli ints

1. Risposta parziale (non costruisce b2sul posto, ma trasforma la costruzione della copia in una costruzione di spostamento): puoi sovraccaricare la incrementfunzione membro sulla categoria di valore dell'istanza associata:

   auto& increment() & {
       i++;
       return *this;
   }
   
   auto&& increment() && {
       i++;
      return std::move(*this);
   }

   Questo causa

   auto b2 = test_class{7}.increment();

   spostare-costruzione b2perché test_class{7}è temporaneo e viene chiamato il &&sovraccarico di test_class::increment.

2. Per una vera costruzione sul posto (cioè nemmeno una costruzione di movimento), puoi trasformare tutte le funzioni speciali e non speciali in constexprversioni. Quindi puoi farlo

   constexpr auto b2 = test_class{7}.increment();

   e non devi pagare né una mossa né una costruzione di copie. Questo è, ovviamente, possibile per il semplice test_class, ma non per uno scenario più generale che non consente le constexprfunzioni membro.

Fondamentalmente, l'assegnazione di un riferimento a un valore richiede l'invocazione di un costruttore, ovvero una copia o uno spostamento . Ciò è diverso dall'eliminazione della copia in cui è noto che su entrambi i lati della funzione è lo stesso oggetto distinto. Anche un riferimento può fare riferimento a un oggetto condiviso in modo molto simile a un puntatore.

Il modo più semplice è probabilmente quello di rendere il costruttore di copie completamente ottimizzato. L'impostazione del valore è già ottimizzata dal compilatore, è solo quella std::coutche non può essere ottimizzata.

test_class(const test_class& t) = default;

(o rimuovi sia la copia che il costruttore di spostamento)

esempio dal vivo

Poiché il problema riguarda sostanzialmente il riferimento, probabilmente una soluzione non sta restituendo un riferimento all'oggetto se si desidera interrompere la copia in questo modo.

  void increment();
};

auto b = test_class{7};//does not call copy constructor
b.increment();//does not call copy constructor

Un terzo metodo si basa solo sull'eliminazione della copia in primo luogo, tuttavia ciò richiede una riscrittura o incapsulamento dell'operazione in una funzione e quindi evitare del tutto il problema (sono consapevole che questo potrebbe non essere quello che vuoi, ma potrebbe essere un soluzione per altri utenti):

auto b2 = []{test_class tmp{7}; tmp.increment().increment().increment(); return tmp;}(); //<-- b2 becomes 10 - copy constructor not called

Un quarto metodo utilizza invece una mossa, invocata in modo esplicito

auto b2 = std::move(test_class{7}.increment());

o come visto in questa risposta .