C++ Type Casting With Example for C Developers

DZone 's Guide to

C++ Type Casting With Example for C Developers

In this article, we break down type casting in C++ for C developers, focusing on c-style, static, const, and reinterpret casts.

· Web Dev Zone ·
Free Resource

The typecasting is a feature that makes C++ more type-safe, robust, and may convince you to use it over C. But this is also a more underrated topic when you are a newbie or moving from a C background. Hence, I came up with an article on it. Here, we will not only see the  C++ type casting with examples, but we will also cover how to remember and employ it easily. Although I am not an expert, but this is what I have learned so far from various sources and 5+ yrs of industry experience. 

In C++, there are 5 different types of casts: C-style casts, static_cast, const_cast, dynamic_cast, and reinterpret_cast.

Jargon You Need to Know

  1. Implicit conversion: where the compiler automatically typecast. Like float f = 3;. Here, the compiler will not complain but directly transform 3, which is of type integer into float and assign to f.
  2. Explicit conversions: where the developer uses a casting operator to direct the conversion. All types of manual casting fall under the explicit type conversions category. Like int * p = (int*)std::malloc(10);, here we explicitly casting void* to int*.
  3. l-value: an identifier which represents memory location. For example, variable name, *ptr where ptr points to a memory location, etc.
  4. r-value: a value which is not l-value,  r-value appears on the right-hand side of the assignment(=) operator. Like

Note: There are some exceptions and more to learn on lvalue, rvalue and their references in C++

Why Do We Need Typecasting?

  • Data is a representation of the bits(0s and 1s) in memory.
  • Data-type is compiler directive that tells the compiler how to store and process particular data.
  • uint32_t a = 5; with this statement, you can presume that 4 bytes will be reserved in your memory, and upon execution, it will store 0000 0000 0000 0000 0000 0000 0000 0101 data bits in that memory location. This was plain and simple. 
  • Let's go a bit further. float f = 3.0; — this statement will also reserve 4 bytes in memory and store data bits in the form of 1). the sign bit, 2). exponent and 3). mantissa. Recall how floating-point numbers are stored in memory.
  • But when you write something like, float f = 3;, the compiler will be confused that how to store an integer value in float type of memory. 
  • So it will automatically presume(Implicit conversion here) that you want to store 3.0 rather than 3, which is technically the same from the human point of view, but it's different when you think from computer memory perspective, as they are stored differently.
  • There are many such scenarios where you provide data to store in memory which is used to represent a different data type.
  • For example, in the following example, you are trying to assign an object of type B into an object of type A

In such a scenario, the compiler can not presume anything and simply throws a compilation error:


But, when you define a conversion operator as follows:


The compiler will simply call this member function & won't throw any error because programmer explicitly mentioning that this is how he/she wants to convert.

C++ Type Casting With Example for C Developers

[su_tabs][su_tab title="C-style casts" disabled="no" anchor="" url="" target="blank" class=""]

C-Style Casts


When you try to run the above code, you will get 2 as output, which we didn't expect. To initialize the res variable correctly, we need to typecast using float as follows:


Now, your answer will be 2.5. This type of casting is very simple and straight forward. You can also write the above casting in C++ as:


C-style casts can change a data type without changing the underlying memory representation, which may lead to garbage results.

[/su_tab] [su_tab title="static_cast" disabled="no" anchor="" url="" target="blank" class=""]


If you are C developer like me, then this will be your best goto C++ cast, which fits in most of the example like:


When you try to compile the above code using a C compiler, it works fine. But a C++ compiler, will not be so kind. It will throw an error as follows :


The first thing that comes to your mind is the C-style cast:


This will work, but C-style cast is not recommended in C++. static_cast handles implicit conversions like this. We will primarily use it for converting in places where implicit conversions fail, such as std::malloc.


The main advantage of static_cast is that it provides compile-time type checking, making it harder to make an inadvertent error. Let's understand this with C++ example:


As you can see, there is no easy way to distinguish between the two situations without knowing a lot about all the classes involved. Another problem with the C-style casts is that it is too hard to locate. In complex expressions, it can be very hard to see C-style casts (e.g. the T(something) syntax is equivalent to (T)something). 

[/su_tab] [su_tab title="const_cast" disabled="no" anchor="" url="" target="blank" class=""]


Now, we will directly jump to example. No theory can explain this better than an example. 

1. Ignore constness 


You are allowed to modify i because of the object (i here) being assigned to, is not const. If you add a const qualifier to i the code will compile, but its behavior will be undefined (which can mean anything from "it works just fine" to "the program will crash"). 

2. Modifying data member using const this pointer

const_cast can be used to change non-const class members by a method in which this pointer declared as const. This can also be useful when overloading member functions based on const, for instance:


3. Pass const argument to a function which accepts only non-const argument

const_cast can also be used to pass const data to a function that doesn’t receive const argument. See the following code:


4. Castaway volatile attribute

const_cast can also be used to cast away volatile attribute. Whatever we discussed above in const_cast is also valid for the volatile keyword.

[/su_tab] [su_tab title="dynamic_cast" disabled="no" anchor="" url="" target="blank" class=""]


dynamic_cast uses the type checking at runtime in contrary to static_cast which does it at compile time. dynamic_cast is more useful when you don't know the type of input that it represents. Let's assume:


As you can see, we don't know which object will be returned by CreateRandom() at run time but you want to execute Method1() of Derived1 if it returns Derived1. So in this scenario, you can use dynamic_cast as follows


In case, if the input of dynamic_cast does not point to valid data, it will return nullptr for pointers or throw a std::bad_cast exception for references. In order to work with dynamic_cast, your classes must be polymorphic type i.e. must include at least one virtual method.

dynamic_cast take advantage of RTTI(Run Time Type Identification) mechanism.

[/su_tab] [su_tab title="reinterpret_cast" disabled="no" anchor="" url="" target="blank" class=""]


reinterpret_cast converts between types by reinterpreting the underlying bit pattern.  You can use reinterpret_cast to cast any pointer or integral type to any other pointer or integral type. 

This can lead to dangerous situations: nothing will stop you from converting an int to an std::string*.

You can use reinterpret_cast in your embedded systems. A common scenario where reinterpret_cast applies is converting between uintptr_t and an actual pointer or between:


Instead, use this:



I have tried to cover most of the intricacies to clear the main concept behind different typecasting, but still, there might be a chance that I may miss some. So, this is it for C++ type casting with examples for C developers. Let's quickly recap:

Cheat Sheet for C Developers Moving to C++ on Type Casting

After reading all this, you may confused on what to use & when! That's why I have created this cheat sheet:

  • Avoid C-style casts. Be sure about what you want while casting.
  • Use static_cast wherever you were using C-style cast.
  • Use dynamic_cast with polymorphic classes. Keep in mind that you should only use dynamic_cast in classes with at least one virtual member in the inheritance hierarchy.
  • Use const_cast when you need to remove const or volatile qualifiers. 
  • Use reinterpret_cast when you have no options. 

Note: const_cast and reinterpret_cast should generally be avoided because they can be harmful if used incorrectly. Don't use it unless you have a very good reason to use them.

Some of the C++ Core Guidelines on Typecasting

Have any suggestions, query or wants to say Hi? Feel free to reach out!

c ,c/c++ ,tutorial ,type casting ,web dev

Published at DZone with permission of Vishal Chovatiya . See the original article here.

Opinions expressed by DZone contributors are their own.

{{ parent.title || parent.header.title}}

{{ parent.tldr }}

{{ parent.urlSource.name }}