C的类型准换

c类型转换：

隐式类型转换： 比如：double f = 1.0 / 2; 显示类型转换： （类型说明符)(表达式) 比如：double f = double(1) / double(2);

c类型转换的问题：

1.任意类型之间都可以转换，编译器无法判断起准确性 2.难于定位：在源码中无法快速定位

C++的类型转化

const_cast

用于转换指针或引用，去掉类型的const属性

  1. int main(){
  3.     //c++ const转换
  4.     const int a = 10;
  5.     int *pA = const_cast<int *>(&a);
  6.     *pA = 100;
  8.     return 0;
  9. }

reinterpret_cast

重新解释类型，既不检查指向的内容，也不检查指针类型本身;但要求转换前后的类型所占用内存大小一致，否则将引发编译时错误。

  1. int Test()
  2. {
  3.     cout << "reinterpret_cast test" <<endl;
  4.     return 0;
  5. }
  7. int main(){
  9.     //c++ reinterpret_cast转换
  10.     typedef void(*FuncPtr)();
  11.     FuncPtr funcPtr;
  13. //    funcPtr = &Test;
  14.     funcPtr = reinterpret_cast<FuncPtr>(&Test);
  15.     funcPtr();
  17.     return 0;
  18. }

static_cast

用于基本类型转换，有继承关系类对象和类指针之间转换，由程序员来确保转换是安全的，它不会产生动态转换的类型安全检查的开销;

  1. int main(){
  3.     //c++ static_cast转换
  4.     int ii = 5;
  5.     double d = static_cast<double >(ii);
  7.     return 0;
  8. }

dynamic_cast

只能用于含有虚的数的类，必须用在多态体系中，用于类层次间的向上和向下转化;向下转化时，如果是非法的对于指针返回NULL;

  1. #include <iostream>
  2. #include <string>
  4. using namespace std;
  6. class Base
  7. {
  8. public:
  9.     Base() : _i(0) { ; }
  10.     virtual void T() { cout << "Base:T" << _i << endl; }
  11. private:
  12.     int _i;
  13. };
  15. class Derived : public Base
  16. {
  17. public:
  18.     Derived() :_j(1) { ; }
  19.     virtual void T() { cout << "Derived:T" << _j << endl; }
  21. private:
  22.     int _j;
  23. };
  25. int main(){
  27.     //dynamic_cast转换
  28.     Base cb;
  29.     Derived cd;
  30.     Base* pcb;
  31.     Derived* pcd;
  33.     // 子类--》 父类
  34.     pcb = static_cast<Base*>(&cd);
  35.     if (pcb == NULL)
  36.     {
  37.         cout << "unsafe static_cast from Derived to Base" << endl;
  38.     }
  39.     pcb = dynamic_cast<Base*>(&cd);
  40.     if (pcb == NULL)
  41.     {
  42.         cout << "unsafe dynamic_cast from Derived to Base" << endl;
  43.     }
  45.     // 父类--》 子类
  46.     pcd = static_cast<Derived*>(&cb);
  47.     if (pcd == NULL)
  48.     {
  49.         cout << "unsafe static_cast from Base to Derived" << endl;
  50.     }
  51.     pcd = dynamic_cast<Derived*>(&cb);
  52.     if (pcd== NULL)
  53.     {
  54.         cout << "unsafe dynamic_cast from Base to Derived" << endl;
  55.     }
  57.     return 0;
  58. }

void*, NULL, nullptr

  1. //◆在C语言中:
  2.   #define NULL ((void *)0)
  3. //◆在C++语言中:
  4.   #ifndef NULL
  5.       #ifdef_ cplusplus
  6.          #define NULL 0
  7.       #else
  8.          #define NULL ((void *)0)
  9.       #endif
  10. //◆在C++11中，nullptr用来替代(void*)0, NULL则只表示0；
  1. #include <iostream>
  2. #include <string>
  4. using namespace std;
  6. void func(void* i)
  7. {
  8.     cout << "func(void* i)" << endl;
  9. }
  10. void func(int i)
  11. {
  12.     cout << "func(int i)" << endl;
  13. }
  15. int main()
  16. {
  17.     int* pi = NULL;
  18.     int* pi2 = nullptr;
  19.     char* pc = NULL;
  20.     char* pc2 = nullptr;
  21.     func(NULL);                   // func(int i)
  22.     func(nullptr);                 // func(void* i)
  23.     func(pi);                         // func(void* i)
  24.     func(pi2);                       // func(void* i)
  25.     func(pc);                        // func(void* i)
  26.     func(pc2);                      // func(void* i)
  28.     return 0;
  29. }