Operatore di conversione del tipo esplicito: ()

Il linguaggio C++ consente la conversione esplicita del tipo mediante una sintassi simile a quella della chiamata di funzione.

Sintassi

simple-type-name ( expression-list )

Osservazioni:

Un nome di tipo semplice seguito da un elenco di espressioni racchiuso tra parentesi costruisce un oggetto del tipo specificato usando le espressioni specificate. Nell'esempio seguente viene illustrata una conversione di tipo esplicita per il tipo int:

int i = int( d );

Nell'esempio seguente viene illustrata una Point classe .

Esempio

// 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

Sebbene l'esempio precedente dimostri la conversione del tipo esplicita mediante le costanti, la stessa tecnica può essere utilizzata per eseguire queste conversioni di oggetti. Nel frammento di codice che segue viene illustrata questa alternativa:

int i = 7;
float d;

d = float( i );

Le conversioni esplicite dei tipi possono essere specificate utilizzando la sintassi di "cast". L'esempio precedente, riscritto utilizzando la sintassi di cast, è:

d = (float)i;

Sia le conversioni eseguite con il cast che con la funzione danno gli stessi risultati quando si esegue la conversione di valori singoli. Tuttavia, nella sintassi stile-funzione è possibile specificare più argomenti per la conversione. Questa differenza è importante per i tipi definiti dall'utente. Si consideri una classe Point e le relative conversioni:

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

Nell'esempio precedente, che usa la conversione in stile funzione, viene illustrato come convertire due valori (uno per x e uno per y) nel tipo Pointdefinito dall'utente .

Attenzione

Si consiglia di utilizzare con cautela le conversioni esplicite del tipo, poiché queste eseguono l'override del controllo del tipo incorporato del compilatore C++.

La notazione cast deve essere usata per le conversioni in tipi che non dispongono di un nome di tipo semplice ,ad esempio un puntatore o un tipo riferimento. La conversione in tipi che possono essere espressi con un nome di tipo semplice può essere scritta in entrambi i formati.

La definizione del tipo all'interno dei cast non è consentita.

Vedi anche

Espressioni di suffissi
Operatori C++, precedenza e associazione