operatore di static_cast
converte espressione il tipo di tipo-ID, basato solo sui tipi presenti nell'espressione.
static_cast <type-id> ( expression )
Note
Nessun controllo del tipo di runtime viene eseguito per garantire la sicurezza di conversione.
static_cast l'operatore può essere utilizzato per operazioni quali convertire un puntatore a una classe di base a un puntatore a una classe derivata.Tali conversioni non sempre sono protette.
In genere si utilizzano static_cast quando si desidera convertire i tipi di dati numerici le enumerazioni a int o int a strumenti e si essere un determinato numero di tipi di dati coinvolti nella conversione.static_cast le conversioni non sono protette come dynamic_cast conversioni, poiché static_cast mancato controllo del tipo di runtime, mentre dynamic_cast scegliere.In dynamic_cast a un puntatore ambiguo non riuscirà, mentre quelli static_cast restituisce come se non sia errato, ciò può risultare pericolosa.sebbene dynamic_cast le conversioni sono più sicure, dynamic_cast è supportata solo sui puntatori o sui riferimenti e il controllo del tipo di runtime è un sovraccarico.Per ulteriori informazioni, vedere operatore di dynamic_cast.
Nell'esempio che segue, la riga D* pd2 = static_cast<D*>(pb); non è consigliabile perché D è possibile assegnare i campi e metodi che non sono in B.Tuttavia, la riga B* pb2 = static_cast<B*>(pd); è una conversione sicura poiché D contiene sempre tutti di 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.
}
A differenza di dynamic_cast, nessun controllo in runtime viene eseguito su static_cast conversione di pb.L'oggetto puntato in near pb non può essere un oggetto di tipo Din questo caso, l'utilizzo di *pd2 potrebbe essere disastroso.Ad esempio, chiamando una funzione membro di D classe, ma non B la classe, è possibile che si verifichi una violazione di accesso.
dynamic_cast e static_cast gli operatori si sposta un puntatore in tutta la gerarchia di classi.tuttavia, static_cast si basa separatamente alle informazioni fornite nell'istruzione di cast e può pertanto essere pericolosa.Di seguito è riportato un esempio:
// 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 in realtà punti a un oggetto di tipo D, quindi pd1 e pd2 ottiene lo stesso valore.Anche ottiene nuovamente lo stesso valore se pb == 0.
se pb punta a un oggetto di tipo B e non a completo D classe, quindi dynamic_cast conoscerà sufficiente per restituire zero.tuttavia, static_cast si basa sull'asserzione del programmatore quello pb punta a un oggetto di tipo D e restituisce semplicemente un puntatore a quello previsto D oggetto.
Di conseguenza, static_cast può fare l'opposto delle conversioni implicite in questo caso, i risultati vengono definiti.È lo stesso al programmatore verificare che i risultati di un oggetto static_cast la conversione è sicura.
Questo comportamento si applica anche a tipi diversi dai tipi di classe.Ad esempio, static_cast può essere utilizzato per la conversione da un tipo int a un oggetto char.tuttavia, il risultato char potrebbe non essere sufficientemente bit per utilizzare l'intero int valore.Di nuovo, viene lasciato al programmatore verificare che i risultati di un oggettostatic_cast la conversione è sicura.
static_cast l'operatore può essere utilizzato per eseguire qualsiasi conversione implicita, incluse le conversioni standard e le conversioni definite dall'utente.Di seguito è riportato un esempio:
// 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);
}
static_cast l'operatore può convertire in modo esplicito un valore integrale a un tipo di enumerazione.Se il valore del tipo integrale non fa parte dell'intervallo dei valori di enumerazione, il valore di enumerazione risultante è definito.
static_cast l'operatore di conversione di un valore di puntatore null al valore di puntatore null del tipo di destinazione.
Qualsiasi espressione in modo esplicito essere convertito nel tipo void da static_cast operatore.Il tipo void di destinazione può includere const, volatile, o __unaligned attributo.
static_cast l'operatore non può eseguire il cast di const, volatile, o __unaligned attributi.vedere operatore di const_cast per informazioni sulla rimozione di questi attributi.
A causa di avviso di eseguire i cast deselezionati su un Garbage Collector di rilocazione, l'utilizzo di static_cast deve essere solo nel codice prestazioni-critico dopo avere verificato funzionerà correttamente.Se è necessario utilizzare static_cast in modalità di rilascio, sostituirla con safe_cast nelle build di debug per fornire esito positivo.