static_cast and dynamic_cast in C++

In this tutorial, we will learn about static_cast and dynamic_cast in C++.

We know that, in C++, we can assign one variable to another of the same type. But what happens if the data type of both the variables is different. In such a case, implicit type conversion would take place. It means the conversion of one data type to another. This typecasting may or may not be implicitly supported in C++. If it is not supported, then we need to make use of casting methods available in C++. So, there are four explicit type casting methods available in C++. They are – static_cast, const_cast, reinterpret_cast and dynamic_cast.

In this tutorial, we will focus only on static_cast and dynamic_cast.

static_cast: C++

static_cast is the simplest one of all the cast. static_cast simply performs implicit conversions between types.
Let us see an example to understand this.

#include<iostream>
using namespace std;
int main()
{
  float f = 6.4;
  int i,j;
  i = f;      //implicit type conversion from float to int 
  j = static_cast<int>(f);
  cout<<i<<"\n"<<j;
  
}

OUTPUT:

6
6

Here, float data type is being converted to integer value.  So, basically line no 7 and 8 is doing the same thing. Then, what is the difference.
Suppose if the program is failing somewhere and we want to check where the implicit cast is being done, searching line 7 in the whole bunch of code is a tideous task. That is why, we use static_cast in such a case as it can be searched easily.
static_cast happens at compile time. In the program, it checks whether we can typecast ‘ f ‘, which is of float type into ‘a’, which is of integer type.

Now, let us see dynamic_cast.

Dynamic _cast: C++

In C++, a derived class reference/pointer can be treated as a base class pointer. This is called upcasting in C++. The opposite process, called downcasting, is not allowed in C++.  So, dynamic_cast is used to promote safe downcasting in C++. It is always performed with polymorphic classes having at least one virtual function inside the class.

Let us see an example.

#include<bits/stdc++.h>
using namespace std;
class base
{
  public:
    virtual void car()
    {
      cout<<"base";
      }
};
class derived:public base
{
  public:
    void gun()
    {
      cout<<"derived";
      }
};
int main()
{
  base *b = new derived;
  derived *d;
  d=b; 			 //base class pointer assigned to the derived class pointer
  d->gun();
}

The above code will show an error as base class pointer is getting assigned to the derived class pointer (downcasting). To make downcasting possible in C++, we need to rewrite the code using dynamic_cast.

#include<bits/stdc++.h>
using namespace std;
class base
{
  public:
    virtual void car()
    {
      cout<<"base";
      }
};
class derived:public base
{
  public:
    void gun()
    {
      cout<<"derived";
      }
};
int main()
{
  base *b = new derived;
  derived *d;
  d=dynamic_cast<derived*>(b);      //to promote downcasting
  cout<<d<"\n";
  d->gun();
}

OUTPUT:

0x161820
derived

This is how we can implement static_cast and dynamic_cast in C++.

Also read: PI Constant in C++