Explicit type conversion

Konvertiert zwischen Typen unter Verwendung einer Kombination aus expliziten und impliziten Konvertierungen.

Syntax

Konvertiert explizit eine beliebige Anzahl von Werten zu einem Wert des Zieltyps.

Erklärung

Auflösung von Mehrdeutigkeiten

Mehrdeutige Deklarationsanweisung

Im Falle einer Mehrdeutigkeit zwischen einem Ausdrucksstatement mit einem Funktions-ähnlichen Cast-Ausdruck als seinem äußersten linken Teilausdruck und einer Deklarationsanweisung wird die Mehrdeutigkeit dadurch aufgelöst, dass sie als Deklaration behandelt wird. Diese Disambiguierung ist rein syntaktisch: Sie berücksichtigt nicht die Bedeutung der in der Anweisung vorkommenden Namen, außer ob es sich um Typnamen handelt:

struct M {};
struct L { L(M&); };
M n;
void f()
{
    M(m);    // Deklaration, äquivalent zu M m;
    L(n);    // fehlerhafte Deklaration, äquivalent zu L n;
    L(l)(m); // immer noch eine Deklaration, äquivalent zu L l((m));
}

struct M;
struct S
{
    S* operator()();
    int N;
    int M;
    void mem(S s)
    {
        auto(s)()->M; // expression (S::M hides ::M), invalid before C++23
    }
};
void f(S s)
{
    {
        auto(s)()->N; // expression, invalid before C++23
        auto(s)()->M; // function declaration, equivalent to M s();
    }
    {
        S(s)()->N;    // expression
        S(s)()->M;    // expression
    }
}

Mehrdeutiger Funktionsparameter

Die oben genannte Mehrdeutigkeit kann auch im Kontext einer Deklaration auftreten. In diesem Kontext besteht die Wahl zwischen einer Objektdeklaration mit einem Funktions-Stil-Cast als Initialisierer und einer Deklaration mit einem Funktionsdeklarator mit einem redundanten Satz von Klammern um einen Parameternamen. Die Auflösung besteht ebenfalls darin, jedes Konstrukt, wie die potenzielle Parameterdeklaration, das möglicherweise eine Deklaration sein könnte, als Deklaration zu betrachten:

struct S
{
    S(int);
};
void foo(double a)
{
    S w(int(a)); // Funktionsdeklaration: hat einen Parameter `a` vom Typ int
    S x(int());  // Funktionsdeklaration: hat einen unbenannten Parameter vom Typ int(*)() 
                 // der von int() angepasst wurde
    // Wege zur Vermeidung von Mehrdeutigkeit:
    S y((int(a))); // Objektdeklaration: zusätzliches Klammernpaar
    S y((int)a);   // Objektdeklaration: C-Stil Cast
    S z = int(a);  // Objektdeklaration: keine Mehrdeutigkeit bei dieser Syntax
}

typedef struct BB { int C[2]; } *B, C;
void foo()
{
    S a(B()->C);    // Objektdeklaration: B()->C kann keinen Parameter deklarieren
    S b(auto()->C); // Funktionsdeklaration: hat einen unbenannten Parameter vom Typ C(*)()
                    // der von C() angepasst wurde
}

Mehrdeutige Typ-ID

Eine Mehrdeutigkeit kann durch die Ähnlichkeit zwischen einem funktionsartigen Cast und einem Typ-Bezeichner entstehen. Die Auflösung besteht darin, dass jedes Konstrukt, das in seinem syntaktischen Kontext möglicherweise ein Typ-Bezeichner sein könnte, als Typ-Bezeichner betrachtet wird:

// `int()` und `int(unsigned(a))` können beide als Typ-ID geparst werden:
// `int()`            repräsentiert eine Funktion, die int zurückgibt
//                    und keine Argumente annimmt
// `int(unsigned(a))` repräsentiert eine Funktion, die int zurückgibt
//                    und ein Argument vom Typ unsigned annimmt
void foo(signed char a)
{
    sizeof(int());            // Typ-ID (fehlerhaft)
    sizeof(int(a));           // Ausdruck
    sizeof(int(unsigned(a))); // Typ-ID (fehlerhaft)
    (int()) + 1;            // Typ-ID (fehlerhaft)
    (int(a)) + 1;           // Ausdruck
    (int(unsigned(a))) + 1; // Typ-ID (fehlerhaft)
}

typedef struct BB { int C[2]; } *B, C;
void foo()
{
    sizeof(B()->C[1]);    // OK, sizeof(expression)
    sizeof(auto()->C[1]); // error: sizeof of a function returning an array
}

Hinweise

Beispiel

#include <cassert>
#include <iostream>
double f = 3.14;
unsigned int n1 = (unsigned int)f; // C-Style-Cast
unsigned int n2 = unsigned(f);     // Funktions-Style-Cast
class C1;
class C2;
C2* foo(C1* p)
{
    return (C2*)p; // castet unvollständigen Typ zu unvollständigem Typ
}
void cpp23_decay_copy_demo()
{
    auto inc_print = [](int& x, const int& y)
    {
        ++x;
        std::cout << "x:" << x << ", y:" << y << '\n';
    };
    int p{1};
    inc_print(p, p); // gibt x:2 y:2 aus, weil Parameter y hier ein Alias von p ist
    int q{1};
    inc_print(q, auto{q}); // gibt x:2 y:1 aus, auto{q} (C++23) castet zu Prvalue,
                           // daher ist Parameter y eine Kopie von q (kein Alias von q)
}
// In diesem Beispiel wird C-Style-Cast als static_cast interpretiert
// obwohl es als reinterpret_cast funktionieren würde
struct A {};
struct I1 : A {};
struct I2 : A {};
struct D : I1, I2 {};
int main()
{
    D* d = nullptr;
//  A* a = (A*)d;                   // Kompilierfehler
    A* a = reinterpret_cast<A*>(d); // dies kompiliert
    assert(a == nullptr);
    cpp23_decay_copy_demo();
}

x:2 y:2
x:2 y:1

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

Referenzen

Siehe auch