static_cast – operátor
Převede expression na typ type-id, pouze na základě typů, které jsou k dispozici ve výrazu.
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 Obsazení (C + +/ CX).
Operátor static_cast lze použít pro operace, jako je například převod ukazatele na základní třídu na ukazatel na odvozenou třídu.Tyto převody nejsou vždy bezpečné.
Obecně můžete použít static_cast, když chcete převést číselné datové typy, například výčty na čísla nebo čísla na hodnoty float, a jste si jisti typy dat zapojených do převodu.Převody static_cast nejsou tak bezpečné jako převody dynamic_cast, protože static_cast nespouští kontrolu za běhu, zatímco dynamic_cast ano.dynamic_cast na nejednoznačný ukazatel se nezdaří, zatímco static_cast vrátí, jako kdyby bylo vše v pořádku; to může být nebezpečné.I když převody dynamic_cast jsou bezpečnější, dynamic_cast funguje pouze u ukazatelů nebo odkazů a kontrola typu v době spuštění je další režií.Další informace naleznete v tématu dynamic_cast – operátor.
V příkladu, který následuje, řádek D* pd2 = static_cast<D*>(pb); není bezpečný, protože D může obsahovat pole a metody, které nejsou v B.Avšak řá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í žádná kontrola běhu provedena na převodu static_castpb.Objekt, na který odkazuje pb, nemusí být objekt typu D. V takovém případě může mít použití *pd2 katastrofální důsledky.Například volání funkce, která je členem třídy D, nikoli však třídy B, může vést k narušení přístupu.
Operátory dynamic_cast a static_cast pohybují ukazatelem v rámci hierarchie tříd.Nicméně static_cast spoléhá výhradně na informace uvedené v prohlášení přetypování a může proto 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 ve skutečnosti odkazuje na objekt typu D, pak pd1 a pd2 dostanou stejnou hodnotu.Dostanou také stejnou hodnotu, pokud pb == 0.
Pokud pb odkazuje na objekt typu B a nikoliv na úplnou třídu D, pak dynamic_cast bude mít dost informací k vrácení nuly.Nicméně static_cast spoléhá na tvrzení programátora, že pb odkazuje na objekt typu D, a jednoduše vrací ukazatel na tento předpokládaný objekt D.
V důsledku toho static_cast může provést inverzní implicitní převod; v takovém případě nejsou výsledky definovány.Je ponecháno na programátorovi, aby ověřil, zda jsou výsledky převodu static_cast bezpečné.
Toto chování platí také pro jiné typy než typy tříd.Například static_cast lze převést z int na char.Avšak výsledný char nemusí mít dostatek bitů k uložení celé hodnoty int.Opět je na programátorovi, aby ověřil, zda jsou výsledky převodustatic_cast bezpečné.
Operátor static_cast lze také použít k provádění jakýchkoli implicitních převodů, včetně standardních převodů a uživatelem 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ůžete explicitně převést integrální 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 typu null cílového typu.
Libovolný výraz může být explicitně převeden na typ void operátorem static_cast.Cílový typ void může volitelně zahrnovat atribut const, volatile nebo __unaligned.
Operátor static_cast nemůže přetypovat pryč atribut const, volatile ani __unaligned.Viz Operátor const_cast pro informace o odebírání těchto atributů.
Z důvodu nebezpečí provádění nekontrolovaného přetypování nad relokačním kolektorem uvolnění paměti je třeba static_cast použít pouze v kódu kritickém pro výkon, když jste si jisti, že bude správně fungovat.Pokud je nutné použít static_cast v režimu vydání, nahraďte ji v sestavení ladění safe_cast (rozšíření komponent C++), aby byl zajištěn úspěch.