Operador static_cast
Converte uma expressão no tipo de type-id com base somente nos tipos que estão presentes na expressão.
Sintaxe
static_cast <type-id> ( expression )
Comentários
No padrão C++, nenhuma verificação de tipo de tempo de execução é feita para ajudar a garantir a segurança da conversão. No C++/CX, uma verificação de tempo de compilação e de runtime é executada. Para obter mais informações, consulte Conversão.
O operador static_cast pode ser usado para operações como converter um ponteiro em uma classe base em um ponteiro e em uma classe derivada. Essas conversões não são sempre seguras.
Em geral, você usa static_cast quando quer converter tipos de dados numéricos, como enums, em ints ou ints em floats, e tem certeza dos tipos de dados envolvidos na conversão. As conversões static_cast não são tão seguranças quanto as conversões dynamic_cast, pois static_cast não verifica o tipo de tempo de execução, enquanto dynamic_cast verifica. Um dynamic_cast para um ponteiro ambíguo falhará, enquanto static_cast é retornado como se nada estivesse errado; isso pode ser perigoso. Embora as conversões dynamic_cast sejam seguras, dynamic_cast só funciona em ponteiros ou referências, e a verificação de tipo de tempo de execução é uma sobrecarga. Para mais informações, confira Operador dynamic_cast.
No exemplo a seguir, a linha D* pd2 = static_cast<D*>(pb); não é segura porque D pode ter campos e métodos que não estão em B. No entanto, a linha B* pb2 = static_cast<B*>(pd); é uma conversão segura porque D sempre contém tudo de 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.
}
Em contraste com dynamic_cast, nenhuma verificação de tempo de execução é feita na conversão static_cast de pb. O objeto apontado por pb não pode ser um objeto do tipo D, pois, nesse caso, o uso de *pd2 seria desastroso. Por exemplo, chamar uma função que é membro da classe D, mas não da classe B, poderá resultar em uma violação de acesso.
Os operadores dynamic_cast e static_cast movem um ponteiro em toda uma hierarquia de classe. No entanto, static_cast confia exclusivamente nas informações fornecidas na instrução de conversão, portanto, pode ser não seguro. Por exemplo:
// 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);
}
Se pb apontar para um objeto do tipo D, pd1 e pd2 obterão o mesmo valor. Eles também obterão o mesmo valor se pb == 0.
Se pb apontar para um objeto do tipo B e não para a classe D completa, dynamic_cast terá conhecimento suficiente para retornar zero. No entanto, static_cast depende da asserção do programador de que pb aponta para um objeto do tipo D e simplesmente retorna um ponteiro ao suposto objeto D.
Portanto, static_cast pode fazer o inverso de conversões implícitas; nesse caso, os resultados são indefinidos. O programador deve verificar se os resultados de uma conversão static_cast são seguros.
Esse comportamento também se aplica a tipos diferentes dos tipos de classe. Por exemplo, static_cast pode ser usado para converter um int em char. No entanto, o char resultante pode não ter bits suficientes para armazenar o valor inteiro de int. Além disso, o programador deve verificar se os resultados de uma conversão static_cast são seguros.
O operador static_cast também pode ser usado para executar qualquer conversão implícita, incluindo conversões padrão e conversões definidas pelo usuário. Por exemplo:
// 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);
}
O operador static_cast pode converter explicitamente um valor integral em um tipo de enumeração. Se o valor do tipo integral não estiver dentro do intervalo de valores de enumeração, o valor de enumeração resultante será indefinido.
O operador static_cast converte um valor de ponteiro nulo em valor de ponteiro nulo do tipo de destino.
Qualquer expressão pode ser explicitamente convertida no tipo void pelo operador static_cast. O tipo void de destino pode, opcionalmente, incluir o atributo const, volatile ou __unaligned.
O operador static_cast não pode eliminar os atributos const, volatile ou __unaligned. Confira Operador const_cast para obter informações sobre como remover esses atributos.
C++/CLI: Devido ao perigo de realizar conversões não verificadas sobre um coletor de lixo de realocação, o uso de static_cast só deve estar no código crítico de desempenho quando você tiver certeza de que funcionará corretamente. Se você precisar usar static_cast no modo de liberação, substitua-o por safe_cast em seus builds de depuração para garantir o êxito.