C++
Kopiuj Elision

Cel wydania kopii

W standardzie są miejsca, w których obiekt jest kopiowany lub przenoszony w celu zainicjowania obiektu. Eliminacja kopiowania (czasami nazywana optymalizacją wartości zwracanej) jest optymalizacją, w której, w pewnych szczególnych okolicznościach, kompilator może unikać kopiowania lub przenoszenia, nawet jeśli standard mówi, że musi się to zdarzyć.

Rozważ następującą funkcję:

std::string get_string()
{
  return std::string("I am a string.");
}

Zgodnie ze ścisłym brzmieniem standardu funkcja ta zainicjuje tymczasowy std::string , następnie skopiuje / przeniesie go do obiektu wartości zwracanej, a następnie zniszczy tymczasowy. Standard jest bardzo jasny, że tak interpretuje się kod.

Skasowanie kopii jest regułą, która pozwala kompilatorowi C ++ zignorować tworzenie tymczasowego i jego późniejszego kopiowania / niszczenia. Oznacza to, że kompilator może pobrać wyrażenie inicjujące tymczasowe i bezpośrednio zainicjować z niego wartość zwracaną przez funkcję. To oczywiście oszczędza wydajność.

Ma jednak dwa widoczne skutki dla użytkownika:

1. Typ musi mieć wywoływany konstruktor kopiowania / przenoszenia. Nawet jeśli kompilator pomija kopiowanie / przenoszenie, typ musi być nadal w stanie zostać skopiowany / przeniesiony.

2. Skutki uboczne konstruktorów kopiowania / przenoszenia nie są gwarantowane w okolicznościach, w których może nastąpić wybranie. Rozważ następujące:

struct my_type
{
  my_type() = default;
  my_type(const my_type &) {std::cout <<"Copying\n";}
  my_type(my_type &&) {std::cout <<"Moving\n";}
};

my_type func()
{
  return my_type();
}

Ponieważ elision jest optymalizacją, twój kompilator może nie obsługiwać elision we wszystkich przypadkach. I niezależnie od tego, czy kompilator wybierze konkretny przypadek, czy nie, typ musi nadal obsługiwać wybieraną operację. Jeśli więc wybrana jest konstrukcja kopii, typ musi nadal mieć konstruktor kopii, nawet jeśli nie zostanie wywołany.

Gwarantowana kopia kopii

std::mutex a_mutex;
std::lock_guard<std::mutex> get_lock()
{
  return std::lock_guard<std::mutex>(a_mutex);
}

std::lock_guard the_lock = get_lock();

std::mutex a_mutex;
std::lock_guard<std::mutex> get_lock()
{
  std::lock_guard<std::mutex> my_lock(a_mutex);
  //Do stuff
  return my_lock;
}

struct trivially_copyable {
    int a;  
};

void foo (trivially_copyable a) {}

foo(trivially_copyable{}); //copy elision not mandated

Wycofanie wartości zwracanej

Jeśli zwrócisz wyrażenie prvalue z funkcji, a wyrażenie prvalue ma ten sam typ, co typ zwracany przez funkcję, wówczas kopia z tymczasowego prvalue może zostać pominięta:

std::string func()
{
  return std::string("foo");
}

W tym przypadku prawie wszystkie kompilatory pominą tymczasową konstrukcję.

Wyznaczanie parametrów

Gdy przekazujesz argument do funkcji, a argument ten jest wyrażeniem wartości typu parametru typu funkcji, a ten typ nie jest odwołaniem, wówczas można pominąć konstrukcję wartości.

void func(std::string str) { ... }

func(std::string("foo"));

To mówi, aby utworzyć tymczasowy string , a następnie przenieść go do parametru parametru str . Skopiuj elision pozwala temu wyrażeniu na bezpośrednie utworzenie obiektu w str , zamiast używania tymczasowego + ruchu.

Jest to przydatna optymalizacja w przypadkach, w których konstruktor jest explicit . Na przykład moglibyśmy napisać powyższe jako func("foo") , ale tylko dlatego, że string ma niejawny konstruktor, który konwertuje z const char* na string . Gdyby ten konstruktor był explicit , bylibyśmy zmuszeni użyć tymczasowego do wywołania explicit konstruktora. Kopiowanie danych eliminuje nas z konieczności wykonywania niepotrzebnego kopiowania / przenoszenia.

Nazwane zwrócenie wartości zwracanej

Jeśli zwrócisz wyrażenie funkcji z funkcji, a ta wartość:

• reprezentuje automatyczną zmienną lokalną dla tej funkcji, która zostanie zniszczona po return
• zmienna automatyczna nie jest parametrem funkcji
• a typ zmiennej jest tego samego typu co typ zwracany przez funkcję

Jeśli tak jest w każdym przypadku, można pominąć kopiowanie / przeniesienie z wartości:

std::string func()
{
  std::string str("foo");
  //Do stuff
  return str;
}

Bardziej złożone przypadki kwalifikują się do elekcji, ale im bardziej złożony jest przypadek, tym mniej prawdopodobne jest, że kompilator faktycznie go obejmie:

std::string func()
{
  std::string ret("foo");
  if(some_condition)
  {
    return "bar";
  }
  return ret;
}

Kompilator nadal może wybierać ret , ale szanse na to są mniejsze.

Jak wspomniano wcześniej, elucja nie jest dozwolona dla parametrów wartości.

std::string func(std::string str)
{
  str.assign("foo");
  //Do stuff
  return str; //No elision possible
}

Skopiuj dane inicjalizacji

Jeśli użyjesz wyrażenia prvalue do kopiowania, zainicjujesz zmienną, a zmienna ma ten sam typ co wyrażenie prvalue, kopiowanie można uniknąć.

std::string str = std::string("foo");

Inicjalizacja kopii skutecznie przekształca to w std::string str("foo"); (istnieją niewielkie różnice).

Działa to również z wartościami zwracanymi:

std::string func()
{
  return std::string("foo");
}

std::string str = func();

Bez usuwania kopii wywołałoby to 2 wywołania konstruktora ruchów std::string . Kopiowanie elision pozwala temu wywołać konstruktor ruchu 1 lub zero razy, a większość kompilatorów wybierze ten drugi.