static_cast in C++ | Type Casting operators
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; // this is how you do in C 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' ; // pass at compile time, may fail at run time 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); // allowed 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 { // Inherited private/protected not public }; int main() { Derived d1; Base* b1 = (Base*)(&d1); // allowed 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; } |
Please Login to comment...