类构造函数的隐式转换

旧城等待， 2024-02-19 12:38 54阅读 0赞

在编程中，类型转换在所难免，在此我将介绍一下C++中常用的隐式转换和强制类型转换。

关于隐式转换：

在C++中，某些类型之间存在相关的依赖关系，若两种类型相关，则可以再需要某种类型的操作数位置上，使用该类型的相关类型对象或值。

C++并不是吧两个不同类型的值直接加在一起，而提供了一组转换规则，一边在执行算数操作之前，将两个操作数转换为同一种数据类型。这些转换规则由编译器自动执行，无需我们再介入。因此，也被成为隐式转换。

发生隐式转换的情况：

1.在混合类型的表达式中，其操作数被转换为相同类型。

2.用作条件的表达式（?:，!，&&，||，if，while，for，do while）被转换为bool类型。

3.用一表达式初始化某个变量，或将一表达式被转换为该变量的类型。

隐式转换类型：

1.指针转换：在使用数组时，大多数情况下数组都会自动转换为指向第一个元素的指针。

int ia\[10\];  
int \*ip = ia;  
C++还提供了另外两种指针转换：指向任意数据类型的指针都可以转换为void\*类型，整型数值常量0可转换为任意指针类型。

2.转换为bool类型：算数值和指针值都可以转换为bool类型。如果指针或算数值为0，则其bool值为false，而其他值则为true。

if (cp)  
while (\*cp)  
3.算术类型与bool类型的转换：可将bool对象转换为int型。true变为1，false则为0。

4.转换与枚举类型：C++自动将枚举类型的对象或枚举成员转换为整型，其转换结果可用于任何要求使用整数的地方。

5.转换为const对象：当使用非const初始化const对象的引用时，系统将非const对象转换为const对象。此外还可以将非const对象的地址转换为指向相关const类型的指针。

int i;  
const int ci = 0;  
const int &j = i;  
const int \*p = &ci;  
6.由标准库类型定义的转换：类类型可以定义由编译器自动执行的类型转换。

string s;  
while (cin >> s)  
其中使用了IO标准库定义的类型转换。

关于显示转换：

显示转换也成为强制类型转换，虽然有时候确实需要强制类型转换，但本质非常危险，应该尽量避免使用强制类型转换。

尽管不建议使用强制类型转换，但还是有一些情况需要使用：

因为要覆盖通常的标准转换，所以需要显示使用强制类型转换。例如：

double dval;  
int ival;  
ival \*= dval;  
这时，需要将ival转换为double型，然后将乘法操作的double型结截尾为int型，再赋值给ival。这样回事的其中多了ival转换为double型这个不必要的转换，则需要强制类型转换。

还有一个原因就是：可能存在多种转换时，需要选择一种特定的类型转换。

现在来讨论下命名的强制类型转换，具体格式如下：

cast-name<type> (expression);  
cast-name为命名的强制类型转换符号，type为转换的目标类型，expression为被强制转换的值。

1.dynamic\_cast

支持运行识别指针或引用所指向的对象。对dynamic\_cast的详细讨论将在下一篇（RTTI）详细解释。

2.const\_cast

顾名思义，就是将表达式的const属性转换掉。比如：

const char \*pc\_str;  
char \*pc = string\_copy(const\_cast<char \*>(pc\_str));  
只用使用const\_cast才能将const性质转换掉。在这种情况下，试图使用其他三种形式的强制转换都会导致编译时的错误。类似地，除了添加或者删除const特性，用const\_cast符来执行其他任何类型转换，都会引起编译错误。

3.static\_cast

编译器隐式执行的任何类型转换都可以由static\_cast显式完成。当要讲一个较大的算数类型复制给较小的类型时，使用强制类型转换非常重要。此时，相当于告诉编译器我们忽略精度的损失，警告信息当然也会被关闭。

当编译器不提供自动转换时，也可以用static\_cast来转换。

4.repinterpret\_cast

通常作为操作数的位模式提供较低层次的重新解释。（repinterpret\_cast本质上依赖于机器，但为了安全的使用它，我们必须理解所涉及的数据类型，以及编译器实现强制类型转换的细节。）例如：

int \*ip;  
char \*pc = reinterpret\_cast<cahr \*>(ip);  
此时通过转换后，pc实际上指向的对象是int型而非字符数组。

（注：我们在平时编程中还是最好避免使用强制类型转换，一面出现无法预测的错误。）

说到C++中的强制类型转换，还记得C中的强制类型转换：

type(expr);  
(type)expr;  
这两种强制类型转换在C++中仍然支持。支持C语言中的强制类型转换符号也是为了让C++保持与C语言的兼容性。

首先我们看下一种比较常见的技术——类构造函数的隐式转换。这儿先说明下，之后的例子中，我会为了尽量突出主要内容，而忽略一些可以作为充分条件但非必要条件的东西，故设计的一些代码存在“不完善”的嫌疑。因为为了堵住所有漏洞，往往会让整个代码让人感觉其重心并非在我想介绍的技术上，而在“苦行僧”式的编程原则上。

我们知道C++是一个类型严格的语言，比如下面一个函数

void test\_int\_proxy(const int\_proxy& v) \{  
printf("%d", v.value());  
\}  
调用者对其传参也应该是一个int\_proxy的对象，但是实际情况并非如此。那该如何表述，我个人觉得应该是：编译器对其传参应该是一个int\_proxy对象。这两种表述的区别就是“调用者”和“编译器”的区别。我们来看一个实际例子，我们先假定int\_proxy类这么定义：

class int\_proxy \{  
public:  
int\_proxy(int n) : \_m(n) \{\};  
public:  
int value() const \{  
return \_m;  
\}  
private:  
int \_m;  
\};  
该类非常简单，它有一个带参数的构造函数，并使用参数列表形式初始化类的成员变量。

一般情况下我们都会这么调用test\_int\_proxy方法：

test\_int\_proxy(int\_proxy(100));  
这种写法我想没人会有异议，但是如果出现下面这种写法，就可能让人感觉不可接受了：

test\_int\_proxy(100);  
然而，这种写法对上述类的定义来说是合法的！其效果和使用int\_proxy控制住是一样的。这是为什么呢？这便是类构造函数的隐式转换技术。C++编译器认为test\_int\_proxy方法传入的应该是一个const类型的int\_proxy对象，然而如果它发现参数不是该对象时，就会使用该类中可以使用该参数进行构造对象的方法构造出一个临时的对象。我们例子中传参100是个int型数据，而int\_proxy正好有一个携带int参数的构造函数。稍微总结下类构造函数隐式转换的必要条件：

找不到传参类型严格对应的函数  
找到传参类型严格匹配的类的构造函数  
因为隐式转换构造出的是临时对象，所以不可修改，故触发隐式转换的函数的传参类型必须要使用const修饰  
但是个人觉得这种“奇巧淫技”还是不用为好。比如我们代码中还有如下函数：

void test\_int\_proxy(const int& v) \{  
printf("%d", v + 100);  
\}  
那么C++编译器会针对传100的调用上面这个过程。这样一个函数调用有两个匹配的调用方法就会产生不确定性——这儿指的不确定性并非是指编译器调用哪个方法的不确定性，而是指维护这段代码的人对上述代码做调整时容易忽略一些问题而导致的“人祸”。

再比如，我们在代码中加入下面类和方法

class int\_proxy\_2 \{  
public:  
int\_proxy\_2(int n) : \_m(n) \{\};  
public:  
int value() const \{  
return \_m + 100;  
\}  
private:  
int \_m;  
\};  
  
void test\_int\_proxy(const int\_proxy\_2& v) \{  
printf("%d", v.value());  
\}  
那么编译器不能确定隐式转换是要转换哪个类，更不知道是调用哪个test\_int\_proxy方法了。

限制类构造函数的隐式转换的方法也很简单，就是给对应的构造函数加上explict关键字

class int\_proxy \{  
public:  
explicit int\_proxy(int n) : \_m(n) \{\};  
这样通过隐式转换而构造临时对象的图谋将会被察觉并禁止。