static_cast – operátor

Převede výraz na typ id typu na základě pouze typů, které jsou ve výrazu přítomné.

Syntaxe

static_cast <type-id> ( expression )

Poznámky

Ve standardním jazyce C++ se pro zajištění bezpečnosti převodu neprovádí žádné typové kontroly za běhu. V jazyce C + +/ CX se provádí kontrola během kompilace a za běhu. Další informace naleznete v tématu Casting.

Operátor static_cast lze použít pro operace, jako je převod ukazatele na základní třídu na ukazatel na odvozenou třídu. Tyto převody nejsou vždy bezpečné.

Obecně se používá static_cast , když chcete převést číselné datové typy, jako jsou výčty na inty nebo inty na plovoucí hodnoty, a vy jste si jisti datovými typy, které jsou součástí převodu. static_cast převody nejsou tak bezpečné jako dynamic_cast převody, protože static_cast nekontroluje typ za běhu, zatímco dynamic_cast to dělá. U dynamic_cast nejednoznačného ukazatele dojde k selhání, zatímco static_cast se vrátí jako by se nic nepovedlo. Může to být nebezpečné. I když dynamic_cast jsou převody bezpečnější, dynamic_cast funguje jenom na ukazatelích nebo odkazech a kontrola typu za běhu představuje režijní náklady. Další informace naleznete v tématu dynamic_cast – operátor.

V následujícím příkladu není řádek D* pd2 = static_cast<D*>(pb); bezpečný, protože D může mít pole a metody, které nejsou v B. Nicméně, řádek B* pb2 = static_cast<B*>(pd); je bezpečný převod, protože D vždy obsahuje všechny .B

// static_cast_Operator.cpp
// compile with: /LD
class B {};

class D : public B {};

void f(B* pb, D* pd) {
   D* pd2 = static_cast<D*>(pb);   // Not safe, D can have fields
                                   // and methods that are not in B.

   B* pb2 = static_cast<B*>(pd);   // Safe conversion, D always
                                   // contains all of B.
}

Na rozdíl od dynamic_cast není provedena žádná kontrola doby běhu při převodu static_castpb. Objekt, na který pb odkazuje, nemusí být objektem typu D, v takovém případě by mohlo *pd2 být katastrofální. Voláním funkce, která je členem D třídy, ale ne B třídou, může dojít k narušení přístupu.

Operátory dynamic_cast a static_cast operátory přesunou ukazatel v hierarchii tříd. static_cast Spoléhá však výhradně na informace uvedené v příkazu přetypování, a proto může být nebezpečné. Příklad:

// static_cast_Operator_2.cpp
// compile with: /LD /GR
class B {
public:
   virtual void Test(){}
};
class D : public B {};

void f(B* pb) {
   D* pd1 = dynamic_cast<D*>(pb);
   D* pd2 = static_cast<D*>(pb);
}

Pokud pb skutečně odkazuje na objekt typu D, pak pd1 a pd2 získá stejnou hodnotu. Získá také stejnou hodnotu, pokud pb == 0.

Pokud pb odkazuje na objekt typu B , a ne na úplnou D třídu, bude dynamic_cast vědět, že je dostatek k vrácení nuly. static_cast Spoléhá však na programátorský kontrolní výraz, který pb odkazuje na objekt typuD, a jednoduše vrátí ukazatel na tento předpokládaný D objekt.

V důsledku toho static_cast může provést inverzní funkci implicitních převodů, v takovém případě jsou výsledky nedefinované. Programátor musí ověřit, že výsledky převodu static_cast jsou bezpečné.

Toto chování platí také pro jiné typy než typy tříd. Lze například static_cast použít k převodu z int na char. Výsledek char ale nemusí obsahovat dostatek bitů k uložení celé int hodnoty. Znovu je ponechán programátor ověřit, že výsledky převodu static_cast jsou bezpečné.

Operátor static_cast lze také použít k provedení jakéhokoli implicitního převodu, včetně standardních převodů a uživatelsky definovaných převodů. Příklad:

// static_cast_Operator_3.cpp
// compile with: /LD /GR
typedef unsigned char BYTE;

void f() {
   char ch;
   int i = 65;
   float f = 2.5;
   double dbl;

   ch = static_cast<char>(i);   // int to char
   dbl = static_cast<double>(f);   // float to double
   i = static_cast<BYTE>(ch);
}

Operátor static_cast může explicitně převést celočíselnou hodnotu na typ výčtu. Pokud hodnota integrálního typu nespadá do rozsahu hodnot výčtu, výsledná hodnota výčtu není definována.

Operátor static_cast převede hodnotu ukazatele null na hodnotu nulového ukazatele cílového typu.

Libovolný výraz lze explicitně převést na typ void operátorem static_cast . Cílový typ void může volitelně obsahovat consthodnotu , volatilenebo __unaligned atribut.

Operátor static_cast nemůže přetypovat const, volatilenebo __unaligned atributy. Informace o odebrání těchto atributů najdete v části const_cast – operátor .

C++/CLI: Vzhledem k nebezpečí provádění nezaškrtnutých přetypování nad uvolněním paměti by mělo být použití static_cast pouze v kritickém kódu výkonu, pokud jste si jistí, že bude fungovat správně. Pokud ho musíte použít static_cast v režimu vydání, nahraďte ho safe_cast v buildech ladění, abyste zajistili úspěch.

Viz také

Operátory přetypování
Klíčová slova