Le retour à une chaîne vide : efficace en c++

J'ai 2 façons de retourner une chaîne vide à partir d'une fonction.

std::string get_string()
{
   return "";
}

std::string get_string()
{
   return std::string();
}

lequel est le plus efficace et pourquoi?

Ni. Utilisation return {};.
Et comment est-ce lié à C?
Cela tombe dans le domaine de l'inutile micro-optimisation de votre compilateur d'optimiser loin à l'aide de RVO et copie élision.
pourriez-vous expliquer pourquoi?
Parce que c'est direct l'initialisation avec le constructeur par défaut, plutôt que de copier l'initialisation (à partir d'un éventuellement dynamiquement évaluée constructeur). Le constructeur par défaut peuvent être mises en œuvre sans l'allocation de constexpr si votre application est si incliné.
C'est (peut-être) plus efficace que le premier, car il tout simplement par défaut-les constructions de la chaîne plutôt que de lire la valeur d'une chaîne de caractères littérale; et plus efficace que le deuxième car elle nécessite moins de frappe.
pas différent, dans la pratique, que de retourner std::string. voir ma réponse
"le royaume de l'inutile micro-optimisation" peut-être que c'est la vraie question. Combien ça coûte de créer une chaîne de caractères à partir d'un char * et est-il important?

InformationsquelleAutor Abhishek Chandel | 2014-10-27

c++performance string

38

Gcc 7.1 -O3 ces sont toutes identiques, godbolt.org/z/a-hc1d – jterm 25 Avr à 3:27

Réponse originale à cette question:

Fait quelques recherches. Ci-dessous est un exemple de programme et les dispositions pertinentes de l'assemblée:

Code:
```
#include <string>

std::string get_string1(){ return ""; }

std::string get_string2(){ return std::string(); }

std::string get_string3(){ return {}; }           //thanks  Kerrek SB

int main()
{
    get_string1();
    get_string2();
    get_string3();
}
```
Assemblée:
```
__Z11get_string1v:
LFB737:
    .cfi_startproc
    pushl   %ebx
    .cfi_def_cfa_offset 8
    .cfi_offset 3, -8
    subl    $40, %esp
    .cfi_def_cfa_offset 48
    movl    48(%esp), %ebx
    leal    31(%esp), %eax
    movl    %eax, 8(%esp)
    movl    $LC0, 4(%esp)
    movl    %ebx, (%esp)
    call    __ZNSsC1EPKcRKSaIcE
    addl    $40, %esp
    .cfi_def_cfa_offset 8
    movl    %ebx, %eax
    popl    %ebx
    .cfi_restore 3
    .cfi_def_cfa_offset 4
    ret $4
    .cfi_endproc

__Z11get_string2v:
LFB738:
    .cfi_startproc
    movl    4(%esp), %eax
    movl    $__ZNSs4_Rep20_S_empty_rep_storageE+12, (%eax)
    ret $4
    .cfi_endproc

__Z11get_string3v:
LFB739:
    .cfi_startproc
    movl    4(%esp), %eax
    movl    $__ZNSs4_Rep20_S_empty_rep_storageE+12, (%eax)
    ret $4
    .cfi_endproc
```
Cela a été compilé avec -std=c++11 -O2.

Vous pouvez voir qu'il y a beaucoup plus de travail pour le return ""; déclaration et comparativement faible pour return std::string et return {}; (ces deux sont identiques).

Comme Frerich Raabe, a déclaré, lors du passage d'un vide C_string, il doit encore faire le traitement sur elle, au lieu d'allouer de la mémoire. Il semble que cela ne peut pas être optimisé à l'écart (au moins pas par GCC)

Donc la réponse est définitivement utilisation:
```
return std::string();
```
ou
```
return {};   //(c++11)
```
Bien que, à moins que vous êtes de retour beaucoup de chaînes vides dans les performances critiques de code (enregistrement, je suppose?), la différence va encore être négligeable.
- Peut-être que cela nécessite une mise à jour à compter de 2017 les trois possibilités de rendements les rendements de la même asm résultat donc il n'y a pas de questions sur le retour d'un "" ou un std::string{} ou {}. Testé sur compilateur explorer pour clang & gcc
- J'aurais dû noter la version de gcc à l'époque... Si vous voulez fournir clang et versions de gcc que vous avez testé, je vais le noter dans la réponse.
- en fait, quand j'essaie de gcc et clang ci-dessus, j'obtiens des résultats similaires (gcc 7.1/clang4.0.0). fait intéressant à noter, Visual studio (2015) donne des résultats qui sont cohérents entre chaque version, mais n'a plus de travail dans tous les cas.
- Il faut également noter que return {}; est une extension C++, donc return std::string(); doit être préféré.
- Gcc 7.1 -O3 ces sont toutes identiques, godbolt.org/z/a-hc1d
InformationsquelleAutor Baldrickk
2

La dernière version n'est jamais plus lente que la première. La première version des appels à la std::string constructeur prenant une chaîne C, puis calculer la longueur de la chaîne. Même si c'est rapide à faire pour une chaîne vide, ce n'est certainement pas plus rapide que ne pas le faire du tout.
- Comme c'est une constante qui doit être retourné, qui est le calcul de la longueur non optimisé par le compilateur? Si non, pourrait-il être?
- Il appelle le premier argument du constructeur de std::string. Je ne pense pas qu'il y a beaucoup (le cas échéant) des compilateurs qui sont assez intelligents pour en déduire que le premier argument du constructeur est l'équivalent du constructeur prenant à la fois un pointeur et une taille, à condition qu'il passe un de moins que la taille de la chaîne littérale (qui a une fuite '\0').
- certains compilateurs optimiser strlen() sur une chaîne littérale - j'ai demandé la fonctionnalité sera ajoutée à SparcWorks C++ plus d'une décennie, je ne sais pas si elles l'ont jamais fait cela - GCC déjà fait à l'époque. Encore - je n'aurais pas forcément s'attendre à une implémentation C++ pour utiliser strlen... ne sait jamais si.
- Confirmé ce que vous avez dit. Voir ma réponse.
InformationsquelleAutor Frerich Raabe

Vous devez vous connecter pour publier un commentaire.

Réponse originale à cette question: