C++ Casting Operators and traditional C casting operators

 

Possible Duplicate:
When should static_cast, dynamic_cast and reinterpret_cast be used?

I have done a lot of googling to find about:

  • why to use C++ casting operators over traditional C style casting operators?
  • When to use C++ casting operators, some live examples?

    • The following is what I found:

  • Traditionally any C++ casting operators is used for better maintenance of your code (ie) we can easily find where casting is used in code by just searching for this complex notation (reinterpret_cast<) unlike C style casting operators.

    • Now let me brief state why and when for each of the C++ casting operators

    static_cast:

    Why use it over C style casting? static_cast is used to perform conversion between related types.

    Examples : 

     Class A {};
 Class B {};

 A* a = new A();
 B* b = static_cast<B*>(a); // Compiler error
 B* b1 = (A*)a;  // Works fine
 float f;
 int addr = (int)(&f); // Works fine
 int addr = static_cast<int>(&f);  // Compiler error

    But I wanted to know a real use case of when to use above code?

    reinterpret_cast :

    reinterpret_cast casts pointers to unrelated types.

    Examples: 

     Class A {};
 Class B {};

 A* a = new A();
 B* b = reinterpret_cast<B*>(a); // Works fine
 B* b1 = (A*)a;  // Works fine
 float f;
 int addr = (int)(&f); // Works fine
 int addr = reinterpret_cast<int>(&f);  // Works fine


 int ai = 10;
 float af = 13.33;
 // Would depend on how floating point is stored in machine
 // int& since reinterpret_cast expects either the type or operand to be pointer or reference 
 int ki = reinterpret_cast<int&>(af); // ki would not be 13
 int kitemp = (int)af; // kitemp would be 13

 // The same reinterpret_cast behaviour can be achieved using this,
 int* in = (int*)(af);
 cout << (*in);

    My question is how else is reinterpret_cast different from C style casting? I'm unable to find why to use it over traditional casting operators and also when to use it?

    Another important example which makes these operators worse is: 

       const unsigned int * p;
   (int*)p; // Would remove unsigned and const at one shot
   // Using C++ casting operators
   // Const_cast expects a pointer or a reference
   reinterpret_cast<int*>(const_cast<unsigned int* >(p));

    Writing the above code to remove const and unsigned is much more complex in C++ casting? Then why do people use reinterpret_cast , const_cast or static_cast over tradional C casting operators?

    I do understand about dynamic_cast used in case of polymorphic classes; again this operator too has an extra cost of RTTI.

    Google's C++ Style Guide gives some motivation for using the C++ style casts:

    The problem with C casts is the ambiguity of the operation; sometimes you are doing a conversion (eg, (int)3.5 ) and sometimes you are doing a cast (eg, (int)"hello" ); C++ casts avoid this. Additionally C++ casts are more visible when searching for them.

    I like the C++ casts because they make what you're intending to do very explicit, allowing the compiler to catch incorrect usage.

    For example, if you know you intend to only do a numeric conversion to an integer, static_cast will only compile when that numeric conversion makes sense. As you showed in your example code, the C style casts will perform a cast regardless of the validity.

    The C++ casts are really just for better documentation of intentions, and compile-time protection against unintended usage.

    It's bad practice to remove the const qualifier. You will probably end up writing to a variable or region of memory that you are not supposed to write to. So that invalidates that part of your question.

    From my memory, reinterpret_cast is pretty much the same thing as c style cast except i think if you have a const Thing you cant reinterpret_cast to noncost_other_thing (c stye lets you remove them which may not be intentional and is likely dangerous).

    I only use c casting in my own projects because i have the luxury of being lazy and sometimes i dont be lazy. You are 'suppose' to use C++ style casting and other C++ features (ostream rather then file, no printfs, avoid memset and other unsafe functions, etc) when using C++. But most people just do whatever they want (and get the bugs because of it).

    Typically if you know when to use dynamic_cast and static cast you'll be fine. I find reinterpret_cast not likely unless i am interfacing with C and need to work with void*. const_cast... i actually never use and hope i will never need to. And you 'should' use them always.

    PS: Unrelated note. I actually throw exception and assert(0) on unimplemented things. If i dont handle a param and expect it to be a 0 i'll write an exception or assert to check that. When i debug/add more code i run into these instead of bugs and theres absolutely no mystery on why it happened :)

    链接地址: http://www.djcxy.com/p/28698.html

    上一篇: 不需要执行运行

    下一篇: C ++铸造操作员和传统的C铸造操作员