您好，登录后才能下订单哦！
密码登录
登录注册
点击 登录注册 即表示同意《亿速云用户服务条款》
今天小编给大家分享一下C++中的explicit关键字怎么使用的相关知识点，内容详细，逻辑清晰，相信大部分人都还太了解这方面的知识，所以分享这篇文章给大家参考一下，希望大家阅读完这篇文章后有所收获，下面我们一起来了解一下吧。
在要求隐式转换的程序上下文中，我们可以通过将构造函数声明为explicit加以组织：
class Sales_data {
public:
Sales_data() = default;
Sales_data(const std::string &s, unsigned n, double p): bookNo(s), units_sold(n), revenue(p*n) {}
explicit Sales_data(const std::string &s): bookNo(s) {}
explicit Sales_data(std::istream&);
Sales_data& combine(const Sales_data &rhs) {
units_sold += rhs.units_sold;
revenue += rhs.revenue;;
return *this;
}
private:
double avg_price() const {return units_sold ? revenue / units_sold : 0; }
string bookNo;
unsigned units_sold = 0;
double revenue = 0.0;
};此时，没有任何构造函数能用于隐式地创建Sales_data对象：下面的两种用法都无法通过编译：
Sales_data item; // right, 调用默认构造函数
Sales_data item2("book"); // right, 调用explicit Sales_data(const std::string &s): bookNo(s) {}
item.combine(null_book); // error: string构造函数式explicit的
item.combine(cin); // error: istream构造函数式explicit的关键字 explicit 只对一个实参的构造函数有效。需要多个实参的构造函数不能用于执行隐式转换，所以无须将这些构造函数指定为 explicit 的。只能在类内声明构造函数时使用 explicit 关键字，在类外部定义时不应重复：
// error: explicit 关键字只允许出现在类内的构造函数声明处
explicit Sales_data::Sales_data(istream& is) {
read(is, *this);
}note1: explicit 构造函数只能用于直接初始化。
note2: 当使用explicit 关键字声明构造函数时，它将只能以直接初始化的形式使用。而且，编译器将不会在自动转换过程中使用该构造函数。
发生隐式转换的一种情况时当我们执行拷贝的初始化时（使用 = ）。此时，我们只能使用直接初始化而不能使用explicit构造函数：
Sales_data null_book("book", 1, 10.0); // right
Sales_data item1(null_book); // right，直接初始化
Sales_data item2 = null_book; // error, 不能将explicit 构造函数用于拷贝形式的初始化过程 尽管编译器不会将 explicit 的构造函数用于隐式转换过程，但是我们可以使用这样的构造函数显式地强制进行转换：
Sales_data null_book("book", 1, 10.0); // right
// right: 直接初始化
item.combine(Sales_data(null_book));
// right: static_cast可以使用explicit的构造函数
item.combine(static_cast<Sales_data>(cin));在第一个调用中，我们直接使用Sales_data的构造函数，该调用通过接受string构造函数创建了一个临时的 Sales_data 对象。在第二个调用中，我们使用 static_cast 执行了显式的而非隐式的转换。其中 static_cast 使用 istram 的构造函数创建了一个临时的Sales_data对象。
《C++ prime》第五版，14.9.1中关于类型转换的介绍：
在实践中，类很少提供类型转换运算符。在大多数情况下，如果类型转换自动发生，用户可能会感觉比较意外，而不是感觉受到了帮助。然而这条经验法则存在一种例外情况：对于类来说，定义向bool的类型转换还是比较普遍的现象。
在C++标准的早期版本中，如果类想定义一个向bool的类型转换，则它常常遇到一个问题：因为bool是一种算术类型，所以类类型的对象转换成bool后就能被用在任何需要算数类型的上下文中。这样的类型转换可能引发意想不到的结果，特别是当istream含有向bool的类型转换时，下面的代码仍将通过编译：
int i = 42; cin << i; // 如果向bool的类型转换不是显式的，则该代码在编译器看来将是合法的！ // 这个程序只有在输入数字的时候，i会默认为整数，输入字符串则会为0
这段程序视图将输出运算符用作输入流。因为istream本身并没有定义<<，所以本来代码应该产生错误。然而，该代码能使用istream的bool类型转换运算符将cin转换成bool，而这个bool值接着会被提升成int并用作内置的左移运算符的左侧运算对象。这样一来，提升后的bool值（1或0）最终会被左移42个位置。这一结果显示与我们的预期大相径庭。
为了防止这样的异常情况发生，C++11新标准引入了显式的类型转换运算符（explicit conversion operator）：
class SmallInt {
public:
// 编译器不会自动执行这一类型转换
explicit operator int() const {return val;}
// 其他成员与之前的版本一致
};和显示的构造函数一样，编译器（通常）也不会将一个显式的类型转换运算符用于隐式类型转换：
SmallInt si = 3; // 正确：SmallInt的构造函数不是显式的 si + 3; // 错误：此处需要隐式的类型转换，但类的运算符是显式的 static_cast<int>(si) + 3; // 正确：显示地请求类型转换。这里的static_cast<int>可以进行强制类型转换
当类型转换运算符是显式的时，我们也能执行类型转换，不过必须通过显式的强制类型转换才可以。
该规定存在一个例外，即如果表达式被用作条件，则编译器会将显式的类型转换自动应用于它。换句话说，当表达式出现在下列位置时，显式的类型转换将被隐式地执行：
if、while及do语句的条件部分
for 语句头的条件表达式
逻辑非（！）、逻辑或（||）、逻辑与（&&）的运算对象
条件运算符（？ : ）的条件表达式
// explicit关键字的作用就是防止类构造函数的隐式自动转换
// 并且explicit关键字只对有一个参数的类构造函数有效，如果类构造函数参数大于
// 或等于两个时，是不会产生隐式转换的，所有explicit关键字也就无效了。
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
using namespace std;
class CxString // 这里没有使用explicit关键字的类声明，即默认为隐式声明
{
public:
char *_pstr;
int _size;
CxString(int size) {
cout << "CxString(int size), size = " << size << endl;
_size = size; // string的预设大小
_pstr = (char*)malloc(size + 1);
memset(_pstr, 0, size + 1);
}
CxString(const char *p) {
int size = strlen(p);
_pstr = (char*)malloc(size + 1); // 分配string的内存
strcpy(_pstr, p);
_size = strlen(_pstr);
cout << "CxString(const char *p), strlen(p) = " << size << endl;
}
~CxString() {
if (_pstr != nullptr) {
delete(_pstr);
_pstr = nullptr;
}
}
};
int main() {
CxString string1(24); // right, 为CxString预分配24字节的大小的内存
CxString string2 = 10; // right, 为CxString预分配10字节的大小的内存
CxString string3; // error, 因为没有默认构造函数, 错误为: “CxString”: 没有合适的默认构造函数可用
CxString string4("aaaa"); // right
CxString string5 = "bbb"; // right, 调用的是CxString(const char *p)
CxString string6 = 'c'; // right, 其实调用的是CxString(int size), 且size等于'c'的ascii码
string1 = 2; // right, 为CxString预分配2字节的大小的内存
string2 = 3; // right, 为CxString预分配3字节的大小的内存
CxString string3 = string1; // right, 至少编译是没问题的, 但是如果析构函数里用free释放_pstr内存指针的时候可能会报错, 完整的代码必须重载运算符"=", 并在其中处理内存释放
return 0;
}上面的代码中, “CxString string2 = 10;” 这句为什么是可以的呢? 在C++中, 如果的构造函数只有一个参数时, 那么在编译的时候就会有一个缺省的转换操作:将该构造函数对应数据类型的数据转换为该类对象. 也就是说 “CxString string2 = 10;” 这段代码, 编译器自动将整型转换为CxString类对象, 实际上等同于下面的操作:
CxString string2(10); 或 CxString temp(10); CxString string2 = temp;
但是, 上面的代码中的_size代表的是字符串内存分配的大小, 那么调用的第二句 “CxString string2 = 10;” 和第六句 “CxString string6 = ‘c’;” 就显得不伦不类, 而且容易让人疑惑. 有什么办法阻止这种用法呢? 答案就是使用explicit关键字. 我们把上面的代码修改一下, 如5.2小节。
// explicit关键字的作用就是防止类构造函数的隐式自动转换
// 并且explicit关键字只对有一个参数的类构造函数有效，如果类构造函数参数大于
// 或等于两个时，是不会产生隐式转换的，所有explicit关键字也就无效了。
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
using namespace std;
class CxString // 这里没有使用explicit关键字的类声明，即默认为隐式声明
{
public:
char *_pstr;
int _size;
int _age;
explicit CxString(int size) {
cout << "CxString(int size), size = " << size << endl;
_size = size; // string的预设大小
_pstr = (char*)malloc(size + 1);
memset(_pstr, 0, size + 1);
}
CxString(const char *p) {
int size = strlen(p);
_pstr = (char*)malloc(size + 1); // 分配string的内存
strcpy(_pstr, p);
_size = strlen(_pstr);
cout << "CxString(const char *p), strlen(p) = " << size << endl;
}
// 上面也已经说过了, explicit关键字只对有一个参数的类构造函数有效。
// 如果类构造函数参数大于或等于两个时, 是不会产生隐式转换的, 所以explicit关键字也就无效了.
explicit CxString(int age, int size) {
_age = age;
_size = size;
}
~CxString() {
if (_pstr != nullptr) {
delete(_pstr);
_pstr = nullptr;
}
}
};
int main() {
CxString string1(24); // right, 为CxString预分配24字节的大小的内存
CxString string2 = 10; // error, 因为取消了隐式转换
CxString string3; // error, 因为没有默认构造函数, 错误为: “CxString”: 没有合适的默认构造函数可用
CxString string4("aaaa"); // right
CxString string5 = "bbb"; // right, 调用的是CxString(const char *p)
CxString string6 = 'c'; // error, 其实调用的是CxString(int size), 且size等于'c'的ascii码, 因为取消了隐式转换
string1 = 2; // error, 因为取消了隐式转换
string2 = 3; // error, 因为取消了隐式转换
CxString string3 = string1; // right, 至少编译是没问题的, 但是如果析构函数里用free释放_pstr内存指针的时候可能会报错, 完整的代码必须重载运算符"=", 并在其中处理内存释放
return 0;
}但是, 也有一个例外, 就是当除了第一个参数以外的其他参数都有默认值的时候, explicit关键字依然有效, 此时, 当调用构造函数时只传入一个参数, 等效于只有一个参数的类构造函数,
例子如下:
class CxString // 使用关键字explicit声明
{
public:
int _age;
int _size;
// 此时该构造函数等效于只有一个参数的类构造函数，explicit可以生效
explicit CxString(int age, int size = 0)
{
_age = age;
_size = size;
// 代码同上, 省略...
}
CxString(const char *p)
{
// 代码同上, 省略...
}
};
// 下面是调用:
CxString string1(24); // right
CxString string2 = 10; // error, 因为explicit关键字取消了隐式转换
CxString string3; // error, 因为没有默认构造函数
string1 = 2; // error, 因为取消了隐式转换
string2 = 3; // error, 因为取消了隐式转换
string3 = string1; // error, 因为取消了隐式转换, 除非类实现操作符"="的重载以上就是“C++中的explicit关键字怎么使用”这篇文章的所有内容，感谢各位的阅读！相信大家阅读完这篇文章都有很大的收获，小编每天都会为大家更新不同的知识，如果还想学习更多的知识，请关注亿速云行业资讯频道。
免责声明：本站发布的内容（图片、视频和文字）以原创、转载和分享为主，文章观点不代表本网站立场，如果涉及侵权请联系站长邮箱：is@yisu.com进行举报，并提供相关证据，一经查实，将立刻删除涉嫌侵权内容。