A Cast operator is an unary operator which forces one data type to be converted into another data type.
C++ supports four types of casting:
1. Static Cast
2. Dynamic Cast
3. Const Cast
4. Reinterpret Cast
Static Cast: This is the simplest type of cast which can be used. It is a compile time cast.It does things like implicit conversions between types (such as int to float, or pointer to void*), and it can also call explicit conversion functions (or implicit ones).
For e.g.
#include <iostream>
using
namespace
std;
int
main()
{
float
f = 3.5;
int
a = f;
int
b =
static_cast
<
int
>(f);
cout << b;
}
Output:
3
Now let’s make a few changes in the code.
#include <iostream>
using
namespace
std;
int
main()
{
int
a = 10;
char
c =
'a'
;
int
* q = (
int
*)&c;
int
* p =
static_cast
<
int
*>(&c);
return
0;
}
If you compile the code, you will get an error:
[Error] invalid static_cast from type 'char*' to type 'int*'
This means that even if you think you can some how typecast a particular object int another but its illegal, static_cast will not allow you to do this.
Lets take another example of converting object to and from a class.
#include <iostream>
#include <string>
using
namespace
std;
class
Int {
int
x;
public
:
Int(
int
x_in = 0)
: x{ x_in }
{
cout <<
"Conversion Ctor called"
<< endl;
}
operator string()
{
cout <<
"Conversion Operator"
<< endl;
return
to_string(x);
}
};
int
main()
{
Int obj(3);
string str = obj;
obj = 20;
string str2 =
static_cast
<string>(obj);
obj =
static_cast
<Int>(30);
return
0;
}
Run the above code:
Conversion Ctor called Conversion Operator Conversion Ctor called Conversion Operator Conversion Ctor called
Lets the try to understand the above output:
- When obj is created then constructor is called which in our case is also a Conversion Constructor(For C++14 rules are bit changed).
- When you create str out of obj, compiler will not thrown an error as we have defined the Conversion operator.
- When you make
obj=20
, you are actually calling the conversion constructor. - When you make str2 out of static_cast, it is quite similar to
string str=obj;
, but with a tight type checking. - When you write
obj=static_cast<Int>(30)
, you are converting 30 into Int using static_cast.
Lets take example which involves Inheritance.
#include <iostream>
using
namespace
std;
class
Base {
};
class
Derived :
public
Base {
};
int
main()
{
Derived d1;
Base* b1 = (Base*)(&d1);
Base* b2 =
static_cast
<Base*>(&d1);
return
0;
}
The above code will compile without any error.
- We took address of
d1
and explicitly casted it intoBase
and stored it inb1
. - We took address of
d1
and used static_cast to cast it intoBase
and stored it inb2
.
As we know static_cast performs a tight type checking, let’s the changed code slightly to see it:
#include <iostream>
using
namespace
std;
class
Base {
};
class
Derived :
private
Base {
};
int
main()
{
Derived d1;
Base* b1 = (Base*)(&d1);
Base* b2 =
static_cast
<Base*>(&d1);
return
0;
}
Try to compile the above code, What do you see?? Compilation Error!!!!!!!
[Error] 'Base' is an inaccessible base of 'Derived'
The above code will not compile even if you inherit as protected. So to use static_cast, inherit it as public.
Use static_cast to cast ‘to and from’ void pointer.
#include <iostream>
int
main()
{
int
i = 10;
void
* v =
static_cast
<
void
*>(&i);
int
* ip =
static_cast
<
int
*>(v);
return
0;
}
My Personal Notes
arrow_drop_up