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 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** 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](../cpp/dynamic-cast-operator.md).

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 simply returns a pointer to that supposed `D` object.

Consequently, **static_cast** can do the inverse of implicit conversions, in which case 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 the entire **int** value. Again, it is left to the programmer to verify that the results of a **static_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:

The **static_cast** operator can explicitly convert an integral value to an enumeration type. If the value of the integral type does not fall within 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 **__unaligned** attribute.

The **static_cast** operator cannot cast away the **const**, **volatile**, or **__unaligned** attributes. See [const_cast Operator](../cpp/const-cast-operator.md) for information on removing these attributes.

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. If you must use **static_cast** in release mode, substitute it with [safe_cast](../windows/safe-cast-cpp-component-extensions.md) in your debug builds to ensure success.

The type of a static member is not qualified by its class name. Therefore, the type of `BufferedOutput::bytecount` is **long**.

The **__stdcall** calling convention is used to call Win32 API functions. The callee cleans the stack, so the compiler makes **vararg** functions **__cdecl**. Functions that use this calling convention require a function prototype.

The [/Gz](../build/reference/gd-gr-gv-gz-calling-convention.md) compiler option specifies **__stdcall** for all functions not explicitly declared with a different calling convention.

Functions declared using the **__stdcall** modifier return values the same way as functions declared using [__cdecl](../cpp/cdecl.md).

On ARM and x64 processors, **__stdcall** is accepted and ignored by the compiler; on ARM and x64 architectures, by convention, arguments are passed in registers when possible, and subsequent arguments are passed on the stack.