Operator static_caststatic_cast Operator

Konwertuje wyrażenie na typ typu, na podstawie tylko typów, które są obecne w wyrażeniu.Converts an expression to the type of type-id, based only on the types that are present in the expression.

SkładniaSyntax

static_cast <type-id> ( expression )

UwagiRemarks

W standardowym C++ nie jest wykonywane żadne sprawdzenie typu w czasie wykonywania, aby pomóc w zapewnieniu bezpieczeństwa konwersji.In standard C++, no run-time type check is made to help ensure the safety of the conversion. W C++/CX, wykonywane są sprawdzenia czasu kompilacji i czasu wykonywania.In C++/CX, a compile time and runtime check are performed. Aby uzyskać więcej informacji, zobacz rzutowanie.For more information, see Casting.

static_cast Operatora można używać na potrzeby operacji takich jak konwertowanie wskaźnika do klasy bazowej na wskaźnik do klasy pochodnej.The static_cast operator can be used for operations such as converting a pointer to a base class to a pointer to a derived class. Takie konwersje nie zawsze są bezpieczne.Such conversions are not always safe.

Ogólnie używa się static_cast , gdy chcesz skonwertować liczbowe typy danych, takie jak wyliczenia na liczby całkowite lub liczby całkowite na Floating, i że masz pewne typy danych, które są wykorzystywane podczas konwersji.In general you use static_cast when you want to convert numeric data types such as enums to ints or ints to floats, and you are certain of the data types involved in the conversion. static_cast Konwersje nie są tak bezpieczne jak dynamic_cast konwersje, ponieważ nie static_cast sprawdzają typów w czasie wykonywania dynamic_cast .static_cast conversions are not as safe as dynamic_cast conversions, because static_cast does no run-time type check, while dynamic_cast does. dynamic_cast Do niejednoznacznego wskaźnika zakończy się niepowodzeniem, podczas gdy static_cast zwraca wartość tak, jakby nic się nie stało; może to być niebezpieczne.A dynamic_cast to an ambiguous pointer will fail, while a static_cast returns as if nothing were wrong; this can be dangerous. Chociaż dynamic_cast konwersje są bezpieczniejsze, dynamic_cast działają tylko w przypadku wskaźników lub odwołań, a sprawdzanie typu w czasie wykonywania jest narzutem.Although dynamic_cast conversions are safer, dynamic_cast only works on pointers or references, and the run-time type check is an overhead. Aby uzyskać więcej informacji, zobacz dynamic_cast operator.For more information, see dynamic_cast Operator.

W poniższym przykładzie wiersz D* pd2 = static_cast<D*>(pb); nie jest bezpieczny, ponieważ D może mieć pola i metody, które nie znajdują się w B .In the example that follows, the line D* pd2 = static_cast<D*>(pb); is not safe because D can have fields and methods that are not in B. Jednak wiersz B* pb2 = static_cast<B*>(pd); jest bezpieczną konwersją, ponieważ D zawsze zawiera wszystkie z nich B .However, the line B* pb2 = static_cast<B*>(pd); is a safe conversion because D always contains all of 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.
}

W przeciwieństwie do dynamic_castnie jest przeprowadzane sprawdzanie w czasie wykonywania static_cast konwersji pb .In contrast to dynamic_cast, no run-time check is made on the static_cast conversion of pb. Obiekt wskazywany przez pb nie może być obiektem typu D , w tym przypadku użycie *pd2 może być katastrofalne.The object pointed to by pb may not be an object of type D, in which case the use of *pd2 could be disastrous. Na przykład wywołanie funkcji, która jest elementem członkowskim D klasy, ale nie B klasy, może spowodować naruszenie zasad dostępu.For instance, calling a function that is a member of the D class, but not the B class, could result in an access violation.

dynamic_cast Operatory i static_cast przesuwają wskaźnik w całej hierarchii klas.The dynamic_cast and static_cast operators move a pointer throughout a class hierarchy. Jest jednak static_cast zależne wyłącznie od informacji podanych w instrukcji Cast i dlatego mogą być niebezpieczne.However, static_cast relies exclusively on the information provided in the cast statement and can therefore be unsafe. Na przykład:For example:

// 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);
}

Jeśli pb naprawdę wskazuje na obiekt typu D , a następnie uzyska pd1pd2 samą wartość.If pb really points to an object of type D, then pd1 and pd2 will get the same value. Otrzymają one również taką samą wartość, jeśli pb == 0 .They will also get the same value if pb == 0.

Jeśli pb wskazuje obiekt typu, B a nie do kompletnej D klasy, dynamic_cast będzie wystarczająco dużo, aby zwrócić zero.If pb points to an object of type B and not to the complete D class, then dynamic_cast will know enough to return zero. Jednakże static_cast opiera się na potwierdzeniu programisty, który pb wskazuje na obiekt typu D i po prostu zwraca wskaźnik do tego D obiektu.However, static_cast relies on the programmer's assertion that pb points to an object of type D and simply returns a pointer to that supposed D object.

static_cast W związku z tym można wykonać odwrotność konwersji niejawnych, w tym przypadku wyniki są niezdefiniowane.Consequently, static_cast can do the inverse of implicit conversions, in which case the results are undefined. Pozostało do programisty, aby sprawdzić, czy wyniki static_cast konwersji są bezpieczne.It is left to the programmer to verify that the results of a static_cast conversion are safe.

To działanie dotyczy także innych typów niż typy klas.This behavior also applies to types other than class types. Na przykład, static_cast może służyć do konwersji z int na char .For instance, static_cast can be used to convert from an int to a char. Jednak wyniki char mogą nie mieć wystarczającej liczby bitów, aby pomieścić całą int wartość.However, the resulting char may not have enough bits to hold the entire int value. Ponownie pozostało do programisty, aby sprawdzić, czy wyniki static_cast konwersji są bezpieczne.Again, it is left to the programmer to verify that the results of a static_cast conversion are safe.

static_cast Operatora można także użyć do wykonania dowolnej niejawnej konwersji, w tym konwersji standardowych i konwersji zdefiniowanych przez użytkownika.The static_cast operator can also be used to perform any implicit conversion, including standard conversions and user-defined conversions. Na przykład:For example:

// 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 Operator może jawnie skonwertować wartość całkowitą na typ wyliczeniowy.The static_cast operator can explicitly convert an integral value to an enumeration type. Jeśli wartość typu całkowitego nie wchodzi w zakres wartości wyliczenia, wynikowa wartość wyliczenia jest niezdefiniowana.If the value of the integral type does not fall within the range of enumeration values, the resulting enumeration value is undefined.

static_cast Operator konwertuje wartość wskaźnika o wartości null na wartość wskaźnika o wartości null typu docelowego.The static_cast operator converts a null pointer value to the null pointer value of the destination type.

Każde wyrażenie może być jawnie konwertowane na typ void przez static_cast operatora.Any expression can be explicitly converted to type void by the static_cast operator. Docelowy typ void może opcjonalnie zawierać const volatile atrybut,, lub __unaligned .The destination void type can optionally include the const, volatile, or __unaligned attribute.

static_cast Operator nie może rzutować const atrybutów, volatile , ani __unaligned .The static_cast operator cannot cast away the const, volatile, or __unaligned attributes. Aby uzyskać informacje na temat usuwania tych atrybutów, zobacz Operator const_cast .See const_cast Operator for information on removing these attributes.

/CLI C++: Ze względu na niebezpieczeństwo wykonywania niezaznaczonych rzutów w stosunku do ponownego lokalizowania modułu wyrzucania elementów bezużytecznych, użycie static_cast powinna być tylko w kodzie krytycznym dla wydajności, gdy jest to konieczne.C++/CLI: Due to the danger of performing unchecked casts on top of a relocating garbage collector, the use of static_cast should only be in performance-critical code when you are certain it will work correctly. Jeśli musisz użyć static_cast w trybie wydania, zastąp go safe_cast w kompilacjach debugowania, aby upewnić się, że powodzenie.If you must use static_cast in release mode, substitute it with safe_cast in your debug builds to ensure success.

Zobacz teżSee also

Operatory rzutowaniaCasting Operators
Słowa kluczoweKeywords