14.14 - 转换构造函数与explicit和delete关键字

"Key Takeaway"

默认情况下，C++会把所有的构造函数都当做隐式地转换操作符。考虑下面的例子：

#include <cassert>
#include <iostream>
 
class Fraction
{
private:
	int m_numerator;
	int m_denominator;
 
public:
	// Default constructor
	Fraction(int numerator = 0, int denominator = 1)
		 : m_numerator(numerator), m_denominator(denominator)
	{
		assert(denominator != 0);
	}
 
	// Copy constructor
	Fraction(const Fraction& copy)
		: m_numerator(copy.m_numerator), m_denominator(copy.m_denominator)
	{
		// no need to check for a denominator of 0 here since copy must already be a valid Fraction
		std::cout << "Copy constructor called\n"; // just to prove it works
	}
 
	friend std::ostream& operator<<(std::ostream& out, const Fraction& f1);
	int getNumerator() { return m_numerator; }
	void setNumerator(int numerator) { m_numerator = numerator; }
};
 
void printFraction(const Fraction& f)
{
	std::cout << f;
}
 
std::ostream& operator<<(std::ostream& out, const Fraction& f1)
{
	out << f1.m_numerator << '/' << f1.m_denominator;
	return out;
}
 
int main()
{
	printFraction(6);
 
	return 0;
}

尽管 printFraction() 期望接受一个 Fraction ，但实际上我们给它传递了一个字面量 6。因为 Fraction 的构造函数可以接受整型，所以编译器会隐式地将字面量6转换为一个 Fraction 对象。它会使用Fraction(int, int) 来初始化 printFraction() 的形参f。

程序执行结果如下：

6/1

对于所有类型的初始化，该隐式转换都可用。

能够被用来进行隐式类型转换的构造函数，称为转换构造函数。

explicit 关键字

虽然在Fraction这个例子中，进行隐式转换是有意义的，但在其他情况下，这可能是不可取的，也可能导致意外的行为:

#include <string>
#include <iostream>
 
class MyString
{
private:
	std::string m_string;
public:
	MyString(int x) // allocate string of size x
	{
		m_string.resize(x);
	}
 
	MyString(const char* string) // allocate string to hold string value
	{
		m_string = string;
	}
 
	friend std::ostream& operator<<(std::ostream& out, const MyString& s);
 
};
 
std::ostream& operator<<(std::ostream& out, const MyString& s)
{
	out << s.m_string;
	return out;
}
 
void printString(const MyString& s)
{
	std::cout << s;
}
 
int main()
{
	MyString mine = 'x'; // Will compile and use MyString(int)
	std::cout << mine << '\n';
 
	printString('x'); // Will compile and use MyString(int)
	return 0;
}

在上面的例子中，我们使用一个字符来初始一个字符串。因为字符实际上是属于整型家族的，所以编译器会使用MyString(int) 构造函数隐式地将字符转换为 MyString。当程序打印 MyString时，其结果会出乎我们的意料。类似的，调用 printString(‘x’) 也会导致隐式类型转换，结果也是类似的。

解决这个问题的一种方法是通过explicit关键字标记构造函数(和转换函数)，该关键字放在函数名前面。explicit 的构造函数和转换函数将不会用于隐式转换或拷贝初始化：

#include <string>
#include <iostream>
 
class MyString
{
private:
	std::string m_string;
public:
	// explicit keyword makes this constructor ineligible for implicit conversions
	explicit MyString(int x) // allocate string of size x
	{
		m_string.resize(x);
	}
 
	MyString(const char* string) // allocate string to hold string value
	{
		m_string = string;
	}
 
	friend std::ostream& operator<<(std::ostream& out, const MyString& s);
 
};
 
std::ostream& operator<<(std::ostream& out, const MyString& s)
{
	out << s.m_string;
	return out;
}
 
void printString(const MyString& s)
{
	std::cout << s;
}
 
int main()
{
	MyString mine = 'x'; // 编译错误，因为 MyString(int) 现在是 explicit 的
	std::cout << mine;
 
	printString('x'); // 编译错误，MyString(int) 不能被用于隐式类型转换
 
	return 0;
}

上面的程序是无法编译的，因为 MyString(int) 被定义为 explicit，而且无法找到一个可用的能够将 ‘x’ 隐式转换为MyString的构造函数。

不过，将构造函数标记为 explict 只能防止隐式类转换。显示的类型转换仍然是可以的：

std::cout << static_cast<MyString>(5); // Allowed: explicit cast of 5 to MyString(int)

直接初始化和统一初始化仍会对参数进行转换使其匹配（统一初始化虽然不会进行缩窄转换，但是可能会进行其他类型的转换）。

MyString str{'x'}; // Allowed: initialization parameters may still be implicitly converted to match

"最佳实践"

考虑将构造函数和用户定义转换成员函数设置为显式的，以防止隐式转换错误。

delete 关键字

在MyString的例子中，如果希望完全禁止 x 被转换为MyString(无论是隐式的还是显式的，因为结果符合直觉)。其中一种方法是添加MyString(char)构造函数，并将其设为私有:

#include <string>
#include <iostream>
 
class MyString
{
private:
	std::string m_string;
 
	MyString(char) // objects of type MyString(char) can't be constructed from outside the class
	{
	}
 
public:
	// explicit keyword makes this constructor ineligible for implicit conversions
	explicit MyString(int x) // allocate string of size x
	{
		m_string.resize(x);
	}
 
	MyString(const char* string) // allocate string to hold string value
	{
		m_string = string;
	}
 
	friend std::ostream& operator<<(std::ostream& out, const MyString& s);
 
};
 
std::ostream& operator<<(std::ostream& out, const MyString& s)
{
	out << s.m_string;
	return out;
}
 
int main()
{
	MyString mine('x'); // compile error, since MyString(char) is private
	std::cout << mine;
	return 0;
}

COPY

但是，这个构造函数仍然可以在类内部使用(私有访问只防止非成员调用此函数)。

更好的解决方法是使用 delete关键字删除函数:

#include <string>
#include <iostream>
 
class MyString
{
private:
	std::string m_string;
 
public:
	MyString(char) = delete; // 任何使用该函数的地方都会报错
	
	// explicit 使得该构造函数不能够被用于隐式类型转换
	explicit MyString(int x) // allocate string of size x /
	{
		m_string.resize(x);
	}
 
	MyString(const char* string) // allocate string to hold string value
	{
		m_string = string;
	}
 
	friend std::ostream& operator<<(std::ostream& out, const MyString& s);
 
};
 
std::ostream& operator<<(std::ostream& out, const MyString& s)
{
	out << s.m_string;
	return out;
}
 
int main()
{
	MyString mine('x'); // compile error, since MyString(char) is deleted
	std::cout << mine;
	return 0;
}

当函数被delete之后，任何对该构造函数的使用都会导致编译报错。

注意，拷贝构造函数和重载运算符也可以被delete，以避免对应的操作。