static_cast Operator

Converts an expression to the type of type-id, based only on the types that are present in the expression.

static_cast <type-id> ( expression ) 

Remarks

No run-time type check is made to help ensure the safety of the conversion.

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. Such conversions are not always safe.

In general, 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 conversions are not as safe as dynamic_cast conversions, because static_cast does no run-time type check, while dynamic_cast does. A dynamic_cast to an ambiguous pointer will fail, while a static_cast returns as if nothing were wrong; this can be dangerous. Although dynamic_cast conversions are safer, dynamic_cast only works on pointers or references, and the run-time type check is an overhead. For more information, see dynamic_cast Operator.

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. 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 by using: /LD
class B {};

class D : public B {};             // D is based on 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.
}

In contrast to dynamic_cast, no run-time check is made on the static_cast conversion of pb. If the object pointed to by pb is not an object of type D, the use of *pd2 could be disastrous. For instance, calling a function that is a member of the D class, but not the B class, could cause an access violation.

The dynamic_cast and static_cast operators move a pointer throughout a class hierarchy. However, static_cast relies exclusively on the information provided in the cast statement and can therefore be unsafe. For example:

// static_cast_Operator_2.cpp
// compile by using: /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);
}

If pb really points to an object of type D, pd1 and pd2 will get the same value. They will also get the same value if pb == 0.

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. However, static_cast relies on the programmer's assertion that pb points to an object of type D and just returns a pointer to that supposed D object.

Consequently, static_cast can do the inverse of implicit conversions, so that the results are undefined. It is left to the programmer to verify that the results of a static_cast conversion are safe.

This behavior also applies to types other than class types. For instance, static_cast can be used to convert from an int to a char. However, the resulting char may not have enough bits to hold all of the int value. Again, it is left to the programmer to verify that the results of astatic_cast conversion are safe.

The static_cast operator can also be used to perform any implicit conversion, including standard conversions and user-defined conversions. For example:

// static_cast_Operator_3.cpp
// compile by using: /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);
}

The static_cast operator can explicitly convert an integral value to an enumeration type. If the value of the integral type does not fall in the range of enumeration values, the resulting enumeration value is undefined.

The static_cast operator converts a null pointer value to the null pointer value of the destination type.

Any expression can be explicitly converted to type void by the static_cast operator. The destination void type can optionally include the const, volatile, or __unalignedattribute.

The static_cast operator cannot cast away the const, volatile, or __unaligned attributes. For information about how to remove these attributes, see const_cast Operator.

Due to the danger of performing unchecked casts where they can be broken by a relocating garbage collector, we recommend that you use static_cast only in performance-critical code when you are sure it will work correctly. If you must use static_cast in release mode, substitute it by using safe_cast in your debug builds to guarantee success.

See Also

Reference

Casting Operators

C++ Keywords

Change History