Type Casting in C++
In this lesson: All C++ casts — implicit, C-style, static_cast, dynamic_cast, const_cast, reinterpret_cast — with examples. In Hindi & English.
What is type casting?
Type casting converts a value from one type to another — a double to an int, a base pointer to a derived one. C++ gives four named cast operators that make each conversion explicit and safer than the old C-style (type)value form.
C-style casts
The old way still compiles but hides intent — it silently tries several conversions:
double d = 3.9; int x = (int)d; // C-style: works, but which cast is this?
Prefer the named casts below — they are clearer and searchable.
static_cast
The everyday cast: numeric conversions and upcasts, checked at compile time:
double d = 3.9; int x = static_cast<int>(d); // 3 (truncated) cout << x << "\n";
3
dynamic_cast
For safe downcasting in a polymorphic hierarchy — checked at run time, returns null on failure:
class Animal { public: virtual ~Animal() {} };
class Dog : public Animal { public: void bark() {} };
Animal *a = new Dog();
Dog *d = dynamic_cast<Dog*>(a); // succeeds → not null
if (d) d->bark();It needs a virtual function in the base to work.
const_cast
Adds or removes const — mainly to call old non-const-correct APIs:
void oldApi(char *s); // not const-correct const char *msg = "hi"; oldApi(const_cast<char*>(msg)); // only safe if oldApi doesn't modify
reinterpret_cast
The most dangerous — reinterprets raw bits as an unrelated type. For low-level work only:
int n = 65; int *p = &n; long addr = reinterpret_cast<long>(p); // pointer → integer
Which cast to use
| Cast | Use for | Checked |
|---|---|---|
static_cast | Numeric, upcasts | Compile time |
dynamic_cast | Safe downcasts | Run time |
const_cast | Add/remove const | Compile time |
reinterpret_cast | Low-level bit reinterpretation | None |
Common mistakes
- Using
reinterpret_castwherestatic_castis correct. - Modifying a truly
constobject afterconst_cast(undefined behaviour). - Forgetting to check
dynamic_castfor null before using the pointer. - Relying on C-style casts that hide a dangerous conversion.
Build an Animal base with Dog and Cat subclasses. Store them as Animal*, then use dynamic_cast to find which ones are dogs and call a dog-only method safely.
Summary
- Type casting converts between types; prefer C++ named casts.
static_castfor ordinary compile-time conversions.dynamic_castfor safe run-time downcasting (needs virtual).const_castadds/removes const;reinterpret_castreinterprets bits.- Named casts are clearer and safer than C-style casts.
Frequently Asked Questions
What is type casting in C++?
double into an int or a base pointer into a derived pointer. C++ offers four named cast operators — static_cast, dynamic_cast, const_cast and reinterpret_cast — that make the intent of each conversion explicit and safer than old C-style casts.What is the difference between static_cast and dynamic_cast in C++?
static_cast performs conversions checked at compile time, such as numeric conversions or upcasts, with no run-time cost. dynamic_cast is used for safe downcasting in an inheritance hierarchy and checks at run time whether the object is really of the target type, returning null (for pointers) if it is not.When should you use const_cast in C++?
const_cast adds or removes const (or volatile) from a type. Its main legitimate use is to call an older API that is not const-correct with data you know is safe to modify; casting away const and then actually modifying a truly const object is undefined behaviour.What does reinterpret_cast do in C++?
reinterpret_cast reinterprets the bit pattern of a value as a different, unrelated type, such as converting a pointer to an integer. It is the most dangerous cast, used for low-level work, and gives no guarantees about portability, so it should be avoided unless absolutely necessary.Why prefer C++ named casts over C-style casts?
static_cast will not silently strip const, for example. A C-style cast tries several conversions in turn and can hide dangerous ones, whereas named casts are searchable, clearer to readers, and safer.