Type conversions in C++

Here’s a breakdown of type conversions in C++ with some practical examples:

Implicit Conversions:

  • Automatic: Occurs behind the scenes when compatible types are combined. Example:
int age = 25;
float average_age = 25.0 / 2; // Implicit promotion of int to float for division.

Explicit Conversions:

  • Forced: The programmer uses cast operators to change data types.


  • Static cast: Safe for predictable conversions. Example:
double pi = 3.14159;
int pi_int = static_cast<int>(pi); // Truncates decimal part.
  • Dynamic cast: Used for runtime conversions between polymorphic types (e.g., base and derived classes). Example:
class Shape { /* Base class */ };
class Circle : public Shape { /* Derived class */ };

Shape* shape = new Circle;
Circle* circle = dynamic_cast<Circle*>(shape); // Safe if shape points to a Circle object.
  • Const cast: Removes const qualifier (potentially risky). Example:
const int MAX_VALUE = 100;
int value = const_cast<int>(MAX_VALUE); // Can modify value, potentially violating const-correctness.
  • Reinterpret cast: Low-level interprets bits directly (unsafe). Example:
int x = 10;
char* str = reinterpret_cast<char*>(&x); // Accesses raw memory of x (undefined behavior).

Additional Examples:

Converting strings to integers:

Converting strings to integers in C++ can be done in several ways, each with its own advantages and limitations. Here are three common methods:

  • Using stoi:
    • Introduced in C++11, stoi (string to integer) is a safe and efficient way to convert a string containing a valid integer representation to an integer value.
    • It throws an exception if the conversion fails, making it easier to handle errors.
#include <string>

std::string str = "123";
int num = stoi(str); // num will be 123

try {
  std::string invalid_str = "abc";
  int invalid_num = stoi(invalid_str); // throws an exception
} catch (const std::exception& e) {
  // Handle conversion error
  • Using atoi:
    • Part of the C standard library, atoi (ASCII to integer) also converts a string to an integer.
    • However, it doesn’t throw exceptions and may not handle leading or trailing whitespace well.
    • Use it only if you need compatibility with older C code or for simple cases.
#include <stdlib.h>

std::string str = "123";
int num = atoi(str.c_str()); // num will be 123

std::string invalid_str = " abc";
int invalid_num = atoi(invalid_str.c_str()); // potentially undefined behavior
  • Using streams:
    • The stringstream class allows you to treat a string as a stream of characters and extract values using extraction operators like >>.
    • Provides more flexibility for handling complex string formats or extracting multiple values from a single string.
#include <sstream>

std::string str = "123,456";
std::stringstream ss(str);
int num1, num2;
ss >> num1; // num1 will be 123
ss >> num2; // num2 will be 456
  • Choosing the right method:
    • stoi is generally the safest and most recommended option for most cases.
    • Use atoi only for compatibility or simple conversions where error handling is not critical.
    • Consider streams for more complex string formats or extracting multiple values.

Converting user input (char*) to floats:

Converting user input (char*) to floats in C++ requires careful consideration, as different methods have their advantages and risks. Here are three options:

  • Using atof:
    • A standard C function that converts a character string to a floating-point number.
    • Easy to use but has limitations:
      • Doesn’t handle errors gracefully – may return unexpected values or crash on invalid input.
      • Doesn’t distinguish between successful conversion and encountering non-numeric characters.
#include <stdlib.h>

char userInput[] = "12.34";
float userFloat = atof(userInput); // userFloat will be 12.34

char invalidInput[] = "abc";
float invalidFloat = atof(invalidInput); // behavior undefined, potentially crashes
  • Using strtod:
    • More robust than atof.
    • Takes additional arguments like an end pointer to indicate where the conversion stopped.
    • Throws an exception (std::invalid_argument) on error, making error handling easier.
#include <string>

std::string userInput = "12.34";
float userFloat;
char* endPtr;
userFloat = std::strtod(userInput.c_str(), &endPtr);

if (endPtr != userInput.c_str() + userInput.length()) {
  // Conversion successful, userFloat contains the value
} else {
  // Error occurred while parsing

std::string invalidInput = "abc";
try {
  userFloat = std::strtod(invalidInput.c_str(), &endPtr);
} catch (const std::invalid_argument& e) {
  // Handle conversion error
  • Using streams:
    • Offers flexibility for handling complex formats and extracting multiple values.
    • Requires more code but provides more control over the conversion process.
#include <sstream>

std::string userInput = "12.34,5.67";
std::stringstream ss(userInput);
float userFloat1, userFloat2;
ss >> userFloat1; // userFloat1 will be 12.34
ss >> userFloat2; // userFloat2 will be 5.67

if (ss.fail()) {
  // Error occurred while parsing

Choosing the right method:

  • For simple cases and compatibility with older C code, atof can be used with caution and proper error handling.
  • For more robust and exception-safe conversions, opt for strtod.
  • If you need more flexibility and complex format handling, consider using streams.

Important points:

  • Choose appropriate conversion based on the situation and data types involved.
  • Use implicit conversions for simple cases.
  • Static cast is generally preferred for explicit conversions.
  • Dynamic cast is necessary for polymorphic types.
  • Const cast and reinterpret cast should be used cautiously due to potential risks.
Share this post:

Newsletter Updates

Enter your email address below and subscribe to our newsletter