zoukankan      html  css  js  c++  java
  • 【C++】C++中explicity关键字的使用

    读者可以尝试预言一下这段代码的输出:

    #include <iostream>
    using namespace std;
    class Complex
    {
        private:
            double real;
            double imag;
        public:
            // 默认构造器无explicity关键字
            Complex(double r = 0.0, double i = 0.0) : real(r), imag(i) {}
          
            // 比较操作符==,接受一个Complex的参数
            bool operator == (Complex rhs) {
               return (real == rhs.real && imag == rhs.imag)? true : false;
            }
    };
    int main()
    {
        // a Complex object
        Complex com1(3.0, 0.0);
        if (com1 == 3.0)//将Complex与double类型比较
           cout << "Same";
        else
           cout << "Not Same";
         return 0;
    } 

    输出:

    Same

    上面Complex的==操作符接受的是一个Complex参数。当程序运行到com1 == 3.0时,程序会自动调用Complex的构造器并且传入参数3.0,然后得到一个新的Complex对象,再将这个新对象传给com1的==操作符。所以程序表面上看起来是Complex和double在进行比较,但实际上程序做了隐式的转化(将double转成了Complex),依然是两个Complex在比较。

    在C++中如果一个类有能够被单参数所调用的构造器,那么这个构造器就被称为转化构造器——转化构造器允许从单参数到类构造的转化。C++中能够接受单参数的构造器默认都是转化构造器。

    那么如何避免这种隐式的转化呢?可以使用explicity关键字。使用了explicity关键字的构造器就不允许上面的隐式转化,要转化的话,只能强制转化。

    我们修改后的程序如下:

    #include <iostream>
    using namespace std;
    class Complex
    {
        private:
            double real;
            double imag;
        public:
            // 在构造器上加入explicity关键字
            explicit Complex(double r = 0.0, double i = 0.0) : real(r), imag(i) {}
          
            // 比较操作符==,接受一个Complex的参数
            bool operator== (Complex rhs) {
               return (real == rhs.real && imag == rhs.imag)? true : false;
            }
    };
    int main()
    {
        // a Complex object
        Complex com1(3.0, 0.0);
    
        //if (com1 == 3.0)//编译错误
        if (com1 == (Complex)3.0) //Complex的构造器使用了explicity关键字,就只能进行强制转化了。
           cout << "Same";
        else
           cout << "Not Same";
         return 0;
    } 

    在案例中,我们可以将double转化为Complex,但是必需强制转化。

    下面是一个赋值的案例(Complex的构造器上无 explicity 关键字):

        Complex com1(3.0, 0.0);
        Complex com2 = 3.0;//将一个3.0赋值给Complex对象

    第一个语句是传入参数构造器Complex对象,这没有什么可讨论的。第二个语句将3.0赋值给了Complex对象,其实原理和上面是一样的,首先传入参数3.0到Complex的构造器构造一个临时Complex对象,然后再将临时Complex对象传给com2对象。

    如果给Complex构造器加上explicity关键字,那么就变成如下的形式了:

    Complex com2 = (Complex)3.0;


    原文链接:

    https://www.geeksforgeeks.org/g-fact-93/


  • 相关阅读:
    PHP实反向代理-收藏
    微信小程序实例-获取当前的地理位置、速度
    Entity Framework Core 实现读写分离
    将ASP.NET Core应用程序部署至生产环境中(CentOS7)(转)
    Centos 7防火墙firewalld开放80端口
    Asp.net Core 使用Redis存储Session
    .net core 使用Autofac依赖注入
    .net core 1.0 实现负载多服务器单点登录
    用ASP.NET Core 1.0中实现邮件发送功能-阿里云邮件推送篇
    阿里大鱼.net core 发送短信
  • 原文地址:https://www.cnblogs.com/HDK2016/p/11013922.html
Copyright © 2011-2022 走看看