C++
Копирование Elision

Цель копирования

В стандарте есть места, где объект копируется или перемещается для инициализации объекта. Копирование elision (иногда называемое оптимизацией возвращаемого значения) - это оптимизация, при которой при определенных обстоятельствах компилятору разрешается избегать копирования или перемещения, даже если стандарт говорит, что это должно произойти.

Рассмотрим следующую функцию:

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

Согласно строгой формулировке стандарта, эта функция инициализирует временную std::string , затем скопирует / переместит ее в объект возвращаемого значения, а затем уничтожит временную. В стандарте очень ясно, что так интерпретируется код.

Копирование elision - это правило, которое позволяет компилятору C ++ игнорировать создание временного и последующего копирования / уничтожения. То есть, компилятор может взять инициализирующее выражение для временного и инициализировать возвращаемое значение функции из него напрямую. Это, очевидно, экономит производительность.

Однако он имеет два видимых эффекта для пользователя:

1. Тип должен иметь конструктор copy / move, который был бы вызван. Даже если компилятор возвращает копию / перемещение, тип все равно должен быть скопирован / перемещен.

2. Побочные эффекты конструкторов копирования / перемещения не гарантируются в обстоятельствах, когда может возникнуть конфликт. Рассмотрим следующее:

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

Поскольку elision - это оптимизация, ваш компилятор может не поддерживать elision во всех случаях. И независимо от того, будет ли компилятор выдавать конкретный случай или нет, тип все равно должен поддерживать отмененную операцию. Поэтому, если построена копия, тип все равно должен иметь конструктор копирования, даже если он не будет вызываться.

Гарантированное копирование

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

Возвращаемое значение elision

Если вы возвращаете выражение prvalue из функции, а выражение prvalue имеет тот же тип, что и возвращаемый тип функции, тогда копия из временного значения prvalue может быть удалена:

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

Практически все компиляторы в этом случае будут исключать временную конструкцию.

Параметр elision

Когда вы передаете аргумент функции, а аргумент является выражением prvalue типа параметра функции, и этот тип не является ссылкой, то конструкцию prvalue можно удалить.

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

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

Это говорит о создании временной string , а затем переместить ее в параметр функции str . Копирование elision позволяет этому выражению напрямую создавать объект в str , а не использовать временный + перемещение.

Это полезная оптимизация для случаев, когда конструктор объявляется explicit . Например, мы могли бы написать выше как func("foo") , но только потому, что string имеет неявный конструктор, который преобразует из const char* в string . Если этот конструктор был explicit , мы были бы вынуждены использовать временный вызов explicit конструктора. Копирование elision избавляет нас от необходимости делать ненужную копию / перемещение.

Именованное возвращаемое значение elision

Если вы возвращаете выражение lvalue из функции, и это lvalue:

• представляет собой автоматическую переменную, локальную для этой функции, которая будет уничтожена после return
• автоматическая переменная не является параметром функции
• и тип переменной такой же, как тип возвращаемого значения функции

Если все это так, то копирование / перемещение из lvalue можно отбросить:

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

Более сложные случаи имеют право на элицию, но чем более сложный случай, тем меньше вероятность того, что компилятор действительно сможет его ликвидировать:

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

Компилятор все еще может игнорировать ret , но шансы на их делают так идти вниз.

Как отмечалось ранее, для значений параметров не разрешено исключение.

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

Копирование инициализации

Если вы используете выражение prvalue для копирования инициализации переменной, и эта переменная имеет тот же тип, что и выражение prvalue, тогда копирование может быть отменено.

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

Инициализация кода эффективно преобразует это в std::string str("foo"); (есть незначительные различия).

Это также работает с возвращаемыми значениями:

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

std::string str = func();

Без копирования elision это вызовет 2 обращения к конструктору перемещения std::string . Копирование elision позволяет это вызвать конструктор перемещения 1 или нулевое время, и большинство компиляторов выберет последнее.