C++中关键字explicit

文章来源：

http://blog.youkuaiyun.com/shift_wwx/article/details/78792987

 

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 有如下几点：

• explicit 是个关键字
• 关键字是适用于类构造函数的声明时
• explicit 的构造函数不能参与隐式转换
• explicit 只用于显示地构造对象

如果声明了explicit 的构造函数，再次参与隐式转换，编译器会报出如下的错误：

error: conversion from ‘int’ to non-scalar type ‘Explicit’ requested
error: conversion from ‘const char [10]’ to non-scalar type ‘Explicit’ requested

 

在C++程序中很少有人去使用explicit关键字，不可否认，在平时的实践中确实很少能用的上。再说C++的功能强大，往往一个问题可以利用好几种C++特性去解决。但稍微留心一下就会发现现有的MFC库或者C++标准库中的相关类声明中explicit出现的频率是很高的。了解explicit关键字的功能及其使用对于我们阅读使用库是很有帮助的，而且在编写自己的代码时也可以尝试使用。既然C++语言提供这种特性，我想在有些时候这种特性将会非常有用。

按默认规定，只用传一个参数的构造函数也定义了一个隐式转换。举个例子：

//Example.h
#pragma once
class CExample
{
public:
    CExample(void);
    ~CExample(void);
public:
    int m_iFirst;
    int m_iSecond;
public:
    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 objOne; //调用没有参数的构造函数
    CExample objTwo(12, 12); //调用有两个参数的构造函数
    CExample objThree(12); //同上，可以传一个参数是因为该构造函数的第二个参数有默认值
    CExample objFour = 12; 
    return 0;
}

 

着重来看下：

CExample objFour = 12 ;

这里用的是隐式转换，等号右边表达式应该理解为CExample(int x)，x就是12。

这个表达式完整表示方式为：

CExample objFour = CExample(12) ;

先是做了隐式转换，后通过等号实现了默认拷贝构造函数调用。对象objFour的构造函数应该调用的是默认拷贝构造函数。

暂时不关心默认拷贝构造函数，注意这里的隐式转换。

 

再来看个例子：

class Stest  
{
public:  
    char *_pstr;  
    int _size;
    //explicit Stest(int size)  
    Stest(int size)
    {
        _size = size;
        _pstr =(char *)malloc(size + 1);
        memset(_pstr, 0, size + 1);
    }
    Stest(const char* p)
    {
        int size = strlen(p);
        cout<<"size"<<size<<endl;
         _pstr = (char *)malloc(size + 1);
       strcpy(_pstr, p);
       _size = strlen(_pstr);
       cout<<"_size"<<size<<endl;
    }
};  
int main()  
{  
    Stest s;
    Stest s1(30);
    Stest s2 = 5;
    Stest s3("hehe");
    Stest s4 = 'a';
    Stest s5 = s3;
    return 0;
}

来分析代码：

    Stest s;//fail，构造函数中没有不带参数的
    Stest s1(30);//success
    Stest s2 = 5;//success，隐式转换，s2=Stest(5)
    Stest s3("hehe");//success
    Stest s4 = 'a';//success，隐式转换，字符a作为assii码传入，调用Stest(int)
    Stest s5 = s3;//success，调用默认构造函数
    return 0;

如果在构造函数Stest(int size)前面加上关键字explicit，结果会变掉：

 

    Stest s;//fail，构造函数中没有不带参数的
    Stest s1(30);//success
    Stest s2 = 5;//fail，不能隐式转换，必须要显示转换
    Stest s3("hehe");//success
    Stest s4 = 'a';//fail，不能隐式转换，必须要显示转换
    Stest s5 = s3;//success，调用默认构造函数
    return 0;

 

关键字explicit意思是“非隐式”，要求构造函数不能做隐式转换，主要用于 一个参数 的构造函数，或者第一个参数后面都是默认值的构造函数。（如果多个参数并没有默认值，那不会出现隐式转换了）

 

 

与之对应的关键字是implicit，表示“隐式”，默认的类的构造函数前面都为隐式。