static_cast conversion

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

Syntax

Gibt einen Wert vom Typ target-type zurück.

Erklärung

Nur die folgenden Konvertierungen können mit static_cast durchgeführt werden, außer wenn solche Konvertierungen Constness entfernen würden (oder Volatilität).

struct B {};
struct D : B { B b; };
D d;
B& br1 = d;
B& br2 = d.b;
static_cast<D&>(br1); // OK, L-Wert bezeichnet das ursprüngliche "d"-Objekt
static_cast<D&>(br2); // UB: Das "b"-Subobjekt ist kein Basisklassen-Subobjekt

Wie bei allen Umwandlungsausdrücken ist das Ergebnis:

• ein lvalue, wenn target-type ein lvalue reference type ist oder ein rvalue reference to function type (seit C++11) ;

• ein prvalue andernfalls.

1. ↑ Diese Art von static_cast wird verwendet, um Move-Semantik in std::move zu implementieren.
2. ↑ Falls IEEE-Arithmetik unterstützt wird, ist das Standardrundungsverfahren "Round to Nearest".

Zeiger-interkonvertierbare Objekte

Zwei Objekte a und b sind zeigerinterkonvertierbar wenn:

• sie dasselbe Objekt sind, oder
• eines ein Union-Objekt und das andere ein nicht-statisches Datenelement dieses Objekts ist, oder
• eines ein Standard-Layout Klassenobjekt und das andere das erste nicht-statische Datenelement dieses Objekts oder irgendein Basisklassen-Subobjekt dieses Objekts ist, oder
• ein Objekt c existiert, sodass a und c zeigerinterkonvertierbar sind, und c und b zeigerinterkonvertierbar sind.

union U { int a; double b; } u;
void* x = &u;                        // Der Wert von x ist „Zeiger auf u“
double* y = static_cast<double*>(x); // Der Wert von y ist „Zeiger auf u.b“
char* z = static_cast<char*>(x);     // Der Wert von z ist „Zeiger auf u“

Hinweise

Basis-zu-abgeleitet-Konvertierungen ( Downcasts ) mit static_cast führen keine Laufzeitprüfungen durch, um sicherzustellen, dass der dynamische Typ des gezeigten/referenzierten Objekts Derived ist, und können nur sicher verwendet werden, wenn diese Voraussetzung durch andere Mittel gewährleistet ist, wie beispielsweise bei der Implementierung von statischem Polymorphismus . Sichere Downcasts können mit dynamic_cast durchgeführt werden.

static_cast kann auch verwendet werden, um Funktionsüberladungen zu disambiguieren, indem eine Funktion-zu-Zeiger-Konvertierung zu einem spezifischen Typ durchgeführt wird, wie in

std::for_each(files.begin(), files.end(),
              static_cast<std::ostream&(*)(std::ostream&)>(std::flush));

Schlüsselwörter

static_cast

Beispiel

#include <iostream>
#include <vector>
struct B
{
    int m = 42;
    const char* hello() const
    {
        return "Hello world, this is B!\n";
    }
};
struct D : B
{
    const char* hello() const
    {
        return "Hello world, this is D!\n";
    }
};
enum class E { ONE = 1, TWO, THREE };
enum EU { ONE = 1, TWO, THREE };
int main()
{
    // 1. statischer Downcast
    D d;
    B& br = d; // Upcast durch implizite Konvertierung
    std::cout << "1) " << br.hello();
    D& another_d = static_cast<D&>(br); // Downcast
    std::cout << "1) " << another_d.hello();
    // 3. Lvalue zu Xvalue
    std::vector<int> v0{1, 2, 3};
    std::vector<int> v2 = static_cast<std::vector<int>&&>(v0);
    std::cout << "3) nach Move, v0.size() = " << v0.size() << '\n';
    // 4. Ausdruck mit verworfenem Wert
    static_cast<void>(v2.size());
    // 5. Initialisierungskonvertierung
    int n = static_cast<int>(3.14);
    std::cout << "5) n = " << n << '\n';
    std::vector<int> v = static_cast<std::vector<int>>(10);
    std::cout << "5) v.size() = " << v.size() << '\n';
    // 6. Umkehrung der impliziten Konvertierung
    void* nv = &n;
    int* ni = static_cast<int*>(nv);
    std::cout << "6) *ni = " << *ni << '\n';
    // 7a. Scoped Enum zu int
    E e = E::TWO;
    int two = static_cast<int>(e);
    std::cout << "7a) " << two << '\n';
    // 7b. int zu Enum, Enum zu anderem Enum
    E e2 = static_cast<E>(two);
    [[maybe_unused]]
    EU eu = static_cast<EU>(e2);
    // 7f. Zeiger auf Member-Upcast
    int D::*pm = &D::m;
    std::cout << "7f) " << br.*static_cast<int B::*>(pm) << '\n';
    // 7g. void* zu beliebigem Objektzeiger
    void* voidp = &e;
    [[maybe_unused]]
    std::vector<int>* p = static_cast<std::vector<int>*>(voidp);
}

1) Hallo Welt, dies ist B!
1) Hallo Welt, dies ist D!
3) nach Verschiebung, v0.size() = 0
5) n = 3
5) v.size() = 10
6) *ni = 3
7a) 2
7f) 42

Fehlerberichte

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

Referenzen

Siehe auch

• const_cast
• dynamic_cast
• reinterpret_cast
• explizite Konvertierung
• implizite Konvertierungen