Jak uniknąć kopiowania podczas łączenia?

Tworzę klasę typu łańcuchowego, na przykład mały przykład poniżej. Wydaje się, że przy łączeniu funkcji składowych wywoływany jest konstruktor kopiowania. Czy istnieje sposób na pozbycie się wywołania konstruktora kopiowania? W moim poniższym przykładzie z zabawkami oczywiste jest, że mam do czynienia tylko z tymczasowymi, dlatego też „powinien” (może nie według standardów, ale logicznie) być elitarny. Drugim najlepszym wyborem, aby skopiować elision, byłoby wywołanie konstruktora ruchu, ale tak nie jest.

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;
}

Edycja: Kilka wyjaśnień. 1. Nie zależy to od poziomu optymalizacji. 2. W moim prawdziwym kodzie mam bardziej złożone obiekty (np. Przydzielone sterty) niż ints

1. Częściowa odpowiedź (nie konstruuje się b2na miejscu, ale przekształca konstrukcję kopiowania w konstrukcję przenoszenia): Możesz przeciążyć funkcję incrementelementu członkowskiego w kategorii wartości powiązanej instancji:

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

   To powoduje

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

   przenieść-skonstruować, b2ponieważ test_class{7}jest to tymczasowe i wywoływane jest &&przeciążenie test_class::increment.

2. Aby uzyskać prawdziwą konstrukcję na miejscu (tj. Nawet konstrukcję bez ruchu), możesz zamienić wszystkie specjalne i niespecjalne funkcje constexprskładowe na wersje. Następnie możesz to zrobić

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

   a ty nie jesteś ani ruchem, ani kopią konstrukcji, za którą trzeba zapłacić. Jest to oczywiście możliwe w przypadku prostego test_class, ale nie bardziej ogólnego scenariusza, który nie dopuszcza constexprfunkcji składowych.

Zasadniczo przypisanie odwołania do wartości wymaga wywołania konstruktora, tj. Kopii lub przeniesienia . Różni się to od wymazywania kopii, gdy wiadomo, że po obu stronach funkcji jest ten sam odrębny obiekt. Również odniesienia może odnosić się do obiektu udostępnionego podobnie jak wskaźnik.

Najprostszym sposobem jest prawdopodobnie optymalizacja konstruktora kopiowania. Ustawienie wartości jest już zoptymalizowane przez kompilator, tylko std::couttego nie można zoptymalizować.

test_class(const test_class& t) = default;

(lub po prostu usuń konstruktor kopiowania i przenoszenia)

przykład na żywo

Ponieważ problem dotyczy w zasadzie referencji, rozwiązaniem prawdopodobnie nie jest zwracanie referencji do obiektu, jeśli chcesz przerwać kopiowanie w ten sposób.

  void increment();
};

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

Trzecia metoda polega przede wszystkim na wymuszeniu kopiowania - wymaga to jednak przepisania lub enkapsulacji operacji w jedną funkcję, a tym samym całkowitego uniknięcia problemu (jestem świadomy, że to może nie być to, czego chcesz, ale może być rozwiązanie dla innych użytkowników):

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

Czwarta metoda wykorzystuje zamiast tego ruch, albo jawnie wywołany

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

lub jak widać w tej odpowiedzi .