C++ C++;Casting操作符和传统的C Casting操作符

C++ C++;Casting操作符和传统的C Casting操作符,c++,casting,C++,Casting,可能重复: 我在谷歌上搜索了很多关于: 为什么要使用C++的铸造操作符来代替传统的C型铸造操作符? 何时使用C++的浇铸操作符,一些活的例子? 以下是我的发现: 传统上,任何C++的C++操作符都用于更好地维护代码(IE),我们可以很容易地找到在代码中使用CARS的方法,只要查找这个复杂的符号(RealTrExtCase)就可以给出使用C++样式表的一些动机: C类型转换的问题在于操作的模糊性;有时 您正在进行转换(例如,(int)3.5),有时您正在进行转换 执行一个强制转换(例如,(in

可能重复:

我在谷歌上搜索了很多关于:

为什么要使用C++的铸造操作符来代替传统的C型铸造操作符?<李>
  • 何时使用C++的浇铸操作符,一些活的例子?
  • 以下是我的发现:

      传统上,任何C++的C++操作符都用于更好地维护代码(IE),我们可以很容易地找到在代码中使用CARS的方法,只要查找这个复杂的符号(RealTrExtCase

      )就可以给出使用C++样式表的一些动机:

      C类型转换的问题在于操作的模糊性;有时 您正在进行转换(例如,
      (int)3.5
      ),有时您正在进行转换 执行一个强制转换(例如,<代码>(int)”hello“”;C++强制避免使用此方法。 C++的搜索在搜索时更为明显。 <>我喜欢C++的转换,因为它们使你想要做的非常明确,允许编译器捕获错误的用法。 例如,如果您知道只想将数值转换为整数,
      static\u cast
      仅在该数值转换有意义时才会编译。正如您在示例代码中所示,C样式的强制转换将执行强制转换,而不管其有效性如何


      < > C++的演播室实际上是为了更好地记录意图,以及编译时保护以防止意外使用。

      删除const限定符是一个错误的做法。你可能会写到一个不应该写入的变量或内存区域。这样就可以使你的问题无效。

      我的记忆中,重新解释与c风格的转换几乎是一样的,除了我认为如果你有一个常量,你不能重新解释为非常量的转换(c风格允许你删除它们,这可能不是故意的,可能是危险的)

      <>我只在自己的项目中使用C铸造,因为我有懒惰的优点,有时我不懒惰。在使用C++时,你可以假设使用C++风格的铸造和其他C++特性(OFSUAM,而不是文件,没有打印文件,避免MyStand和其他不安全的功能等),但是大多数人只是做他们想做的任何事情。(并因此而得到bug)

      通常情况下,如果你知道何时使用动态和静态转换,你会很好。我发现重新解释转换不太可能,除非我与C交互,并且需要使用void*.const\u cast…我实际上从未使用过,希望我永远也不需要。而且你“应该”始终使用它们


      PS:不相关的注释。我实际上在未实现的东西上抛出异常和断言(0)。如果我不处理一个参数,并期望它是一个0,我将编写一个异常或断言来检查它。当我调试/添加更多代码时,我会遇到这些错误,而不是bug,并且完全没有什么神秘的原因:)

      C++Cases是C++风格的强制版本,它几乎每一个演员都会尝试,直到找到一个有效的。当你想要某种类型的转换发生时,你应该使用C++风格的转换,如果不能发生这种转换,编译失败。casts@Mat:从你建议的链接中,我了解了很多。但我有一个疑问,你如何将这种类型的示例映射到C样式的cast,float a=13.33;int b=reinterpret_cast(a);…请让我理解this@RishiMehta当前位置我不知道演员阵容是什么意思。你为什么要写这样的“东西”它会给出大小为13.33的位值。它也被称为联合黑客。更多细节,请参阅…链接确实值得学习…但是你能帮助我使用C++的CAST真的有用吗?我给我的答案加了一点。这有帮助吗?如果你有更多的问题,我可以给出更确切的例子。
       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
      
       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);
      
         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));