C++的转换手段并与explicit关键词配合使用

前言

C 中我们会进行各种类型的强制转化，而在 C 中我们经常可以看到这种转换：

  memset(OTA_FLAG_ADDRESS,(uint8_t*)&OTA_Flag,sizeof(OTA_Flag));

而 C++的类型转化和 C 差别很多，那么 C++里面的类型转化是怎么用的呢。C++除了隐式转换和显示转化，显示转化是我们熟知，有四个显示转化函数：static_cast、dynamic_cast、const_cast、reinterpret_cast，主要运用于继承关系类间的强制转化。

下面我就给大家说道说道。

隐式转化

c++语言不会直接将两个不同类型的值相加，二十先根据类型转化规则设法将运算对象的类型统一后再求值。例如 int value = 3.14 +3;这个程序是可以编译通过的，只不过编译器可能会警告改运算损失了精度。这样的类型转化是自动运行，无需程序员介入，因此，它们被称为隐式转换。

何时会发生隐式转化：

在下面的情况中，编译器会自动的转化运算对象的类型：

在大多数表达式中，需要将比 int 类型小的整型值首先提升到较大的整数类型会进行隐式转化；

在条件中，非布尔值转换成布尔类型；

初始化过程中，初始值转化成变量的类型；在赋值语句中，右侧运算对象转化成左侧运算对象的类型；

函数调用时候也会发生类型转化（实参类型转化）。

显示转化

C 风格的强制转换(Type Cast)容易理解,不管什么类型的转换都可以使用使用下面的方式

Type b = (Type)a;

当然,C++也是支持 C 风格的强制转换,但是 C 风格的强制转换可能带来一些隐患,让一些问题难以察觉 . 所以 C++提供了一组可以用在不同场合的强制转换的函数 .

C++提供了四种强制类型转化的函数，分别是：

static_cast，命名上理解是静态类型转换。大部分 C 实现的转化，用这个函数就可以了。

const_cast，字面上理解就是去 const 属性。
dynamic_cast，命名上理解是动态类型转换。如子类和父类之间的多态类型转换。
reinterpret_cast，仅仅重新解释类型，但没有进行二进制的转换。

static_cast：

任何具有明确定义的类型转化，只要不包含底层 const，都可以使用 static_cast,举一个例子。

double slop = static_cast(j) / i;// 进行强制转化成 doubleint*pn =&n;double*dp = static_cast(&pn) // 无关类型指针转换，编译错误 void*p = &n; double*d = static_cast(&p) // 将 void*转化为初始的指针类型

‍

static_cast 强制转换只会在编译时检查，但没有运行时类型检查来保证转换的安全性。同时，static_cast 也不能去掉 expression 的 const、volitale、或者 __unaligned 属性。

const_cast：

const_cast<>可以实现将 const 指针类型转普通指针,const_cast 操作不能在不同的种类间转换。相反，它仅仅把一个它作用的表达式转换成常量。它可以使一个本来不是 const 类型的数据转换成 const 类型的，或者把 const 属性去掉。如果一个对象本身不是一个常量，使用强制类型转化获得写权限是合法的行为。然而如果对象是一个常量，再使用 const_cast 执行写操作就会产生未定义的后果。

只有 const_cast 能改变表达式的常量属性，使用其他形式的命名强制类型转化改变表达式的常量属性都将引发编译器错误。同样的，也不能用 const_cast 改变表达式的类型：

const char *cp;
char *q = static_cast(cp);// 错误：static_cast 不能转换掉 const 性质static_cast(cp);// 正确：字符串字面值转换成 string 类型const_cast(cp);// 错误：const_cast 只改变常量属性const_cast(cp);// 正确const int p = 0;int &rb = const_cast(p);// 正确rb =10;

dynamic_cast：

1. 其他三种都是编译时完成的，dynamic_cast 是运行时处理的，运行时要进行类型检查。

2. 不能用于内置的基本数据类型的强制转换。

3.dynamic_cast 转换如果成功的话返回的是指向类的指针或引用，转换失败的话则会返回 NULL。

4. 使用 dynamic_cast 进行转换的，基类中一定要有虚函数，否则编译不通过。可以从父类转基类，但是可能为空

5. 在类的转换时，在类层次间进行上行转换时，dynamic_cast 和 static_cast 的效果是一样的。在进行下行转换时，dynamic_cast 具有类型检查的功能，比 static_cast 更安全。向上转换即为指向子类对象的向下转换，即将父类指针转化子类指针。向下转换的成功与否还与将要转换的类型有关，即要转换的指针指向的对象的实际类型与转换以后的对象类型一定要相同，否则转换失败。

class BaseClass { public:    int Num;    virtualvoid foo(){}; // 基类必须有虚函数。保持多台特性才能使用 dynamic_cast  }; DerivedClass: public BaseClass { public:   char*m_szName[100];  void bar(){};};int main(int argc,char** argv){  BaseClass* pb =new DerivedClass();  DerivedClass *pd1 = static_cast(pb); // 子类 ->父类，静态类型转换，正确但不推荐  DerivedClass *pd2 = dynamic_cast(pb); // 子类 ->父类，动态类型转换，正确  BaseClass* pb2 =new BaseClass();  DerivedClass *pd21 = static_cast(pb2); // 父类 ->子类，静态类型转换，危险！访问子类 m_szName 成员越界  DerivedClass *pd22 = dynamic_cast(pb2); // 父类 ->子类，动态类型转换，安全的。结果是 NULL

reinterpret_cast：

实现指针转整形，整形转指针 .reinterpret_cast 是强制类型转换符用来处理无关类型转换的，通常为操作数的位模式提供较低层次的重新解释！但是它仅仅是重新解释了给出的对象的比特模型，并没有进行二进制的转换！

它是用在任意的指针之间的转换，引用之间的转换，指针和足够大的 int 型之间的转换，整数到指针的转换。最普通的用途就是在函数指针类型之间进行转换。

请看一个简单代码

int doSomething(){return 0;};typedef void(*FuncPtr)(); //FuncPtr is 一个指向函数的指针，该函数没有参数，返回值类型为 voidFuncPtr funcPtrArray[10]; //10 个 FuncPtrs 指针的数组 让我们假设你希望（因为某些莫名其妙的原因）把一个指向下面函数的指针存入 funcPtrArray 数组：funcPtrArray[0] =&doSomething;// 编译错误！类型不匹配，reinterpret_cast 可以让编译器以你的方法去看待它们：funcPtrArrayfuncPtrArray[0] = reinterpret_cast(&doSomething); // 不同函数指针类型之间进行转换

explicit 关键字（显示的类型转化运算符）

C++提供了关键字 explicit，可以阻止不应该允许的经过转换构造函数进行的隐式转换的发生。即声明为 explicit 的构造函数不能在隐式转换中使用。

explicit 关键字只能用于类内部的构造函数声明上，而不能用在类外部的函数定义上。现在 Things 类像这样：

class Things{public:   Things(const std::string&name ="")；     explicit operator int() const{return val;}     // 编译器不会自动执行这一类型的};

下面再看个好一点的例子进行对比一下：

// 类的通过构造函数的隐式转换:#include using namespace std;
class A {};
class B {public:  // conversion from A (constructor):  B (const A& x) {}  // conversion from A (assignment):  B& operator= (const A& x) {return *this;}  // conversion to A (type-cast operator)  operator A() {return A();}};
int main (){  A foo;  B bar = foo;    // 调用构造函数实现隐式类型转换  bar = foo;      // calls assignment  foo = bar;      // calls type-cast operator，相当于 foo = A(bar);  return 0;}

再看使用 explicit 的一个例子：

#include using namespace std;
class A {};
class B {public:  explicit B (const A& x) {}  B& operator= (const A& x) {return *this;}  operator A() {return A();}};
void fn (B x) {}  // 当我们希望 x 只能是 B 类型时，我们就需要禁止隐式类型转换
int main (){  A foo;  B bar (foo);  // 必须显式类型转换，不再允许 B bar = foo;   bar = foo;  foo = bar;
//  fn (foo);  // 不允许隐式类型转换  fn (bar);  
  return 0;}