Chapter 91: Explicit type conversions

An expression can be explicitly converted or cast to type T using dynamic_cast<T>, static_cast<T>, reinterpret_cast<T>, or const_cast<T>, depending on what type of cast is intended.

C++ also supports function-style cast notation, T(expr), and C-style cast notation, (T)expr.

Section 91.1: C-style casting

C-Style casting can be considered 'Best e ort' casting and is named so as it is the only cast which could be used in C. The syntax for this cast is (NewType)variable.

Whenever this cast is used, it uses one of the following c++ casts (in order):

const_cast<NewType>(variable)

static_cast<NewType>(variable)

const_cast<NewType>(static_cast<const NewType>(variable))

reinterpret_cast<const NewType>(variable)

const_cast<NewType>(reinterpret_cast<const NewType>(variable))

Functional casting is very similar, though as a few restrictions as the result of its syntax: NewType(expression). As a result, only types without spaces can be cast to.

It's better to use new c++ cast, because s more readable and can be spotted easily anywhere inside a C++ source code and errors will be detected in compile-time, instead in run-time.

As this cast can result in unintended reinterpret_cast, it is often considered dangerous.

Section 91.2: Casting away constness

A pointer to a const object can be converted to a pointer to non-const object using the const_cast keyword. Here we use const_cast to call a function that is not const-correct. It only accepts a non-const char* argument even though it never writes through the pointer:

bad_strlen(const_cast<char*>(s)); // OK, but it's better to make bad_strlen accept const char*

const_cast to reference type can be used to convert a const-qualified lvalue into a non-const-qualified value.

const_cast is dangerous because it makes it impossible for the C++ type system to prevent you from trying to modify a const object. Doing so results in undefined behavior.

const int x = 123;

int& mutable_x = const_cast<int&>(x);

mutable_x = 456; // may compile, but produces *undefined behavior*

Section 91.3: Base to derived conversion

A pointer to base class can be converted to a pointer to derived class using static_cast. static_cast does not do any run-time checking and can lead to undefined behaviour when the pointer does not actually point to the desired type.

register_callback(my_callback,

reinterpret_cast<void*>(x)); // hopefully this doesn't lose information...

Section 91.5: Conversion by explicit constructor or explicit conversion function

A conversion that involves calling an explicit constructor or conversion function can't be done implicitly. We can request that the conversion be done explicitly using static_cast. The meaning is the same as that of a direct initialization, except that the result is a temporary.

class C { std::unique_ptr<int> p;

public:

explicit C(int* p) : p(p) {}

Section 91.6: Implicit conversion

static_cast can perform any implicit conversion. This use of static_cast can occasionally be useful, such as in the following examples:

When passing arguments to an ellipsis, the "expected" argument type is not statically known, so no implicit conversion will occur.

const double x = 3.14;

printf("%d\n", static_cast<int>(x)); // prints 3

//printf("%d\n", x); // undefined behaviour; printf is expecting an int here

//alternative:

//const int y = x; printf("%d\n", y);

Without the explicit type conversion, a double object would be passed to the ellipsis, and undefined behaviour would occur.

A derived class assignment operator can call a base class assignment operator like so:

struct Base { /* ... */ }; struct Derived : Base {

Derived& operator=(const Derived& other) { static_cast<Base&>(*this) = other;

//alternative:

//Base& this_base_ref = *this; this_base_ref = other;

}

};

Section 91.7: Enum conversions

static_cast can convert from an integer or floating point type to an enumeration type (whether scoped or