En C++, quelles sont les différences entre static_cast<double>(a) et double(un)?

Quelles sont les différences entre

int a;
//a gets some value
double pi = static_cast<double>(a)/3;

et

int a;
//a gets some value
double pi = double(a)/3;

Avez-vous vu le dernier? Il me semble que je l'ai vu dans certains extrait écrit par Stroustrup, mais je ne trouve pas la référence.

Lorsque a est un int, static_cast<double>(a), (double)a, et double(a) sont tous sémantiquement identiques. Les différences deviennent évidentes quand a est un autre type scalaire, ou est const ou volatile, etc.
et à partir d'un point de vue des performances?
Des moyens identiques identiques, il n'y a pas de différence que ce soit.
en fait, de ne pas double(a) être un peu (mais insignifiant) plus lent lors de la compilation car elle va d'abord essayer de correspondre à une const_cast?
Trouver static_cast<double> dans ton code est beaucoup plus facile. Il se démarque le plus.

OriginalL'auteur Alessandro Jacopson | 2012-05-03

  1. 12

    Quelqu'un a peut-être pensé qu'ils ont été la construction plutôt que la coulée. Considérer:

    some_fun(std::string("Hello"));

    Beaucoup de gens pensent qu'il appelle un constructeur il y a quand en fait ils font un style C cast. Il se trouve que le casting va regarder les constructeurs du type de cible parmi la longue liste d'autres choses, il regarde et donc, ici, il finira appelant le constructeur.

    Fonctionnelle de la notation de jette ont tout de même des faiblesses de l'autre type de C cast:

    • Peut, par inadvertance, a jeté constness
    • Peuvent silencieusement à son tour dans une réinterpréter cast
    • Sont difficiles à différencier avec grepping outils.

    D'ailleurs, même si vous effectuez exactement la même opération dans les deux cas.

    OriginalL'auteur Crazy Eddie

  2. 7

    Ce dernier est désigné comme le fonctionnelle notation de une conversion explicite où vous l'avez explicitement dire a devrait être traitée comme une double. Vous pouvez très bien jeter ce à n'importe quel type en utilisant cette technique.

    L'ancien est la meilleure façon de jeter un type en C++. Il n'base de la vérification pour voir que le type coulée de sens (de la classe enfant pointeur vers une classe de base pointeur, etc.). En outre, comme dans l'exemple que vous montrez, vous pouvez effectuer des conversions implicites. Techniquement, le static_cast dans votre exemple est explicite, mais le résultat de l'opération (la mission) est implicite.

    OriginalL'auteur greg

  3. 4

    Il n'y a pas de différence en termes de code assembleur généré entre static_cast<double> (a) et (double) a. Le principal avantage de la fonte de la notation, (type_id) cast_expression, c'est que c'est plus flexible. Dans une situation, il pourrait être l'équivalent d'un const_cast, dans un autre, un static_cast, dans un autre encore, un dynamic_cast, dans un autre encore, une combinaison de const_cast et static_cast (ou dynamic_cast).

    Cette force est aussi une faiblesse. Cast notation signifie différentes choses à différents endroits. Un autre inconvénient est qu'il est très facile de trouver xxx_cast<type_id> (cast_expression). Il suffit de chercher pour _cast. Il est très difficile de trouver des expressions qui utilisent la fonte de la notation.

    OriginalL'auteur David Hammen

  4. 2

    à l'aide de static_cast est sûr C++-style moyen, mais (double) - dangereux vieux C-style.

    voir ici: La Conversion De Type

    OriginalL'auteur Alexander