Operador static_cast
Converte um expressão o tipo de identificação do tipo, com base apenas nos tipos que estão presentes na expressão.
static_cast <type-id> ( expression )
Comentários
Nenhuma verificação de tipo de tempo de execução é feita para ajudar a garantir a segurança da conversão.
O static_cast pode ser usado para operações como, por exemplo, a conversão de um ponteiro para uma classe base para um ponteiro para uma classe derivada.Tais conversões nem sempre são seguras.
Em geral você usa static_cast quando você deseja converter tipos de dados numéricos como, por exemplo, enums icas ou icas floats e você estão certos tipos de dados envolvidos na conversão.static_castconversões não são tão seguras quanto dynamic_cast conversões, pois static_cast nenhum tipo de tempo de execução verifica, enquanto dynamic_cast oferece.A dynamic_cast para um ponteiro ambíguo falhará, enquanto um static_cast retorna como se nada estivesse errado; Isso pode ser perigoso.Embora dynamic_cast conversões são mais seguras, dynamic_cast somente funciona em ponteiros ou referências e verificação de tipo de tempo de execução é uma sobrecarga.Para obter mais informações, consulte Operador de dynamic_cast.
No exemplo a seguir, a linha D* pd2 = static_cast<D*>(pb); não é seguro porque D pode ter campos e métodos que não estejam em B.No entanto, a linha B* pb2 = static_cast<B*>(pd); é uma conversão de segurança porque D sempre contém todos os 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 a static_cast conversão de pb.O objeto apontado pelo pb não pode ser um objeto do tipo D, caso em que o uso de *pd2 pode ser desastroso.Por exemplo, chamando uma função que é um membro da D de classe, mas não o B da classe, que pode resultar em uma violação de acesso.
O dynamic_cast e static_cast operadores mover um ponteiro ao longo de uma hierarquia de classes.No entanto, static_cast baseia-se exclusivamente nas informações fornecidas na instrução cast e pode não ser seguras.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 realmente aponta para um objeto do tipo D, em seguida, pd1 e pd2 obterá o mesmo valor.Eles também terá o mesmo valor se pb == 0.
Se pb aponta para um objeto do tipo B e não para o completo D de classe, em seguida, dynamic_cast saberá o suficiente para retornar zero.No entanto, static_cast baseia-se na declaração do programador que pb aponta para um objeto do tipo D e simplesmente retorna um ponteiro para o que deve D objeto.
Conseqüentemente, static_cast pode fazer o inverso da conversões implícitas, caso em que os resultados são indefinidos.Ela é deixada para o programador para verificar se os resultados de uma static_cast conversão são seguros.
Esse comportamento também se aplica a tipos diferentes de tipos de classe.Por exemplo, static_cast pode ser usado para converter de um int para um char.No entanto, o resultante char pode não ter o suficiente de bits para armazenar todo o int valor.Novamente, ela é deixada para o programador para verificar se os resultados de umastatic_cast conversão são seguros.
O static_cast operador 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 static_cast operador explicitamente pode converter um valor inteiro para um tipo de enumeração.Se o valor do tipo integral não se enquadra dentro do intervalo de valores de enumeração, o valor de enumeração resultante é indefinido.
O static_cast operador converte um valor de ponteiro nulo para o valor de ponteiro nulo do tipo de destino.
Qualquer expressão pode ser convertido para o tipo void por explicitamente a static_cast operador.O tipo void destino pode incluir, opcionalmente, o const, volatile, ou __unaligned atributo.
O static_cast operador não é possível converter fora do const, volatile, ou __unaligned atributos.Consulte const_cast operador para obter informações sobre como remover esses atributos.
Devido ao perigo de realizar projeções não verificadas na parte superior de um coletor de lixo realocando, o uso de static_cast só deve ser no código cujo desempenho é crítico quando você tiver certeza de que ele funcione corretamente.Se você precisar usar static_cast no modo de versão, substituí-lo com Safe_cast em suas compilações de depuração para garantir o sucesso.