Int(xxx) est il moins efficient que int{xxx}

Signaler
Messages postés
10
Date d'inscription
samedi 7 novembre 2015
Statut
Membre
Dernière intervention
20 avril 2020
-
 XgadaX -
Bonjour à vous,

Allons droit au but, std::string(xxx) est désignée comme une fonction surchargée mais int(xxx), qui est équivalent depuis c++11 à (int)xxx est désignée comme style d'écriture fonction ( " function-style cast " ). D'après mon expérience int(xxx) et int{xxx} sont tout aussi efficace l'un que l'autre.
Ma question est la suivante : int(xxx) est-il moins efficient que int{xxx} __du fait d'un appel de fonction peut-être ?__ .

Merci par avance de vos réponse.

4 réponses

Messages postés
472
Date d'inscription
dimanche 7 février 2016
Statut
Membre
Dernière intervention
26 octobre 2020
3
Bonjour,

Ne pas oublier que le compilateur optimise avant de créer le code final, donc même si un appel de fonction était nécessaire il serait de toute manière simplifié dans les cas simples.
Quoi qu'il en soit, ici les lignes suivantes reviennent au même :
int(xxx)
int{xxx}
static_cast<int>(xxx)
Si xxx est un entier ou un
enum
ou une constante, il n'y aura aucun appel de fonction. Si xxx est flottant non constant, il y aura appel d'un traitement de conversion. Si xxx est un type convertible en
int
, il y aura l'appel de la fonction de conversion.
Merci de votre réponse,
en effet j'ai bien conscience que le compilateur optimise la littérature donc si j'ai bien compris, int(xxx) remplit simplement un rôle plus large du point de vue du développement ?
Messages postés
472
Date d'inscription
dimanche 7 février 2016
Statut
Membre
Dernière intervention
26 octobre 2020
3
Je ne comprends bien ce que tu entends par "rôle plus large".
Ce qui distingue ces opérations ce sont des contrôles différents à la compilation, ainsi :
const double xxx = 3.14;
int{xxx};              // ne compile pas car détecte un 'narrowing conversion'
int(xxx);              // fonction const : compile
(int)xxx;              // cast façon C : compile
static_cast<int>(xxx); // cast C++ : compile
int x = xxx;           // conversion implicite, produit un warning

Mais tous reviennent à convertir un
double
en
int
.

Si
xxx
est un objet convertible en
int
les 5 conversions fonctionnent (sauf la dernière si la conversion est
explicit
.)
Si
xxx
est un objet convertible en
short
, aucune ne fonctionne car nécessite une double conversion :
xxx==>short
et
short==>int
.
Merci encore pour vos réponses des plus complètes,
Ce que j'entendais par rôle plus large c'est que int foo(xxx) semblait pouvoir être utilisé dans d'avantage de cas comme celui de la conversion, tandis que int foo{xxx} servirait uniquement à l'initialisation ( à l'origine tout du moins ).