"Vous voulez de la vitesse ? Passer par valeur" est-il toujours vrai : quand le passage par référence surpasse-t-il le passage par valeur ?

"Vous voulez de la vitesse ? Passer par la valeur" et optimisation des performances

Lorsqu'ils traitent des opérations gourmandes en copies, les développeurs s'efforcent souvent d'optimiser les performances. Cette prémisse a conduit à l'axiome « ​​Vous voulez de la vitesse ? Passez par la valeur » inventé par Scott Meyers. Cependant, cette notion pose la question : le passage par valeur apporte-t-il toujours un avantage en performances par rapport au passage par référence ?

Considérant les classes X et Y suivantes :

<code class="cpp">struct X {
    std::string mem_name;

    X(std::string name) : mem_name(std::move(name)) {}
};

struct Y {
    std::string mem_name;

    Y(const std::string& name) : mem_name(name) {}
};</code>

Dans X, le constructeur prend une copie de l'argument et utilise le constructeur de déplacement pour initialiser sa variable membre mem_name. Dans Y, le constructeur prend une référence const et initialise mem_name directement à partir de l'argument.

Examinons maintenant un scénario dans lequel nous utilisons ces classes :

<code class="cpp">std::string foo() { return "a" + std::string("b"); }

int main() {
    X(foo());
    Y(foo());
}</code>

La fonction foo() renvoie un valeur temporaire utilisée pour initialiser name dans X et mem_name dans Y.

Dans le cas de X, le compilateur peut optimiser la construction de foo() et placer sa valeur de retour directement dans name. Ensuite, il déplace le nom vers mem_name. Ce processus aboutit à un seul déplacement, sans aucune copie.

En revanche, Y ne peut pas effectuer cette optimisation. Il lie la valeur de retour temporaire de foo() à son nom de référence, puis copie cette valeur dans mem_name. Par conséquent, Y effectue une copie.

En résumé, lors du passage d'une rvalue (objet temporaire), le passage par valeur dans X a le potentiel d'optimiser le processus en un seul mouvement, tandis que le passage par référence dans Y nécessite un copie. Cependant, il est important de noter que cette optimisation dépend des capacités du compilateur et que le profilage est toujours conseillé pour déterminer l'impact réel sur les performances.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!