KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / C++

Copy-elision, NRVO en impliciet verplaatsen

Onderscheid de gegarandeerde constructie vanuit een prvalue, optionele NRVO en impliciet verplaatsen in C++23. Teruggeven op waarde betekent niet noodzakelijk kopiëren, maar de correctheid van een programma mag niet afhangen van het uitvoeren van NRVO.

Versie: C++23; repository compiler flag, production runtime not attested

Syntax

T direct() { return T{}; }
T named() { T local; return local; }
T forward_value(T value) { return value; }

Copy-elision staat toe om in bepaalde omstandigheden een kopieer- of verplaatsingsconstructie over te slaan, zelfs als hierdoor waarneembare effecten van constructors en destructors veranderen. Baseer de programmalogica niet op het aantal van deze aanroepen.

Gegarandeerde copy-elision is de gebruikelijke naam voor de prvalue-regels die sinds C++17 gelden. In T direct() { return T{}; } wordt het resultaat rechtstreeks in het doelobject van hetzelfde type geconstrueerd; cv-kwalificaties worden bij de typevergelijking genegeerd. Dit is geen optionele NRVO: een kopieer- of verplaatsingsconstructor is niet nodig, maar de destructor moet toegankelijk en niet verwijderd zijn.

NRVO (named return value optimization) kan worden toegepast op return local; wanneer local een niet-volatile automatisch object van het juiste type is, en geen functieparameter of variabele van een exception handler. NRVO blijft optioneel in C++23; de eisen voor de geselecteerde constructor blijven gelden. return std::move(local); voldoet niet aan de NRVO-eis dat de expressie het object benoemt.

Impliciet verplaatsen slaat de constructie niet over. In C++23 wordt een verplaatsingsgeschikte expressie behandeld als een xvalue; dit omvat gebruikelijke returns van lokale objecten of parameters die op waarde zijn doorgegeven. Overloadresolutie kan een verplaatsingsconstructor of een beschikbare kopie die const T& accepteert selecteren; een verwijderde geselecteerde verplaatsingsconstructor leidt tot een fout, niet tot een nieuwe poging met kopiëren. forward_value laat een parameter zien: NRVO geldt er niet voor, impliciet verplaatsen wel. Dit artikel beschrijft C++23; de genoemde pagina’s zijn een zich ontwikkelend concept en geen vastgelegde C++23-editie.

Referentie-identificatoren die in dit item worden behandeld: Copy elision, NRVO and implicit move.

Voorbeelden

#include <iostream>

struct T {
    int value;
    explicit T(int n = 0) : value(n) {}
    T(const T&) = delete;
    T(T&&) = default;
};

T direct() {
    return T{10};
}

T named() {
    T local{20};
    return local;
}

T forward_value(T value) {
    return value;
}

int main() {
    T a = direct();
    T b = named();
    T c = forward_value(T{30});
    std::cout << a.value << ' ' << b.value << ' ' << c.value << '\n';
}

Resultaat

10 20 30

De getoonde code en het opgegeven resultaat zijn in een geïsoleerde omgeving geverifieerd met de methode die in het verificatiebewijs voor exact deze versie is vastgelegd.

Bronnen