62575人阅读
在C++程序中很少有人去使用explicit关键字，不可否认，在平时的实践中确实很少能用的上。再说C++的功能强大，往往一个问题可以利用好几种C++特性去解决。但稍微留心一下就会发现现有的MFC库或者C++标准库中的相关类声明中explicit出现的频率是很高的。了解explicit关键字的功能及其使用对于我们阅读使用库是很有帮助的，而且在编写自己的代码时也可以尝试使用。既然C++语言提供这种特性，我想在有些时候这种特性将会非常有用。
按默认规定，只用传一个参数的构造函数也定义了一个隐式转换。举个例子：
（下面这个CExample没有什么实际的意义，主要是用来说明问题）
//Example.h
#pragma once
class CExample
CExample(void);
~CExample(void);
CExample(int iFirst, int iSecond = 4);
//Example.cpp
#include "StdAfx.h"
#include "Example.h"
CExample::CExample(void)
: m_iFirst(0)
CExample::~CExample(void)
CExample::CExample(int iFirst, int iSecond):m_iFirst(iFirst), m_iSecond(iSecond)
//TestExplicitKey.cpp
...//其它头文件
#include "Example.h"
int _tmain(int argc, _TCHAR* argv[])
CExample objO //调用没有参数的构造函数
CExample objTwo(12, 12); //调用有两个参数的构造函数
CExample objThree(12); //同上，可以传一个参数是因为该构造函数的第二个参数有默认值
CExample objFour = 12; //执行了隐式转换,等价于CExample temp(12);objFour(temp);注意这个地方调用了
//编译器为我们提供的默认复制构造函数
如果在构造函数声明中加入关键字explicit，如下
explicit CExample(int iFirst, int iSecond = 4);
那么CExample objFour = 12; 这条语句将不能通过编译。在vs05下的编译错误提示如下
error C2440: 'initializing' : cannot convert from 'int' to 'CExample'
&&&&&&&&Constructor for class 'CExample' is declared 'explicit'
对于某些类型，这一情况非常理想。但在大部分情况中，隐式转换却容易导致错误（不是语法错误，编译器不会报错）。隐式转换总是在我们没有察觉的情况下悄悄发生，除非有心所为，隐式转换常常是我们所不希望发生的。通过将构造函数声明为explicit（显式）的方式可以抑制隐式转换。也就是说，explicit构造函数必须显式调用。
引用一下Bjarne Stroustrup的例子:
class String{
&&&&&&explicit String(int n);
&&&&&&String(const char *p);
String s1 = 'a'; //错误：不能做隐式char-&String转换
String s2(10);&& //可以：调用explicit String(int n);
String s3 = String(10);//可以：调用explicit String(int n);再调用默认的复制构造函数
String s4 = "Brian"; //可以：隐式转换调用String(const char *p);再调用默认的复制构造函数
String s5("Fawlty"); //可以：正常调用String(const char *p);
void f(String);
String g()
&&&&f(10); //错误：不能做隐式int-&String转换
&&&&f("Arthur"); //可以：隐式转换，等价于f(String("Arthur"));
&&&&return 10; //同上
在实际代码中的东西可不像这种故意造出的例子。
发生隐式转换，除非有心利用，隐式转换常常带来程序逻辑的错误，而且这种错误一旦发生是很难察觉的。
原则上应该在所有的构造函数前加explicit关键字，当你有心利用隐式转换的时候再去解除explicit，这样可以大大减少错误的发生。
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：270994次
积分：3260
积分：3260
排名：第7484名
原创：107篇
评论：55条
(2)(2)(1)(1)(7)(2)(1)(2)(5)(5)(1)(2)(3)(4)(15)(1)(8)(18)(9)(1)(1)(2)(2)(5)(6)(8)c++中explicit关键字作用-c/c++-电脑编程网c++中explicit关键字作用作者：黄鹏　和相关&&c++的explicit关键字c++中的explicit关键字用来修饰类的构造函数，表明该构造函数是显式的，既然有"显式"那么必然就有"隐式"，那么什么是显示而什么又是隐式的呢？如果c++类的构造函数有一个参数，那么在编译的时候就会有一个缺省的转换操作：将该构造函数对应数据类型的数据转换为该类对象，如下面所示：class myclass{public:&& myclass( int num );}....myclass obj = 10; //ok,convert int to myclass在上面的代码中编译器自动将整型转换为myclass类对象，实际上等同于下面的操作：myclass temp(10);myclass obj =上面的所有的操作即是所谓的"隐式转换"。如果要避免这种自动转换的功能，我们该怎么做呢？嘿嘿这就是关键字explicit的作用了，将类的构造函数声明为"显式"，也就是在声明构造函数的时候前面添加上explicit即可，这样就可以防止这种自动的转换操作，如果我们修改上面的myclass类的构造函数为显示的，那么下面的代码就不能够编译通过了，如下所示：class myclass{public:&& explicit myclass( int num );}....myclass obj = 10; //err,can't non-explict convert&转载&！相关资料：｜｜｜｜｜｜｜c++中explicit关键字作用来源网络，如有侵权请告知，即处理！编程Tags：　　　　　　　　　　　　　　　　&　　　　　　　　　　　　　　　　　　　　c++中的explicit 关键字是什么意思？
[问题点数：0分]
c++中的explicit 关键字是什么意思？
[问题点数：0分]
不显示删除回复
显示所有回复
显示星级回复
显示得分回复
只显示楼主
2003年11月 C/C++大版内专家分月排行榜第三
2004年7月 C/C++大版内专家分月排行榜第三
2005年8月 Linux/Unix社区大版内专家分月排行榜第三2005年6月 Linux/Unix社区大版内专家分月排行榜第三
本帖子已过去太久远了，不再提供回复功能。explicit_百度百科
本词条缺少名片图，补充相关内容使词条更完整，还能快速升级，赶紧来吧！
C++提供了explicit，可以阻止不应该允许的经过进行的隐式转换的发生。声明为explicit的不能在隐式转换中使用。
explicit词语意思
详述的,明晰的,明确的,毫不隐瞒的,露骨的,外在的, 清楚的, 直率的, (租金等)直接付款的
英英解释:形容词explicit:
1. precisely and clearly expressed o leaving nothing to implication
同义词：expressed
2. in accordance with fact or the primary meaning of a term
同义词：denotative
习惯用语be explicit about 对某事态度鲜明 例句
He avoids the explicit answer to us.
他避免给我们明确的回答。
They gave explicit reasons for leaving.
他们明确地说出了离开的原因.
She was quite explicit about why she left.
她对自己离去的原因直言不讳.
explicitC++中的explicit
C++中， 一个参数的(或者除了第一个参数外其余参数都有默认值的多参构造函数)， 承担了两个角色。 1 是个 ，2 是个默认且隐含的类型转换操作符。
所以， 有时候在我们写下如 AAA = XXX， 这样的代码， 且恰好XXX的类型正好是AAA单参数构造器的参数类型， 这时候就自动调用这个构造器， 创建一个AAA的对象。
这样看起来好象很酷， 很方便。 但在某些情况下（见下面权威的例子）， 却违背了我们（程序员）的本意。 这时候就要在这个构造器前面加上explicit修饰， 指定这个构造器只能被明确的调用/使用， 不能作为类型转换操作符被隐含的使用。
explicit的作用
explicit构造函数是用来防止隐式转换的。请看下面的代码：
class&Test1
&&&&Test1(int&n)
&&&&&&&&num=n;
&&&&}//普通构造函数
class&Test2
&&&&explicit&Test2(int&n)
&&&&&&&&num=n;
&&&&}//explicit(显式)构造函数
int&main()
&&&&Test1&t1=12;//隐式调用其构造函数,成功
&&&&Test2&t2=12;//编译错误,不能隐式调用其构造函数
&&&&Test2&t2(12);//显式调用成功
&&&&return&0;
Test1的带一个int型的参数，代码23行会隐式转换成调用Test1的这个构造函数。而Test2的构造函数被声明为explicit（显式），这表示不能通过隐式转换来调用这个构造函数，因此代码24行会出现编译错误。
普通构造函数能够被。而explicit构造函数只能被显式调用。
企业信用信息深入理解C++中的explicit关键字 - 推酷
深入理解C++中的explicit关键字
深入理解C++中的explicit关键字
& & & & &C++中的explicit关键字
修饰只有一个参数
的类构造函数
, 它的作用是表明该构造函数是显示的, 而非隐式的， 跟它相对应的另一个关键字是implicit, 意思是隐藏的,类构造函数默认情况下即声明为implicit(隐式)。
& & & & &关于explicit关键字，先看看MSDN上的解释：
This keyword is a declaration specifier that can
only be applied to in-class constructor declarations
. An explicit constructor cannot take part in implicit conversions. It can
only be used to explicitly construct an object
& & & & 从上面的解释可以看到， explicit关键字的作用：
禁止隐式调用类内的单参数构造函数，
这主要包括如下三层意思：
& & & & &（1）该关键字只能用来修饰类内部的构造函数
& & & & &（2）禁止隐式调用拷贝构造函数
& & & & &（3）禁止类对象之间的隐式转换
& & & & &首先，来看看隐式转换，如下例：
class CExplict
CExplict();
CExplict( bool _explicit)
this-&is_explict = _
CExplict(const CExplict& other)
this-&is_explict = other.is_
friend void printExplicit(const CExplict& cx);
void printExplicit(const CExplict& cx)
cout&&&is_explict=&&&cx.is_explict&&
int main( int argc, char* argv[])
CExplict cx1 =
CExplict cx2 = cx1;
printExplicit(cx1);
printExplicit(cx2);
printExplicit(false);
getchar();
& & & 在上面的代码中：
CExplict cx1 =
CExplict cx2 = cx1;
printExplicit(false);
隐式调用CExplict类的单参数构造函数。这种调用在C++语法中是允许的，但是诸如：CExplict cx1 = true和printExplicit(false)这种表达形式看着很别扭，也很让人费解，将一个bool型的值赋给一个CExplicit类的cx1，使代码的可读性变差。
& & & & & 因此，为了禁止对类的单参数构造函数的隐式调用，C++引入了关键字explicit。在类的定义中，在任何一个单参数构造函数钱加explicit关键字，就可以禁止对该构造函数的隐式调用。如下：
class CExplict
CExplict();
explicit CExplict( bool _explicit)
this-&is_explict = _
CExplict(const CExplict& other)
this-&is_explict = other.is_
friend void printExplicit(const CExplict& cx);
void printExplicit(const CExplict& cx)
cout&&&is_explict=&&&cx.is_explict&&
int main( int argc, char* argv[])
CExplict cx1 =
CExplict cx2 = cx1;
printExplicit(cx1);
printExplicit(cx2);
printExplicit(false);
getchar();
此时，在调用上面一段代码，则会报：
&error C2440: “初始化”: 无法从“bool”转换为“CExplict”的错误，为了使程序能正确运行，需要将main函数内的代码改为：
int main( int argc, char* argv[])
CExplict cx1(true);
CExplict cx2(cx1);
printExplicit(cx1);
printExplicit(cx2);
printExplicit(CExplict(false));
getchar();
至此，程序就可以正常运行，而且进一步增加了程序的可读性。
& & & & （1）explicit关键字只需用于类内的单参数构造函数前面。由于无参数的构造函数和多参数的构造函数总是显示调用，这种情况在构造函数前加explicit无意义。
& & & & （2）如果想禁止类A对象被隐式转换为类B对象，可在类B中使用关键字explicit，即定义这样的转换构造函数
explicit B(A a)
explicit B(const A &a)
& & & & google的c++规范中提到explicit的优点是可以避免不合时宜的类型变换，缺点无。所以google约定所有单参数的构造函数都必须是显示的，只有极少数情况下拷贝构造函数可以不声明称explicit。例如作为其他类的透明包装器的类。
effective c++中说：被声明为explicit的构造函数通常比其non-explicit兄弟更受欢迎。因为它们禁止编译器执行非预期（往往也不被期望）的类型转换。除非我有一个好理由允许构造函数被用于隐式类型转换，否则我会把它声明为explicit，鼓励大家遵循相同的政策。
欢迎转载或分享，但请务必声明文章出处。
已发表评论数()
请填写推刊名
描述不能大于100个字符!
权限设置： 公开
仅自己可见
正文不准确
标题不准确
排版有问题
主题不准确
没有分页内容
图片无法显示
视频无法显示
与原文不一致