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

Messages postés
6
Date d'inscription
samedi 7 novembre 2015
Statut
Membre
Dernière intervention
22 décembre 2019
- - Dernière réponse :  XgadaX - 27 déc. 2019 à 17:57
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.
Afficher la suite 
A voir également:

4 réponses

Messages postés
430
Date d'inscription
dimanche 7 février 2016
Statut
Membre
Dernière intervention
8 janvier 2020
2
0
Merci
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.
Commenter la réponse de Dalfab
0
Merci
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 ?
Commenter la réponse de XgadaX
Messages postés
430
Date d'inscription
dimanche 7 février 2016
Statut
Membre
Dernière intervention
8 janvier 2020
2
0
Merci
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
.
Commenter la réponse de Dalfab
0
Merci
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 ).
Commenter la réponse de XgadaX