AdvancedC++ Programming · Lesson 15 of 17 · Updated ·
Type Casting in C++ — static_cast, dynamic_cast, const_cast and reinterpret_cast
A program often needs a value as a different type: total marks as a double to get an exact average, a character as its ASCII code, a base-class pointer as the derived class it really points to. Converting a value from one type to another is called type casting (or type conversion). C++ gives four named casts for this, each with one clear job. "What are the four casts in C++, and when is each used?" is a standard interview question.
1. Implicit conversions
Many conversions happen automatically. The compiler converts int to double when you mix them, char to int in arithmetic, and a derived-class pointer to a base-class pointer.
The trouble is that the automatic rules do not always do what you mean. The classic example is integer division:
#include <iostream>
using namespace std;
int main() {
int total = 355, subjects = 4;
double avg1 = total / subjects; // int / int = 88, then converted
double avg2 = static_cast<double>(total) / subjects; // 355.0 / 4 = 88.75
cout << avg1 << " " << avg2 << "\n";
char grade = 'A';
cout << static_cast<int>(grade) << " " << static_cast<char>(grade + 2) << "\n";
double price = 99.99;
int rupees = static_cast<int>(price); // drops the fraction
cout << rupees << "\n";
return 0;
}
88 88.75
65 C
99
In avg1, both operands are int, so C++ does integer division first (88) and only then converts 88 to double. Casting one operand before dividing makes it a floating-point division. Converting double to int truncates — it drops the fraction, it does not round.
2. Why not the C-style cast?
C writes casts as (double)total. C++ still accepts this, but it is discouraged because:
- It can do anything — a harmless number conversion, removing
const, or treating memory as a completely different type — and the code looks the same in every case. - It is hard to search for. You cannot easily grep a project for
(int).
The four named casts each allow only one kind of conversion, so the compiler rejects a cast that does something you did not intend, and a reader sees your intent at once.
3. static_cast: ordinary, compile-time conversions
static_cast<T>(x) is the one you will use most. It handles conversions that make sense and are checked by the compiler:
- between number types:
int↔double,char↔int enum classvalues to and from integersvoid *back to a typed pointer (for example, aftermalloc)- upcasts (derived → base) and, without any run-time check, downcasts
#include <iostream>
using namespace std;
enum class Grade { A = 1, B, C };
int main() {
Grade g = Grade::C;
cout << static_cast<int>(g) << "\n"; // enum class needs an explicit cast
Grade h = static_cast<Grade>(2);
cout << (h == Grade::B) << "\n";
long long big = 3000000000LL;
int small = static_cast<int>(big); // allowed, but the value does not fit
cout << (small == big) << "\n";
return 0;
}
3
1
0
The last line is a warning: static_cast does what you ask even when information is lost. Three billion does not fit in a 32-bit int, so the result is a different number. A cast tells the compiler "I know what I am doing" — so be sure you do.
4. dynamic_cast: safe downcasting
An upcast goes from derived to base (Manager * → Employee *). It is always safe and happens automatically. A downcast goes the other way, from base to derived. It is only safe if the object really is of the derived type.
dynamic_cast checks this at run time:
- For pointers, it returns the derived pointer if the object matches, or
nullptrif it does not. - For references, it throws
std::bad_castif it does not match (a reference cannot be null). - It only works on polymorphic classes — classes with at least one virtual function — because it uses the type information stored with the vtable.
#include <iostream>
#include <string>
#include <vector>
using namespace std;
class Employee {
public:
string name;
Employee(string n) : name(n) {}
virtual ~Employee() {} // makes the class polymorphic
};
class Manager : public Employee {
public:
int teamSize;
Manager(string n, int t) : Employee(n), teamSize(t) {}
};
class Engineer : public Employee {
public:
Engineer(string n) : Employee(n) {}
};
int main() {
vector<Employee *> staff = {new Engineer("Asha"), new Manager("Ravi", 6), new Engineer("Meena")};
for (Employee *e : staff) {
if (Manager *m = dynamic_cast<Manager *>(e))
cout << m->name << " manages " << m->teamSize << " people\n";
else
cout << e->name << " is not a manager\n";
}
for (Employee *e : staff) delete e;
return 0;
}
Asha is not a manager
Ravi manages 6 people
Meena is not a manager
If we had used static_cast<Manager *>(e) here, the compiler would have trusted us. For Asha, an Engineer, reading m->teamSize would then read memory that is not a teamSize at all — undefined behaviour. dynamic_cast costs a small run-time check, and that check is what makes it safe.
If you find yourself writing many dynamic_casts, consider a virtual function instead: let each class answer the question itself.
5. const_cast: removing const
const_cast adds or removes const. Its honest use is calling an old function (often a C library) that takes a char * but does not actually modify the data:
#include <iostream>
#include <string>
using namespace std;
void legacy_print(char *s) { cout << "[" << s << "]\n"; } // old API: does not change s
int main() {
const string city = "Jaipur";
legacy_print(const_cast<char *>(city.c_str())); // we know it only reads
return 0;
}
[Jaipur]
Modifying an object that was declared const through a const_cast pointer is undefined behaviour. The cast only removes the compiler's check; it does not make the object writable.
6. reinterpret_cast: the same bits as a different type
reinterpret_cast tells the compiler to treat a pointer as a pointer to a completely unrelated type. It does no conversion of the data at all. It is used in low-level code: binary file I/O (as in the file handling lesson), hardware registers and network packets.
#include <iostream>
using namespace std;
int main() {
int x = 0x01020304;
unsigned char *bytes = reinterpret_cast<unsigned char *>(&x);
for (int i = 0; i < 4; i++) cout << (int)bytes[i] << " ";
cout << "\n";
return 0;
}
4 3 2 1
The output shows how the int is laid out in memory. On a little-endian machine (x86 and most ARM systems, which covers nearly all laptops and phones), the lowest byte is stored first, giving 4 3 2 1. A big-endian machine would print 1 2 3 4. That machine dependence is exactly why reinterpret_cast should be rare.
7. explicit constructors: stopping surprise conversions
A constructor with one parameter also acts as an implicit conversion. With class Rupees { public: Rupees(int v); };, the call pay(500) silently turns 500 into a Rupees object. Sometimes that hides a bug — was 500 rupees or 500 paise meant? Mark the constructor explicit to forbid it:
class Rupees {
public:
explicit Rupees(int v) : value(v) {}
int value;
};
void pay(Rupees r) { /* ... */ }
// pay(500); // error: no implicit conversion from int
// pay(Rupees(500)); // OK: the conversion is written out
A good rule: make single-argument constructors explicit unless the implicit conversion is clearly natural.
Common mistakes
- Casting after an integer division (
(double)(a / b)) instead of before (static_cast<double>(a) / b). - Expecting
double→intto round. It truncates: 99.99 becomes 99. - Using
static_castto downcast when you are not sure of the real type. Usedynamic_castand check fornullptr. - Using
dynamic_caston a class with no virtual functions — it does not compile. - Writing through a pointer obtained by
const_caston a trulyconstobject. - Reaching for C-style casts out of habit; they hide which conversion you meant.
Quick recap
- Implicit conversions are automatic; be careful with integer division and narrowing.
static_cast: normal conversions (numbers, enums, upcasts), checked at compile time.dynamic_cast: safe downcast checked at run time;nullptrfor pointers,bad_castfor references; needs a virtual function.const_cast: removesconstto call old APIs; never use it to modify a const object.reinterpret_cast: raw reinterpretation of bits; machine-dependent, use rarely.explicitconstructors stop unwanted implicit conversions.