C++
Elision kopieren

Zweck der Auslassung von Kopien

Es gibt Stellen im Standard, an denen ein Objekt kopiert oder verschoben wird, um ein Objekt zu initialisieren. Copy elision (manchmal auch als Rückgabewertoptimierung bezeichnet) ist eine Optimierung, bei der ein Compiler unter bestimmten Umständen das Kopieren oder Verschieben vermeiden darf, obwohl der Standard dies für erforderlich hält.

Betrachten Sie die folgende Funktion:

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

Gemäß dem strengen Wortlaut des Standards initialisiert diese Funktion einen temporären std::string , kopiert / verschiebt diesen in das Rückgabewertobjekt und zerstört dann das temporäre. Der Standard ist sehr klar, dass der Code auf diese Weise interpretiert wird.

Copy elision ist eine Regel, die es einem C ++ - Compiler erlaubt , die Erstellung des temporären Elements und die anschließende Kopie / Zerstörung zu ignorieren . Das heißt, der Compiler kann den Initialisierungsausdruck für das temporäre Element übernehmen und den Rückgabewert der Funktion direkt daraus initialisieren. Dies spart offensichtlich Leistung.

Es hat jedoch zwei sichtbare Auswirkungen auf den Benutzer:

1. Der Typ muss über den Copy / Move-Konstruktor verfügen, der aufgerufen worden wäre. Selbst wenn der Compiler das Kopieren / Verschieben aufhebt, muss der Typ kopiert / verschoben werden können.

2. Nebenwirkungen von Copy / Move-Konstruktoren können unter Umständen nicht garantiert werden, in denen eine Entscheidung getroffen werden kann. Folgendes berücksichtigen:

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

Da elision eine Optimierung ist, unterstützt Ihr Compiler möglicherweise nicht in allen Fällen elision. Unabhängig davon, ob der Compiler einen bestimmten Fall auswählt oder nicht, muss der Typ die ausgeführte Operation trotzdem unterstützen. Wenn also eine Kopierkonstruktion entfernt wird, muss der Typ noch einen Kopierkonstruktor haben, auch wenn er nicht aufgerufen wird.

Garantierte Kopiereinstellung

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

Rückgabewert elision

Wenn Sie einen prvalue-Ausdruck aus einer Funktion zurückgeben und der prvalue-Ausdruck denselben Typ wie der Rückgabetyp der Funktion hat, kann die Kopie aus dem temporären prvalue-Objekt entfernt werden:

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

So ziemlich alle Compiler werden in diesem Fall die temporäre Konstruktion übernehmen.

Parameterauswahl

Wenn Sie ein Argument an eine Funktion übergeben und das Argument ein prvalue-Ausdruck des Parametertyps der Funktion ist und dieser Typ keine Referenz ist, kann die Konstruktion des prvalue aufgehoben werden.

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

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

Dies bedeutet, dass Sie eine temporäre string erstellen und diese dann in den Funktionsparameter str . Copy elision erlaubt es diesem Ausdruck, das Objekt direkt in str zu erstellen, anstatt eine temporäre + Verschiebung zu verwenden.

Dies ist eine nützliche Optimierung für Fälle, in denen ein Konstruktor als explicit deklariert wird. Zum Beispiel hätten wir das Obige als func("foo") schreiben können, aber nur, weil string einen impliziten Konstruktor hat, der von const char* in einen string konvertiert. Wenn dieser Konstruktor explicit , müssen wir den explicit Konstruktor mit einem temporären Aufruf aufrufen. Copy elision erspart uns das unnötige Kopieren / Verschieben.

Benannte Rückgabewerte

Wenn Sie einen lvalue-Ausdruck von einer Funktion zurückgeben, und diesen lvalue:

• stellt eine automatische Variable lokal für diese Funktion dar, die nach der return
• Die automatische Variable ist kein Funktionsparameter
• und der Typ der Variablen ist derselbe Typ wie der Rückgabetyp der Funktion

Wenn dies alles der Fall ist, kann das Kopieren / Bewegen vom Wert abgelöst werden:

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

Für komplexere Fälle kann eine Entscheidung getroffen werden, aber je komplexer der Fall ist, desto unwahrscheinlicher wird es sein, dass der Compiler die Entscheidung trifft.

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

Der Compiler konnte noch elide ret , aber die Chancen, sie so tun , nach unten gehen.

Wie bereits erwähnt, ist für Werteparameter keine Entscheidung zulässig.

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

Kopieren Sie die Initialisierung

Wenn Sie zum Kopieren einer Variablen einen Prvalue-Ausdruck verwenden und diese Variable denselben Typ wie der Prvalue-Ausdruck hat, kann das Kopieren abgebrochen werden.

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

Die Initialisierung beim Kopieren wandelt dies effektiv in std::string str("foo"); (es gibt geringfügige Unterschiede).

Dies funktioniert auch mit Rückgabewerten:

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

std::string str = func();

Ohne Copy-Elision würde dies 2 Aufrufe des Move-Konstruktors von std::string hervorrufen. Die Kopierentscheidung erlaubt den Aufruf des Bewegungskonstruktors 1 oder null Mal, und die meisten Compiler entscheiden sich für Letzteres.