C++ 语言隐式的类类型转换 - explicit 构造函数

悠悠 2022-09-07 06:40 238阅读 0赞

#  C++ 语言隐式的类类型转换 - explicit 构造函数 #

**如果构造函数只接受一个实参，则它实际上定义了转换为此类类型的隐式转换机制，我们把这种构造函数称作转换构造函数 (converting constructor)。**能通过一个实参调用的构造函数定义了一条从构造函数的参数类型向类类型隐式转换的规则。

**转换构造函数 (converting constructor) 可以用一个实参调用的非显式构造函数。这样的函数隐式地将参数类型转换成类类型。**

在 `Sales` 类中，接受 `std::string` 的构造函数和接受 `std::istream` 的构造函数分别定义了从这两种类型向 `Sales` 隐式转换的规则。在需要使用 `Sales` 地方，我们可以使用 `std::string` 或者 `std::istream` 作为替代：

std::string null_book = "9-99999-9";
    // 构造一个临时的 Sales 对象
    // 该对象的 sold_num 和 revenue 等于 0，book_no 等于 null_book
    item.combine(null_book);

在这里我们用一个 `std::string` 实参调用了 `Sales` 的 `combine` 成员。该调用是合法的，编译器用给定的 `std::string` 自动创建了一个 `Sales` 对象。新生成的这个 (临时) `Sales` 对象被传递给 `combine`。因为 `combine` 的参数是一个常量引用，所以我们可以给该参数传递一个临时量。

## 1. 只允许一步类类型转换 ##

编译器只会自动地执行一步类型转换。因为下面的代码隐式地使用了两种转换规则，所以是错误的：

// 错误：需要用户定义的两种转换
    // (1) 把 "9-99999-9" 转换成 std::string
    // (2) 再把这个 (临时的) std::string 转换成 Sales
    item.combine("9-99999-9");

如果我们想完成上述调用，可以显式地把字符串转换成 `std::string` 或者 `Sales` 对象：

// 正确：显式地转换成 std::string，隐式地转换成 Sales
    item.combine(std::string("9-99999-9"));
    
    // 正确：隐式地转换成 std::string，显式地转换成 Sales
    item.combine(Sales("9-99999-9"));

## 2. 类类型转换不是总有效 ##

`null_book` 中的 `std::string` 可能表示了一个不存在的 ISBN 编号。

从 `std::istream` 到 `Sales` 的转换如下：

// 使用 std::istream 构造函数创建一个函数传递给 combine
    item.combine(cin);

这段代码隐式地把 `std::cin` 转换成 `Sales`，这个转换执行了接受一个 `std::istream` 的 `Sales` 构造函数。该构造函数通过读取标准输入创建了一个 (临时的) `Sales` 对象，随后将得到的对象传递给 `combine`。

`Sales` 对象是个临时量，一旦 `combine` 完成我们就不能再访问它了。实际上，我们构建了一个对象，先将它的值加到 `item` 中，随后将其丢弃。

## 3. 抑制构造函数定义的隐式转换 ##

在要求隐式转换的程序上下文中，我们可以通过将构造函数声明为 `explicit` 加以阻止：

class Sales {
    public:
    	Sales() = default;
    	Sales(const std::string &s, unsigned int n, double p) : book_no(s), sold_num(n), revenue(p*n) {}
    	explicit Sales(const std::string &s) : book_no(s) {}
    	explicit Sales(std::istream &);
    	// ......
    };

没有任何构造函数能用于隐式地创建 `Sales` 对象，之前的两种用法都无法通过编译：

item.combine(null_book);  // 错误：std::string 构造函数是 explicit 的
    item.combine(cin);  // 错误：std::istream 构造函数是 explicit 的

**构造函数声明为 `explicit`，从而可以避免我们不期望的隐式转换。**

**关键字 `explicit` 只对一个实参的构造函数有效。需要多个实参的构造函数不能用于执行隐式转换，所以无须将这些构造函数指定为 `explicit` 的。只能在类内声明构造函数时使用 `explicit` 关键字，在类外部定义时不应重复：**

// 错误：explicit 关键字只允许出现在类内的构造函教声明处
    explicit Sales::Sales(std::istream& is)
    {
    	read(is, *this);
    }

## 4. `explicit` 构造函数只能用于直接初始化 ##

发生隐式转换的一种情况是当我们执行拷贝形式的初始化时 (使用 `=`)。此时，我们只能使用直接初始化而不能使用 `explicit` 构造函数：

Sales iteml(null_book);  // 正确：直接初始化
    // 错误：不能将 explicit 构造函数用于拷贝形式的初始化过程
    Sales_data item2 = null_book;

**当我们用 `explicit` 关键字声明构造函数时，它将只能以直接初始化的形式使用。而且，编译器将不会在自动转换过程中使用该构造函数。**

**显式构造函数 (explicit constructor) 是可以用一个单独的实参调用但是不能用隐式转换的构造函数。通过在构造函数之前加 `explicit` 关键字就可以将其声明成显式构造函数。**

## 5. 为转换显式地使用构造函数 ##

尽管编译器不会将 `explicit` 的构造函数用于隐式转换过程，但是我们可以使用这样的构造函数显式地强制进行转换：

// 正确：实参是一个显式构造的 Sales 对象 
    item.combine(Sales(null_book));
    // 正确：static_cast 可以使用 explicit 的构造函数 
    item.combine(static_cast<Sales_data> (cin));

在第一个调用中，我们直接使用 `Sales` 的构造函数，该调用通过接受 `std::string` 的构造函数创建了一个临时的`Sa1es` 对象。在第二个调用中，我们使用 `static_cast` 执行了显式的而非隐式的转换。其中，`static_cast` 使用 `std::istream`构造函数创建了一个临时的 `Sales` 对象。

## 6. 标准库中含有显式构造函数的类 ##

我们用过的一些标准库中的类含有单参数的构造函数：

*  接受一个单参数的 `const char*` 的 `std::string` 构造函数不是 `explicit` 的。
 *  接受一个容量参数的 `vector` 构造函数是 `explicit` 的。

实现 (implementation) 类的成员 (通常是私有的)，定义了不希望为使用类类型的代码所用的数据及任何操作。

## References ##

(美) Stanley B. Lippman, (美) Josée Lajoie, (美) Barbara E. Moo 著, 王刚, 杨巨峰 译. C++ Primer 中文版\[M\]. 第 5 版. 电子工业出版社, 2013.  
[https://www.informit.com/store/c-plus-plus-primer-9780321714114][https_www.informit.com_store_c-plus-plus-primer-9780321714114]

[https_www.informit.com_store_c-plus-plus-primer-9780321714114]: https://www.informit.com/store/c-plus-plus-primer-9780321714114