Type Conversion

Type Conversion

Type Conversion (also known as Type Casting) is the process of converting a variable from one data type to another. It is a fundamental concept in C++ programming that ensures type compatibility, safe operations, and flexible use of data in expressions, assignments, and function calls.

Types of Type Conversion

C++ supports two primary types of conversion:

1️⃣ Implicit Conversion (Type Promotion or Coercion):

Implicit conversion, also known as automatic conversion, occurs when the compiler automatically converts one data type to another without any explicit instruction from the programmer. This conversion is performed automatically by the compiler when types are compatible and there is no risk of major data loss.

Characteristics:

• Done automatically by the compiler
• Converts form a lower to higher precision type (e.g., int → float)
• Helps in type compatibility during operations or assignments.

Example of conversion of int to float:

int intValue = 10;
float floatValue = intValue;  // Implicit conversion from int to float

In this example, the integer value intValue is implicitly converted to a floating-point number floatValue during the assignment.

Example in Expression:

int x = 5;
double y = 2.5;
double result = x + y; // x is promoted to double

2️⃣ Explicit Conversion (Type Casting):

Explicit conversion, also called type casting, is performed by the programmer using casting operators.

This is necessary when:

• Automatic conversion is not available.
• You want to override implicit behavior.
• You are converting between incompatible or unrelated types.

Types of Explicit Casting in C++

C++ provides five methods for explicit type conversion:

There are two types of explicit conversion: C-style casting and functional casting.

C-Style Casting:

In standard C programming, casts are done vis the () operator, with the name of the type to convert the value placed inside the parentheses.

float floatValue = 10.5;
int intValue = (int) floatValue;  // C-style casting

• Compact, but dangerous and ambiguous.
• Performs one of static_cast, const_cast, or reinterpret_cast, whichever works.
• Avoid in modern C++ (use C++ cast operators).

Functional Casting (Constructor-style) (Since C++11):

int value = int(3.75);  // Function-style cast - Converts float to int (value = 3)

• Slightly more readable than C-style, but still lacks clarity.

C++ Cast Operators (Safer and more specific):

C++ introduces four casting operators for more clarity and type safety, each with a specific use case:

• static_cast
• dynamic_cast
• const_cast
• reinterpret_cast

float floatValue = 10.5;
int intValue = static_cast<int>(floatValue); // C++ static_cast from float to int

Using static_cast is generally preferred as it performs checks at compile-time and is more specific about the intended conversion.

static_cast<T>(expression):

C++ introduces a casting operator called static_cast, which can be used to convert a value of one type to a value of another type.

Purpose:

• Compile-time conversion between related types (no runtime overhead).
• Safe for numeric conversions, upcasting pointers, or simple type adjustments.
• Used when the types are compatible or there's known relationship between them.
• Can be used for:
  • Numeric conversions: double → int, int → char
  • Converting pointers up the inheritance hierarchy (Derived* → Base*)
  • void* → actual pointer type
  • Enum ↔ int conversions

Example 1:

#include <iostream>

int main()
{
    char c { 'a' };
    std::cout << c << ' ' << static_cast<int>(c) << '\n'; // prints a 97

    return 0;
}

Example 2:

float f = 3.14;
int i = static_cast<int>(f);  // i = 3 (truncates decimal)

Example 3:

void* ptr = malloc(sizeof(int));
int* iptr = static_cast<int*>(ptr);  // from void* to typed pointer

⚠️ Caution:

• No runtime type check.
• Don not use for downcasting in polymorphic hierarchies.

dynamic_cast<T>(expression):

Purpose:

• Safe downcasting for polymorphic classes (i.e., those with virtual functions).

Description:

• Used for safe down casting in an inheritance hierarchy.
• Requires the base class to have at least one virtual function (i.e., polymorphic).
• Performs a runtime check and returns nullptr if the cast is invalid (for pointers).
• Works only with pointers or references to class types.

Example:

class Base { virtual void func() {} };
class Derived : public Base {};

Base* b = new Derived();
Derived* d = dynamic_cast<Derived*>(b);  // Safe cast: b actually points to Derived

Base* b2 = new Base();
Derived* d2 = dynamic_cast<Derived*>(b2);  // Invalid: returns nullptr

Features:

• Returns nullptr on failure (for pointers).
• Throws std::bad_cast on failure (for references).
• Requires at least one virtual method in the base class.

⚠️ Overhead:

• Introduces runtime type checking.
• Slightly slower, but type-safe and very useful in RTTI scenarios.

const_cast: const_cast<T>(expression)

Purpose:

• Add or remove const or volatile qualifiers.
• Often used to interface with APIs that don't accept const parameters.

Description:

• Used to cast awayconst or volatile qualifiers.
• Allows modifying something declared as const (not safe unless you're sure the object is non-const in reality).

Example:

void print(char* str) {
    std::cout << str;
}

const char* msg = "Hello";
print(const_cast<char*>(msg));  // Removes const, may be unsafe!

⚠️ Danger:

• Undefined behavior if you modify truly const data.
• Only use when you're confident the data wasn't originally declared const.

reinterpret_cast: reinterpret_cast<T>(expression)

Purpose:

• Reinterpret the bit pattern of a value.
• Used in low-level programming, e.g., for unions, memory manipulation, and hardware interfacing.

Description:

• Performs a bit-level reinterpretation of a value.
• Use to convert between unrelated pointer types, int to pointer, etc.
• Does no type safety checking — purely syntactic conversion.

Example:

int x = 42;
char* p = reinterpret_cast<char*>(&x);  // Treat int as char array

void* vptr = malloc(8);
long* lptr = reinterpret_cast<long*>(vptr);  // From void* to unrelated type

⚠️ Use With Extreme Caution:

• No safety checks.
• May lead to undefined behavior.
• Platform/compiler dependent.

Summary Table: C++ Cast Operators