C++ explicit关键字详解

最新推荐文章于 2022-10-09 16:36:48 发布

jean7155

最新推荐文章于 2022-10-09 16:36:48 发布

阅读量166

点赞数

分类专栏： C++

C++ 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

C++ explicit关键字详解

平平笔记：
1、 C++ explicit关键字详解
2、C++: explicit的适用场合以及为什么要使用explicit
C++关键字explicit

平平笔记：

第三篇中最后总结，“如第26行代码所示”后面的部分和第一篇文章中“上面的代码中, “CxString string2 = 10;” ”这句下面的代码的说明部分有矛盾。
由于比较偏底层，我不太擅长，具体情况我没有核实过。请学习的小伙伴注意。
有核实过得请联系，我也学习一下。：）

1、 C++ explicit关键字详解

首先, C++中的explicit关键字只能用于修饰只有一个参数的类构造函数, 它的作用是表明该构造函数是显示的, 而非隐式的, 跟它相对应的另一个关键字是implicit, 意思是隐藏的,类构造函数默认情况下即声明为implicit(隐式).

那么显示声明的构造函数和隐式声明的有什么区别呢? 我们来看下面的例子:

class CxString  // 没有使用explicit关键字的类声明, 即默认为隐式声明  
{  
public:  
    char *_pstr;  
    int _size;  
    CxString(int size)  
    {  
        _size = size;                // string的预设大小  
        _pstr = malloc(size + 1);    // 分配string的内存  
        memset(_pstr, 0, size + 1);  
    }  
    CxString(const char *p)  
    {  
        int size = strlen(p);  
        _pstr = malloc(size + 1);    // 分配string的内存  
        strcpy(_pstr, p);            // 复制字符串  
        _size = strlen(_pstr);  
    }  
    // 析构函数这里不讨论, 省略...  
};  
  
    // 下面是调用:  
  
    CxString string1(24);     // 这样是OK的, 为CxString预分配24字节的大小的内存  
    CxString string2 = 10;    // 这样是OK的, 为CxString预分配10字节的大小的内存  
    CxString string3;         // 这样是不行的, 因为没有默认构造函数, 错误为: “CxString”: 没有合适的默认构造函数可用  
    CxString string4("aaaa"); // 这样是OK的  
    CxString string5 = "bbb"; // 这样也是OK的, 调用的是CxString(const char *p)  
    CxString string6 = 'c';   // 这样也是OK的, 其实调用的是CxString(int size), 且size等于'c'的ascii码  
    string1 = 2;              // 这样也是OK的, 为CxString预分配2字节的大小的内存  
    string2 = 3;              // 这样也是OK的, 为CxString预分配3字节的大小的内存  
    string3 = string1;        // 这样也是OK的, 至少编译是没问题的, 但是如果析构函数里用free释放_pstr内存指针的时候可能会报错, 完整的代码必须重载运算符"=", 并在其中处理内存释放

上面的代码中, “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关键字. 我们把上面的代码修改一下, 如下:

class CxString  // 使用关键字explicit的类声明, 显示转换  
{  
public:  
    char *_pstr;  
    int _size;  
    explicit CxString(int size)  
    {  
        _size = size;  
        // 代码同上, 省略...  
    }  
    CxString(const char *p)  
    {  
        // 代码同上, 省略...  
    }  
};  
  
    // 下面是调用:  
  
    CxString string1(24);     // 这样是OK的  
    CxString string2 = 10;    // 这样是不行的, 因为explicit关键字取消了隐式转换  
    CxString string3;         // 这样是不行的, 因为没有默认构造函数  
    CxString string4("aaaa"); // 这样是OK的  
    CxString string5 = "bbb"; // 这样也是OK的, 调用的是CxString(const char *p)  
    CxString string6 = 'c';   // 这样是不行的, 其实调用的是CxString(int size), 且size等于'c'的ascii码, 但explicit关键字取消了隐式转换  
    string1 = 2;              // 这样也是不行的, 因为取消了隐式转换  
    string2 = 3;              // 这样也是不行的, 因为取消了隐式转换  
    string3 = string1;        // 这样也是不行的, 因为取消了隐式转换, 除非类实现操作符"="的重载

explicit关键字的作用就是防止类构造函数的隐式自动转换.

上面也已经说过了, explicit关键字只对有一个参数的类构造函数有效, 如果类构造函数参数大于或等于两个时, 是不会产生隐式转换的, 所以explicit关键字也就无效了. 例如:

class CxString  // explicit关键字在类构造函数参数大于或等于两个时无效  
{  
public:  
    char *_pstr;  
    int _age;  
    int _size;  
    explicit CxString(int age, int size)  
    {  
        _age = age;  
        _size = size;  
        // 代码同上, 省略...  
    }  
    CxString(const char *p)  
    {  
        // 代码同上, 省略...  
    }  
};  
  
    // 这个时候有没有explicit关键字都是一样的

但是, 也有一个例外, 就是当除了第一个参数以外的其他参数都有默认值的时候, explicit关键字依然有效, 此时, 当调用构造函数时只传入一个参数, 等效于只有一个参数的类构造函数, 例子如下:

class CxString  // 使用关键字explicit声明  
{  
public:  
    int _age;  
    int _size;  
    explicit CxString(int age, int size = 0)  
    {  
        _age = age;  
        _size = size;  
        // 代码同上, 省略...  
    }  
    CxString(const char *p)  
    {  
        // 代码同上, 省略...  
    }  
};  
  
    // 下面是调用:  
  
    CxString string1(24);     // 这样是OK的  
    CxString string2 = 10;    // 这样是不行的, 因为explicit关键字取消了隐式转换  
    CxString string3;         // 这样是不行的, 因为没有默认构造函数  
    string1 = 2;              // 这样也是不行的, 因为取消了隐式转换  
    string2 = 3;              // 这样也是不行的, 因为取消了隐式转换  
    string3 = string1;        // 这样也是不行的, 因为取消了隐式转换, 除非类实现操作符"="的重载

转载自：https://blog.csdn.net/guoyunfei123/article/details/89003369

2、C++: explicit的适用场合以及为什么要使用explicit

explicit是个C++关键子,但是关注过它的人远远没有其他关键字的多,但是往往忽略了它,就会在一些不经意的地方造成错误,而花费更多的时间去寻找.

看下下面这个例子:

#include <iostream>
using namespace std;

class A
{
public:
    A(int i = 5)
    {
        m_a = i;
     }
private:
    int m_a;
};

int main()
{
    A s;
    //我们会发现,我们没有重载'='运算符,但是去可以把内置的int类型赋值给了对象A.
    s = 10;
    //实际上,10被隐式转换成了下面的形式,所以才能这样.
    //s = A temp(10);

    system("pause");
    return 0;
}

我们发现成员变量的值被修改了.
在这里插入图片描述

由此可知:当类构造函数的参数只有一个的时候,或者所有参数都有默认值的情况下,类A的对象时可以直接被对应的内置类型隐式转换后去赋值的,这样会造成错误,所以接下来会体现出explicit这个关键词的作用.

#include <iostream>
using namespace std;

class A
{
public:
    //这里用explicit关键词来修饰类构造函数.
    explicit A(int i = 5, int j = 10)
    {
        m_a = i;
        m_b = j;
    }
private:
    int m_a;
    int m_b;
};

int main()
{
    A s;
    //这样直接赋值,会被提示错误,因为explicit抑制隐式转换的进行
    s = 10;//这样会报错!!!
    //当然显示转换还是可以的.
    s = A(20);

    system("pause");
    return 0;
}

通过两个例子我们知道:explicit可以抑制内置类型隐式转换,所以在类的构造函数中,最好尽可能多用explicit关键字,防止不必要的隐式转换.

原文：https://blog.csdn.net/qq_37233607/article/details/79051075

C++关键字explicit

C++中的explicit关键字只能用于修饰只有一个参数的类构造函数, 它的作用是表明该构造函数是显示的, 而非隐式的, 跟它相对应的另一个关键字是implicit, 意思是隐藏的,类构造函数默认情况下即声明为implicit(隐式).

C++提供关键字explicit，可以阻止不应该允许的经过转换构造函数进行的隐式转换发生．

声明为explicit的构造函数不能在隐式转换中使用．

C++中，一个参数的构造函数(或者除了第一个参数外其余参数都有默认值的多参构造函数)，承担了两个角色．

1.是个构造器，2.是个默认且隐含的类型转换操作符．

写下如AAA = XXX，这样的代码，且恰好XXX的类型正好是AAA单参数构造的参数类型，这时候编译器就自动调用这个构造器，创建一个AAA的对象．

使用explicit声明构造函数，则可防止隐式转换，避免上述情况的发生．具体例子如下：

class CTest1 {
  public:
      CTest1(int n)
      {
          cout<<"Constructor of CTest1"<<endl;
      }
      CTest1(const CTest1&)
      {
          cout<<"Copy constructor of CTest1"<<endl;
     }
 };
 class CTest2 {
 public:
     explicit CTest2(int n)
     {
         cout<<"Constructor of CTest2"<<endl;
     }
     explicit CTest2(const CTest2&)
     {
         cout<<"Copy constructor of CTest2"<<endl;
     }
 };
 int main()
 {
     CTest1 a1(1);            //显示调用构造函数
     CTest1 b1 = 1;            //隐式调用构造函数
     CTest1 c1 = a1;            //隐式调用拷贝构造函数
     CTest1 d1(b1);            //显示调用拷贝构造函数
     CTest2 a2(2);            //显示调用构造函数
     CTest2 b2 = 2;            //隐式调用构造函数，编译错误
     CTest2 c2 = a2;            //隐式调用拷贝构造函数，编译错误
     CTest2 d2(b2);            //显示调用拷贝构造函数
     return 0;
 }

如第26行代码所示，是直接隐式调用构造函数，创建对象b1,不要误理解为是先隐式调用构造函数创建临时对象，将调用拷贝构造函数，以临时对象创建对象b1.

如第31行代码所示，explicit对拷贝构造函数也会限制作用，将会阻隐式拷贝构造函数的调用．

将拷贝构造函数声明为explicit，则会阻止隐式拷贝构造函数的调用．隐式拷贝构造函数的调用主要发生在三个点：

1.一个对象作为函数参数，以值传递的方式传入函数体．

2.一个对象作为函数返回值，以值传递的方式从函数返回．

3.以AAA = xxx的方式创建对象AAA，xxx为与AAA为同类型的对象.

因而，将拷贝构造函数声明成explicit并不是良好的设计，一般只将有单个参数的constructor声明为explicit，而copy constructor不要声明为explicit.

原文地址：https://www.cnblogs.com/dwdxdy/archive/2012/07/17/2595479.html

jean7155

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
C++ explicit关键字详解

C++ explicit关键字详解平平笔记：1、 C++ explicit关键字详解2、C++: explicit的适用场合以及为什么要使用explicitC++关键字explicit平平笔记：第三篇中最后总结，“如第26行代码所示”后面的部分和第一篇文章中“上面的代码中, “CxString string2 = 10;” ”这句下面的代码的说明部分有矛盾。由于比较偏底层，我不太擅长，具体情...
复制链接

扫一扫

专栏目录