Jawny operator konwersji typów: ()

Język C++ pozwala na jawną konwersję typu przy użyciu składni podobnej do składni wywołania funkcji.

Składnia

simple-type-name ( expression-list )

Uwagi

Prosta nazwa typu, po której znajduje się lista wyrażeń ujęta w nawiasy, tworzy obiekt określonego typu przy użyciu określonych wyrażeń. W poniższym przykładzie pokazano jawną konwersję typu na typ int.

int i = int( d );

W poniższym przykładzie przedstawiono klasę Point .

Przykład

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

Wyjście

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

Mimo że w poprzednim przykładzie zademonstrowano jawną konwersję typu przy użyciu stałych, ta sama technika działa przy wykonywaniu konwersji na obiektach. Potwierdza to następujący fragment kodu:

int i = 7;
float d;

d = float( i );

Jawne konwersje typu mogą być również określone przy użyciu składni „rzutowania”. Poprzedni przykład przepisany przy użyciu składni rzutowania:

d = (float)i;

Zarówno rzutowanie, jak i konwersje w stylu funkcji, dają te same wyniki podczas konwertowania z pojedynczych wartości. Jednakże, w składni stylu funkcji można określić więcej niż jeden argument do konwersji. Różnica jest ważna dla typów zdefiniowanych przez użytkownika. Rozważ klasę Point i jej konwersje:

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

W poprzednim przykładzie, który używa konwersji stylu funkcji, pokazano, jak przekonwertować dwie wartości (jeden dla x i jeden dla y) na typ Pointzdefiniowany przez użytkownika .

Uwaga

Użyj jawnej konwersji typu z rozwagą, gdyż zastępuje ona kontrolę typów wbudowaną w kompilator C++.

Notacja rzutowania musi być używana do konwersji na typy, które nie mają prostej nazwy typu (na przykład wskaźnika lub typów odwołań). Konwersja na typy, które można wyrazić przy użyciu prostej nazwy typu, może być zapisywana w obu formach.

W ramach rzutowań niedozwolone są definicje typu.

Zobacz też

Wyrażenia przyrostków
Wbudowane operatory, pierwszeństwo i kojarzenie języka C++