is static_cast and (int) the same thing?

The problem is that () type casting can mean a million different things that you don’t even guess, depending on the context.

First, it performs the conversion of arithmetic types. If you need an int from double , it calculates the integer part. If you need a char from long , it discards significant digits.

Second, it drops the const and volatile specifiers. Unnoticed by you.

Third, it converts an int to a pointer and vice versa.

Fourth, it translates pointers up and down along the inheritance hierarchy.

Fifth, it converts pointers as reinterpret_cast , focusing on the bit representation.

In contrast, static_cast does only the conversion of arithmetic types (for arithmetic types) and the conversion of up and down pointers along the inheritance hierarchy (for pointers). [You can still bring completely “unfamiliar” types to each other in two steps, through void* , but this must already be done explicitly and cannot be done by mistake. Here is the complete list of rules .]

In many cases, you don't need the insane power of the () cast, because it can hide errors. Examples:

 void f(char *str); void g(const _TCHAR *txt) { f((char*)txt); // компилируется f(static_cast<char*>(txt)); // не компилируется } 

Here, the call most likely should not compile because the f function expects a one-byte string, and is probably not ready to work with wchar_t* . If the function f can work with such strings, you can use reinterpret_cast . For the case of () -quot, you do not have the ability to distinguish between these cases.

 void f(char *str); void g(const char *txt) { f((char*)txt); // компилируется f(static_cast<char*>(txt)); // не компилируется } 

Here again, the call should not be compiled, because the function f has the right to modify the string, and the characters in txt cannot be modified.

Of course, in such simple examples, the problem is visible "to the naked eye." But if the function g is a pattern, and the exact type of txt unknown at the point of the function definition, it is much more difficult for you to catch such errors. In this case, static_cast will allow static_cast to catch them at compile time, without causing the program to crash.

An expression of the form (T) described in chapter 5.4 Explicit type conversion (cast notation) [expr.cast] .

It tries the following transformations in turn.

• const_cast
• static_cast
• static_cast and then const_cast
• reinterpret_cast
• reinterpret_cast and then const_cast

At the same time, static_cast removes the restriction on the visibility of the base class during conversions between pointers / references to descendants and base classes. (And also when converting between pointers to members of classes).

 class Base {}; class Derived : private Base {}; Derived* d = new Derived(); //static_cast<Base*>(d); // не скомпилируется: Base недоступна (private) Base* b = (Base*)d; // OK //static_cast<Derived*>(b); // не скомпилируется: Base недоступна (private) Derived* d2 = (Derived*)b; // OK 

If several transformations are possible at the same time, the code will not compile. (For example, in the case of multiple inheritance, there may be two base classes with the same type)

You can convert incomplete class types. At the same time, the standard does not indicate which caste will be made, static_cast or reinterpret_cast .

 struct X; struct Y; X* blind_cast(Y* y) { //return static_cast<X*>(y); // не скомпилируется: неполные типы return (X*)y; // OK } 

If we define these types

 struct Base1 { int some; }; struct X {}; struct Y : Base1, X {}; 

That expression static_cast<X*>(y) == blind_cast(y) can be either true or false :

• if at the time of code generation the compiler sees the full type definitions, then it will make static_cast ,
• if blind_cast compiled separately, then the compiler does not see the full type definitions and does a reinterpret_cast , then the blind_cast result will actually point to Base1 , and the comparison Base1 false .