Operador de conversión de tipos explícito: ()

C++ permite la conversión de tipos explícita mediante una sintaxis similar a la de las llamadas de función.

Sintaxis

simple-type-name ( expression-list )

Comentarios

Un elemento simple-type-name seguido de una expression-list incluida entre paréntesis crea un objeto del tipo indicado mediante las expresiones especificadas. En el ejemplo siguiente se muestra una conversión de tipo explícita al tipo int:

int i = int( d );

En el ejemplo siguiente, se muestra una clase Point.

Ejemplo

// 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();
}

Output

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

Aunque el ejemplo anterior muestra la conversión de tipos explícita mediante constantes, se puede usar la misma técnica para realizar estas conversiones en objetos. En el siguiente fragmento de código se muestra este caso:

int i = 7;
float d;

d = float( i );

Las conversiones de tipos explícitas también se pueden especificar utilizando la sintaxis de conversión ("cast"). El ejemplo anterior, reescrito mediante la sintaxis de conversión, es:

d = (float)i;

Las conversiones de estilo "cast" o de función tienen los mismos resultados cuando se convierten valores simples. Sin embargo, en la sintaxis de estilo de función, puede especificar más de un argumento para la conversión. Esta diferencia es importante para los tipos definidos por el usuario. Considere una clase Point y sus conversiones:

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

En el ejemplo anterior, donde se usa la conversión de estilo de función, se muestra cómo convertir dos valores (uno para x y uno para y) al tipo Point definido por el usuario.

Precaución

Utilice las conversiones de tipos explícitas con cuidado, ya que invalidan la comprobación de tipos integrada del compilador de C++.

La notación de conversión cast se debe usar para las conversiones a tipos que no tienen un elemento simple-type-name (por ejemplo, tipos de puntero o referencia). La conversión a tipos que puedan expresarse con un elemento simple-type-name se puede escribir en cualquiera de las formas.

La definición de tipos en las conversiones "cast" no es válida.

Consulte también

Expresiones postfijas
Operadores integrados de C++, precedencia y asociatividad