C++Talk.NET

Vincent Lascaux · Guest

Bonjour,

Je suis à la recherche d'un document qui explique simplement (avec le moins
possible de langage machine) les optimisations réalisées par le compilateur.

Régulièrement, je veux faire une fonction qui retourne un type un peu
complexe (des vecteurs, des strings...). Je fais donc
std::vector<std::string> foo()
{
std::vector<std::string> data;
//remplit data
return data;
}

int main()
{
std::vector<std::string> result = foo();
}

Théoriquement, il doit y avoir une construction de std::vector<std::string>
dans foo, un constructeur par copie dans main, et l'appel au destructeur de
l'objet créé dans foo. C'est dommage (surtout si data contient beaucoup de
données). Une optimisation simple consiste à faire
void foo(std::vector<std::string>& data)
{
//remplit data
}
int main()
{
std::vector<std::string> result; foo(result);
}

ou encore (un peu moins bien, mais toujours mieux que l'original)

std::vector<std::string> foo()
{
std::vector<std::string> data;
//remplit data
return data;
}
int main()
{
std::vector<std::string> result; result.swap(foo());
}

Dans la premiere optimisation, on n'a plus qu'une seul construction de
std::vector<std::string>. Dans la seconde, on a pas de duplication des
données en mémoire.

Est ce que je peux compter sur le compilo pour faire une de ces deux
optimisations ?

Merci
--
Vincent

PS: est ce que fclc++ est le groupe le plus adapté pour parlé de ca ?

Jean-Marc Bourguet · Guest

"Vincent Lascaux" <nospam (AT) nospam (DOT) org> writes:

Matthieu Moy · Guest

Jean-Marc Bourguet <jm (AT) bourguet (DOT) org> writes:

Yannick Moy · Guest

Salut,

Les compilo implementent en fait la premiere solution
que tu proposes, cad qu'ils reservent l'espace memoire necessaire
dans la fonction appelante, en passsant un argument supplementaire
a la fonction appellee qui est un pointeur vers ton espace memoire.

Cette optimisation n'est en general possible que si tous les "return"
de la fonction appellee retournent la meme variable (d'ou le nom
"Named Return Value Optimization"), ou s'il n'y a qu'un seul point de retour
(auquel cas "return Obj();" sera aussi optimise).

A la difference de ta simulation en C++, il n'y a pas de construction
a proprement parler dans la fonction appelante.

Le mieux comme dit Mathieu, c'est de tester, en faisant imprimer quelque
chose par le copy-constructeur, qu'il est appelle ou pas.
Un remarque concernant une reponse precedente, la norme dit
qu'une implementation est libre de "sucrer" la creation de variables
temporaires, meme s'il y a des effets de bords attendus. C'est le cas
pour le retour de fonction ici, mais aussi pour le passage de parametres,
les throw/catch ...

Yannick