C++
Kopieer Elision

Doel van kopie elision

Er zijn plaatsen in de standaard waar een object wordt gekopieerd of verplaatst om een object te initialiseren. Copy elision (soms retourwaarde-optimalisatie genoemd) is een optimalisatie waarbij, onder bepaalde specifieke omstandigheden, een compiler is toegestaan de kopie te vermijden of te verplaatsen, hoewel de standaard zegt dat dit moet gebeuren.

Overweeg de volgende functie:

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

Volgens de strikte formulering van de standaard zal deze functie een tijdelijke std::string initialiseren, deze vervolgens kopiëren / verplaatsen naar het retourwaardeobject en vervolgens de tijdelijke vernietigen. De standaard is heel duidelijk dat dit is hoe de code wordt geïnterpreteerd.

Copy elision is een regel waarmee een C ++ compiler het maken van de tijdelijke en de daaropvolgende kopie / vernietiging kan negeren . Dat wil zeggen dat de compiler de initialisatie-expressie voor de tijdelijke kan nemen en de retourwaarde van de functie hieruit direct kan initialiseren. Dit bespaart duidelijk prestaties.

Het heeft echter twee zichtbare effecten op de gebruiker:

1. Het type moet de copy / move-constructor hebben die zou zijn aangeroepen. Zelfs als de compiler het kopiëren / verplaatsen opheft, moet het type nog steeds kunnen worden gekopieerd / verplaatst.

2. Bijwerkingen van kopieer- / verplaatsingsconstructors zijn niet gegarandeerd in omstandigheden waarin elision kan plaatsvinden. Stel je de volgende situatie voor:

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

Omdat elision een optimalisatie is, ondersteunt uw compiler mogelijk niet in alle gevallen elision. En ongeacht of de compiler een bepaald geval verwijdert of niet, het type moet nog steeds de bewerking ondersteunen die wordt geëlimineerd. Dus als een kopieconstructie wordt weggelaten, moet het type nog steeds een kopieconstructie hebben, hoewel deze niet wordt aangeroepen.

Gegarandeerde kopie-eliminatie

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

Retourwaarde elision

Als u een prvalue-expressie retourneert vanuit een functie en de prvalue-expressie van hetzelfde type is als het retourtype van de functie, kan de kopie uit de tijdelijke prvalue worden verwijderd:

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

Vrijwel alle compilers zullen in dit geval de tijdelijke constructie uit de weg gaan.

Parameter elision

Wanneer u een argument doorgeeft aan een functie en het argument een prvalue-expressie is van het parametertype van de functie, en dit type geen verwijzing is, kan de constructie van de prvalue worden weggelaten.

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

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

Dit zegt dat u een tijdelijke string moet maken en deze vervolgens naar de functieparameter str moet verplaatsen. Met Copy elision kan deze expressie het object rechtstreeks in str , in plaats van een tijdelijke + verplaatsing te gebruiken.

Dit is een nuttige optimalisatie voor gevallen waarin een constructor explicit wordt verklaard. We hadden het bovenstaande bijvoorbeeld kunnen schrijven als func("foo") , maar alleen omdat string een impliciete constructor heeft die converteert van een const char* naar een string . Als die constructor explicit , zouden we genoodzaakt zijn een tijdelijk te gebruiken om de explicit constructor aan te roepen. Copy elision voorkomt dat we onnodig moeten kopiëren / verplaatsen.

Genoemde retourwaarde-elision

Als u een lvalue-uitdrukking van een functie retourneert en deze waarde:

• staat voor een automatische variabele lokaal voor die functie, die na de return wordt vernietigd
• de automatische variabele is geen functieparameter
• en het type van de variabele is hetzelfde type als het retourtype van de functie

Als dit allemaal het geval is, kan de kopie / verplaatsing van de waarde worden verwijderd:

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

Complexere cases komen in aanmerking voor verkiezing, maar hoe complexer de case, hoe minder waarschijnlijk de compiler zal zijn om deze daadwerkelijk te elimineren:

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

De compiler kan nog steeds uitwijken voor ret , maar de kans dat ze dat doen, neemt af.

Zoals eerder opgemerkt, is elisie niet toegestaan waardeparameters.

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

Initialisatie-kopie kopiëren

Als u een prvalue-expressie gebruikt om te kopiëren, initialiseert u een variabele en die variabele heeft hetzelfde type als de prvalue-expressie, dan kan het kopiëren worden verwijderd.

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

Initialisatie kopiëren kopieert dit effectief naar std::string str("foo"); (er zijn kleine verschillen).

Dit werkt ook met retourwaarden:

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

std::string str = func();

Zonder copy elision zou dit 2 aanroepen van std::string 's constructor veroorzaken. Copy elision staat dit toe om de constructor 1 of nul keer aan te roepen, en de meeste compilers zullen voor het laatste kiezen.