How to Convert Data Types in C++ with TypeCasting Operator Example

Converting data types from one to another is a most basic aspect for any programmers.

First, let us start with the basics.

int nNumber;

The following are few things to keep in mind for the above line of code:

• Data type of nNumber is int, which means that we are dealing with number that will be good for natural numbers from certain range. Sometimes, this is not good, as this is machine dependent, and when you use 32 bit machine, it will be different than when you use 64 bit machine.
• For this variable, a place is reserved in memory and that place has an address. To obtain the address for a variable you could use operator that will return the address of the variable. For example: &nNumber. This is very important operator and it is used to connect the pointer and some other object in memory.
• When you write something like this nNumber=10, system will interpret array of ones and zeros in certain way. Well they will be interpreted as int-s, and it call that array of zeros and ones nNumber or change value 10 into something else.

There are pointers as well, they are not storing the value, but they contain the address of some object in the memory. To define the pointer you could do something like this:

int* ptr;

This code is reserving the place for addresses that will point to some int data. There are also void pointers, they have no type to point to, but they could be converted to some pointer of certain data type.

Then to work with the pointers, you need to connect it to some object in the memory that has address that could be done like this:

ptr = & nNumber;

Now you connected object of int type in the memory. If pointer has nothing to point to, it will use NULL address, and new C++11 standard has new way for that. You are advised to use: nullptr.

Now, let us move to constants. For example, pi is a constant that is used to calculate area of the circle and in some other calculations.

To define a constant value, we could use macro like this:

#define EXIT_SUCCESS 0

Now, every time when EXIT_SUCCESS is found in the code it will be replaced with 0.

This way you don’t see what is the type of const, so you could define the constant value like this:

const unsigned long long cullConstantValue = 011235813;

You can also figure out the size of a variable as shown below:

sizeof(someObject);

When you want to define your own datatype, do the following:

typedef unsigned long long int myDataType;

This way you don’t have to types those very long data types every time, and also this is easy to understand.

And if you are familiar with classes, then it would be appropriate to compare class to data type and object to variable.

In the next few lines we will also need from you to understand the concept of classes, inheritance and few other things.

How and Why to Convert Data Types

When you have an expression that has few different data types in it, you could end up with lost precision. That is one of the reason why you need data conversion. There are also some other situations that require from you to convert data types as well.

So, how do we convert data types? You could do something like this:

int nNumber = 1;

double dNumber =(double) nNumber;

This is not only way and it is still possible to do it in C++11, we could write it like this, as well: double(nNumber);

When you convert 8-bit to 16-bit data type, it could be done as there is enough space. When you convert 16-bit data type to 8-bit data type, there will be some loss. In that case, you’ll get a warning.

We have few advanced ways to achieve same result:

• static_cast
• const_cast
• dynamic_cast
• reinterpret_cast

The static_cast is used when you need to change the type of the variable.

If you are in a situation where you need to change the state of const object, you could use const_cast.

When you need to change the types of objects in manner of hierarchy with the respect to inheritance, you could use dynamic_cast.

If you try to change type of pointers, without respect to inheritance or classes being related, you could use reinterpret_cast.

The following example is for static_cast:

int    nNumber = 1788;
double dNumber = static_cast<double>(nNumber);

int nI=1,
    nJ=5;

double dResult1 = static_cast<double> (nI)/nJ;
double dResult2 = double(nI)/nJ;

It is possible to use static_cast with classes as shown below:

class CParent { ...//some code that goes in this class};
class CChild: public CParent { ...//some code that goes with this one};

CParent* ptrParent = new CParent;
CChild*  ptrChild  = static_cast< CChild*>(ptrParent);

But, why do we want to do the above?

For const cast, it changes something that is constant. Example for that could be the data type that is passed to function that expects some non constant data type.

Also, it could be used in the following situation.

const double dGravity = 9.81;

double *ptrGravity = const_cast<double*>(dGravity);

*ptrGravity = 10;

cout<<dGravity<<endl;

The dynamic cast will be used in situations where you have pointers or references to classes. Parent class should have one virtual function, and it gets done in run time. It is used for changing the type from CParent to CChiled and vice-versa.

CChild* ptrChild = dynamic_cast <CChild*> (ptrParent);

The following could be used with void pointers as well.

When we deal with reinterpret cast and objects, we need to be careful as it could also change types of non related classes.

class CSomeClass { ...//some code that goes in this class};
class COtherClass{ ...//some code that goes with this one};

CSomeClass*   ptrSC = new CSomeClass;
COtherClass*  ptrOC = reinterpret_cast< COtherClass*> (ptrSC);

If C++11 is supported, I would like to mention few new concepts.

When you are dealing with situation where you need to create the variable from the context of expression you could use the auto type as shown below:

auto aVariable = 11;
auto aVariable = 2.111719;
auto aVariable = ‘c';

The first aVariable will be int type, the second would be double and the third char.

If you need to figure out the type of the variable in C++11 you could use decltype as shown below:

decltype(someType) sameType;

Functions Used for Conversions

In the <stdlib.h> there are few interesting functions that could be used to convert data types:

• atof(charArray) will transform the array in style of C language into float.
• atoi(charArray) will transform the array of chars into the int.
• atol(charArray) performs the conversion into the long data type.
• from C99 there should be atoll.
• itoa(nNumber) should change int into the array of chars.

Those functions and few others are usually used in C style programming, but they still have place in C++ programs.

Overloading Operator Type() IN class

If you create a class, it could have overloaded operator (). So, if you need to use implicit conversion, it could be achieved with constructor that is used for initialization, and if you are having the problems with this, you could define explicit constructor, this would prevent the implicit conversion to happen.

Why would you prevent implicit conversion? Well there are situations in which you would not have expected results, to avoid that you just type explicit and the implicit conversion is prevented.

The explicit conversion, could be achieved with overloading of the operator(), which is the operator of casting.

The following example explains this from Object Orientated Programming point of view:

#include <iostream>

using namespace std;

class CKelvin
{
double dK;

public:
 CKelvin(double Celzijus=0)
{
 dK = Celzijus + 273.15;
}
operator double() { return dK;}

};

int
main(void)
{
  double dCelziusDegree;
  cout<<"Input the temperature in Celzius->";
  cin>>dCelziusDegree;

  CKelvin K(dCelziusDegree);

  cout<<"In Celzius it is="
  	<<double(K)-273.15
  	<<"In Kelvin it is="
  	<<endl
  	<<double(K)
  	<<endl;

  return EXIT_SUCCESS;
}