CODEWITHSUNDEEP
c++
user380731
user380731

Reputation: 89

What are the benefits of explicit type cast in C++?

What are the benefits of explicit type cast in C++ ?

Upvotes: 1

Views: 2430

Answers (5)

Johannes Schaub - litb
Johannes Schaub - litb

Reputation: 506925

Notice that all typecasts are explicit in C++ and C. There are, in the language, no "implicit" typecasts. It's called "implicit conversions" and "explicit conversions", the latter of which are also called "casts".

Typecasts are most often used to inhibit warnings by the compiler. For instance if you have a signed and an unsigned value and compare them, the compiler usually warns you. If you know the comparison is correct, you can cast the operands to a signed type.

Another example is overload resolution, where type casts can be used to drive to the function to be called. For example to print out the address of a char, you can't just say cout << &c because that would try to interpret it as a C-Style String. Instead you would have to cast to void* before you print.

Often implicit conversions are superior to casts. Boost provides boost::implicit_cast to go by implicit conversions. For example the following relies on the implicit conversions of pointers to void*

cout << boost::implicit_cast<void*>(&c);

This has the benefit that it's only allowing conversions that are safe to do. Downcasts are not permitted, for example.

Upvotes: 1

Akaanthan Ccoder
Akaanthan Ccoder

Reputation: 2179

Sometimes explicit casting avoids certain undesirable cirumstances by using explicit keyword.

class ExplicitExample
{
public:
    ExplicitExample(int a){...}
}


ExplicitExample objExp = 'A';//No error.. call the integer constructor

Change as 

explicit ExplicitExample(int a){ ... }

Now compile.

ExplicitExample objExp = 'A';

We get this error in VS2005. error C2440: 'initializing' : cannot convert from 'char' to 'ExplicitExample' Constructor for class 'ExplicitExample' is declared 'explicit'

To overcome this error, we have to declare as 

ExplicitExample objExp = ExplicitExample('A');

It means as a programmer, we tell the compiler we know what we are calling. So compiler ignores this error.

Upvotes: 0

Boojum
Boojum

Reputation: 6692

  1. They're more specific than the full general C-style casts. You don't give up quite as much type safety and the compiler can still double check some aspects of them for you.

  2. They're easy to grep for if you want to try clean up your code.

  3. The syntax intentionally mimics a templated function call. As a a result, you can "extend" the language by defining your own casts (e.g., Boost's lexical_cast).

Upvotes: 8

Keith Nicholas
Keith Nicholas

Reputation: 44288

often used on void* to recover a implicitly known type. Especially common on embedded OS's for callbacks. This is a case where when you register for an event and maybe pass your "this" pointer as a context void*, then when the triggers it will pass you the void * context and you covert it back to the type the "this" pointer was.

Upvotes: 0

John Weldon
John Weldon

Reputation: 40749

Clarity in reading the code. There is not too much else of benefit, except for the cases where the compiler cannot infer the implicit cast at all, in which case you'd have to cast explicitly anyway.

The recommended way to cast in c++ is through dynamic_cast, static_cast, and the rest of those casting operators:

http://www.cplusplus.com/doc/tutorial/typecasting/

Upvotes: 1

Related Questions