static_cast(foo) vs. (int)foo

Question

Could somebody please elaborate on the differences?

Answer 1

The difference is that (int)foo can mean half a dozen different things. It might be a static_cast (convert between statically known types), it might be a const_cast (adding or removing const-ness), or it might be a reinterpret_cast (converting between pointer types)

The compiler tries each of them until it finds one that works. Which means that it may not always pick the one you expect, so it can become a subtle source of bugs.

Further, static_cast is a lot easier to search for or do search/replace on.

Answer 2

(int) foo compares most to c++ reinterpret_cast<int>, i.e. no checks on the validity of the cast.

Answer 3

Look at what Stroustrup has to say about that, including the following:

Because the C-style cast (T) can be used to express many logically different operations, the compiler has only the barest chance to catch misuses. [...]

The "new-style casts" were introduced to give programmers a chance to state their intentions more clearly and for the compiler to catch more errors. [...]

In particular, C++ makes the distinction between static_cast and reinterpret_cast:

The idea is that conversions allowed by static_cast are somewhat less likely to lead to errors than those that require reinterpret_cast. In principle, it is possible to use the result of a static_cast without casting it back to its original type, whereas you should always cast the result of a reinterpret_cast back to its original type before using it to ensure portability.