Opérateur de conversion de type explicite : ()

Article
03/04/2013

C++ permet la conversion de type explicite à l'aide de la syntaxe similaire à la syntaxe de fonction-appel.

simple-type-name ( expression-list )

Notes

Un simple-type-nom suivi d'une expression-liste entre crochets construit un objet du type spécifié à l'aide de les expressions spécifiées.L'exemple suivant montre une conversion de type explicite tapait int :

int i = int( d );

l'exemple suivant utilise une version modifiée de la classe d' Point définie dans résultats de Fonction-Appel.

Exemple

// expre_Explicit_Type_Conversion_Operator.cpp
// compile with: /EHsc
#include <iostream>

using namespace std;
class Point
{
public:
    // Define default constructor.
    Point() { _x = _y = 0; }
    // Define another constructor.
    Point( int X, int Y ) { _x = X; _y = Y; }

    // Define "accessor" functions as
    // reference types.
    unsigned& x() { return _x; }
    unsigned& y() { return _y; }
    void Show()   { cout << "x = " << _x << ", "
                         << "y = " << _y << "\n"; }
private:
    unsigned _x;
    unsigned _y;
};

int main()
{
    Point Point1, Point2;

    // Assign Point1 the explicit conversion
    //  of ( 10, 10 ).
    Point1 = Point( 10, 10 );

    // Use x() as an l-value by assigning an explicit
    //  conversion of 20 to type unsigned.
    Point1.x() = unsigned( 20 );
    Point1.Show();

    // Assign Point2 the default Point object.
    Point2 = Point();
    Point2.Show();
}

Sortie

x = 20, y = 10
x = 0, y = 0

Bien que l'exemple précédent affiche la conversion de type explicite à l'aide de les constantes, la même technique fonctionne pour exécuter ces conversions sur les objets.Le fragment de code suivant illustre ce comportement :

int i = 7;
float d;

d = float( i );

Les conversions de type explicite peuvent également être spécifiées en utilisant la syntaxe de « cast ».L'exemple précédent, réécrit à l'aide de la syntaxe de cast, est :

d = (float)i;

Le cast et les conversions de style fonction ont les mêmes résultats en convertissant les valeurs uniques.Toutefois, dans la syntaxe de style fonction, vous pouvez spécifier plusieurs arguments pour la conversion.cette différence est importante pour les types définis par l'utilisateur.Prenons l'exemple d'une classe d' Point et ses conversions :

struct Point
{
    Point( short x, short y ) { _x = x; _y = y; }
    ...
    short _x, _y;
};
...
Point pt = Point( 3, 10 );

L'exemple précédent, qui utilise la conversion de style fonction, montre comment convertir deux valeurs (une de x et une pour *y)*au type défini par l'utilisateur Point.

Attention
Utilisez les conversions de type explicite avec prudence, car ils substituent la vérification du type intégré du compilateur C++.

La notation de cast doit être utilisée pour les conversions aux types qui n'ont pas de simple-type-nom (pointeur ou types référence, par exemple).La conversion des types qui peuvent être exprimés avec un simple-type-nom peut être écrite dans l'un ou l'autre de formulaire.Consultez Spécificateur de type pour plus d'informations sur ce qui constitue un simple-type-nom.

La définition de type dans les casts non conforme.

Voir aussi

Référence

Expressions suffixées

Opérateurs C++

Priorité des opérateurs et d'associativité

Partager via