一文详解C++中的转换构造函数

 更新时间:2023年09月20日 08:57:28   作者:向阳逐梦  
在 C/C++ 中,不同的数据类型之间可以相互转换,无需用户指明如何转换的称为自动类型转换(隐式类型转换),需要用户显式地指明如何转换的称为强制类型转换,本文就给大家详细介绍一下C++的转换构造函数,需要的朋友可以参考下

在 C/C++ 中,不同的数据类型之间可以相互转换。无需用户指明如何转换的称为自动类型转换(隐式类型转换),需要用户显式地指明如何转换的称为强制类型转换。

自动类型转换示例:

    int a = 6;
    a = 7.5 + a;

编译器对 7.5 是作为 double 类型处理的,在求解表达式时,先将 a 转换为 double 类型,然后与 7.5 相加,得到和为 13.5。在向整型变量 a 赋值时,将 13.5 转换为整数 13,然后赋给 a。整个过程中,我们并没有告诉编译器如何去做,编译器使用内置的规则完成数据类型的转换。强制类型转换示例:

    int n = 100;
    int *p1 = &n;
    float *p2 = (float*)p1;

p1 是int *类型,它指向的内存里面保存的是整数,p2 是float *类型,将 p1 赋值给 p2 后,p2 也指向了这块内存,并把这块内存中的数据作为小数处理。我们知道,整数和小数的存储格式大相径庭,将整数作为小数处理非常荒诞,可能会引发莫名其妙的错误,所以编译器默认不允许将 p1 赋值给 p2。但是,使用强制类型转换后,编译器就认为我们知道这种风险的存在,并进行了适当的权衡,所以最终还是允许了这种行为。

不管是自动类型转换还是强制类型转换,前提必须是编译器知道如何转换,例如,将小数转换为整数会抹掉小数点后面的数字,将int *转换为float *只是简单地复制指针的值,这些规则都是编译器内置的,我们并没有告诉编译器。换句话说,如果编译器不知道转换规则就不能转换,使用强制类型也无用,请看下面的例子:

    #include <iostream>
    using namespace std;
    //复数类
    class Complex{
    public:
        Complex(): m_real(0.0), m_imag(0.0){ }
        Complex(double real, double imag): m_real(real), m_imag(imag){ }
    public:
        friend ostream & operator<<(ostream &out, Complex &c);  //友元函数
    private:
        double m_real;  //实部
        double m_imag;  //虚部
    };
    //重载>>运算符
    ostream & operator<<(ostream &out, Complex &c){
        out << c.m_real <<" + "<< c.m_imag <<"i";;
        return out;
    }
    int main(){
        Complex a(10.0, 20.0);
        a = (Complex)25.5;  //错误,转换失败
        return 0;
    }

25.5 是实数,a 是复数,将 25.5 赋值给 a 后,我们期望 a 的实部变为 25.5,而虚部为 0。但是,编译器并不知道这个转换规则,这超出了编译器的处理能力,所以转换失败,即使加上强制类型转换也无用。

幸运的是,C++ 允许我们自定义类型转换规则,用户可以将其它类型转换为当前类类型,也可以将当前类类型转换为其它类型。

这种自定义的类型转换规则只能以类的成员函数的形式出现,换句话说,这种转换规则只适用于类。本节我们先讲解如何将其它类型转换为当前类类型,下节再讲解如何将当前类类型转换为其它类型。

转换构造函数

将其它类型转换为当前类类型需要借助转换构造函数(Conversion constructor)。转换构造函数也是一种构造函数,它遵循构造函数的一般规则。转换构造函数只有一个参数。

仍然以 Complex 类为例,我们为它添加转换构造函数:

    #include <iostream>
    using namespace std;
    //复数类
    class Complex{
    public:
        Complex(): m_real(0.0), m_imag(0.0){ }
        Complex(double real, double imag): m_real(real), m_imag(imag){ }
        Complex(double real): m_real(real), m_imag(0.0){ }  //转换构造函数
    public:
        friend ostream & operator<<(ostream &out, Complex &c);  //友元函数
    private:
        double m_real;  //实部
        double m_imag;  //虚部
    };
    //重载>>运算符
    ostream & operator<<(ostream &out, Complex &c){
        out << c.m_real <<" + "<< c.m_imag <<"i";;
        return out;
    }
    int main(){
        Complex a(10.0, 20.0);
        cout<<a<<endl;
        a = 25.5;  //调用转换构造函数
        cout<<a<<endl;
        return 0;
    }

运行结果:

10 + 20i

25.5 + 0i

Complex(double real);就是转换构造函数,它的作用是将 double 类型的参数 real 转换成 Complex 类的对象,并将 real 作为复数的实部,将 0 作为复数的虚部。这样一来,a = 25.5;整体上的效果相当于:

a.Complex(25.5);

将赋值的过程转换成了函数调用的过程。在进行数学运算、赋值、拷贝等操作时,如果遇到类型不兼容、需要将 double 类型转换为 Complex 类型时,编译器会检索当前的类是否定义了转换构造函数,如果没有定义的话就转换失败,如果定义了的话就调用转换构造函数。

转换构造函数也是构造函数的一种,它除了可以用来将其它类型转换为当前类类型,还可以用来初始化对象,这是构造函数本来的意义。下面创建对象的方式是正确的:

    Complex c1(26.4);  //创建具名对象
    Complex c2 = 240.3;  //以拷贝的方式初始化对象
    Complex(15.9);  //创建匿名对象
    c1 = Complex(46.9);  //创建一个匿名对象并将它赋值给 c1

在以拷贝的方式初始化对象时,编译器先调用转换构造函数,将 240.3 转换为 Complex 类型(创建一个 Complex 类的匿名对象),然后再拷贝给 c2。如果已经对+运算符进行了重载,使之能进行两个 Complex 类对象的相加,那么下面的语句也是正确的:

    Complex c1(15.6, 89.9);
    Complex c2;
    c2 = c1 + 29.6;
    cout<<c2<<endl;

在进行加法运算符时,编译器先将 29.6 转换为 Complex 类型(创建一个 Complex 类的匿名对象)再相加。需要注意的是,为了获得目标类型,编译器会“不择手段”,会综合使用内置的转换规则和用户自定义的转换规则,并且会进行多级类型转换,例如:

  • 编译器会根据内置规则先将 int 转换为 double,再根据用户自定义规则将 double 转换为 Complex(int --> double --> Complex);
  • 编译器会根据内置规则先将 char 转换为 int,再将 int 转换为 double,最后根据用户自定义规则将 double 转换为 Complex(char --> int --> double --> Complex)。

从本例看,只要一个类型能转换为 double 类型,就能转换为 Complex 类型。请看下面的例子:

    int main(){
        Complex c1 = 100;  //int --> double --> Complex
        cout<<c1<<endl;
        c1 = 'A';  //char --> int --> double --> Complex
        cout<<c1<<endl;
        c1 = true;  //bool --> int --> double --> Complex
        cout<<c1<<endl;
        Complex c2(25.8, 0.7);
        //假设已经重载了+运算符
        c1 = c2 + 'H' + true + 15;  //将char、bool、int都转换为Complex类型再运算
        cout<<c1<<endl;
        return 0;
    }

运行结果:

100 + 0i

65 + 0i

1 + 0i

113.8 + 0.7i

再谈构造函数

构造函数的本意是在创建对象的时候初始化对象,编译器会根据传递的实参来匹配不同的(重载的)构造函数。回顾一下以前的章节,到目前为止我们已经学习了以下几种构造函数。

  • 默认构造函数。就是编译器自动生成的构造函数。以 Complex 类为例,它的原型为:

Complex();  //没有参数

  • 普通构造函数。就是用户自定义的构造函数。以 Complex 类为例,它的原型为:

Complex(double real, double imag);  //两个参数

  • 拷贝构造函数。在以拷贝的方式初始化对象时调用。以 Complex 类为例,它的原型为:

Complex(const Complex &c);

  • 转换构造函数。将其它类型转换为当前类类型时调用。以 Complex 为例,它的原型为:

Complex(double real);

不管哪一种构造函数,都能够用来初始化对象,这是构造函数的本意。假设 Complex 类定义了以上所有的构造函数,那么下面创建对象的方式都是正确的:

    Complex c1();  //调用Complex()
    Complex c2(10, 20);  //调用Complex(double real, double imag)
    Complex c3(c2);  //调用Complex(const Complex &c)
    Complex c4(25.7);  //调用Complex(double real)

这些代码都体现了构造函数的本意——在创建对象时初始化对象。除了在创建对象时初始化对象,其他情况下也会调用构造函数,例如,以拷贝的的方式初始化对象时会调用拷贝构造函数,将其它类型转换为当前类类型时会调用转换构造函数。这些在其他情况下调用的构造函数,就成了特殊的构造函数了。特殊的构造函数并不一定能体现出构造函数的本意。

对 Complex 类的进一步精简

上面的 Complex 类中我们定义了三个构造函数,其中包括两个普通的构造函数和一个转换构造函数。其实,借助函数的默认参数,我们可以将这三个构造函数简化为一个,请看下面的代码:

    #include <iostream>
    using namespace std;
    //复数类
    class Complex{
    public:
        Complex(double real = 0.0, double imag = 0.0): m_real(real), m_imag(imag){ }
    public:
        friend ostream & operator<<(ostream &out, Complex &c);  //友元函数
    private:
        double m_real;  //实部
        double m_imag;  //虚部
    };
    //重载>>运算符
    ostream & operator<<(ostream &out, Complex &c){
        out << c.m_real <<" + "<< c.m_imag <<"i";;
        return out;
    }
    int main(){
        Complex a(10.0, 20.0);  //向构造函数传递 2 个实参,不使用默认参数
        Complex b(89.5);  //向构造函数传递 1 个实参,使用 1 个默认参数
        Complex c;  //不向构造函数传递实参,使用全部默认参数
        a = 25.5;  //调用转换构造函数(向构造函数传递 1 个实参,使用 1 个默认参数)
        return 0;
    }

精简后的构造函数包含了两个默认参数,在调用它时可以省略部分或者全部实参,也就是可以向它传递 0 个、1 个、2 个实参。转换构造函数就是包含了一个参数的构造函数,恰好能够和其他两个普通的构造函数“融合”在一起。

以上就是一文详解C++中的转换构造函数的详细内容,更多关于C++转换构造函数的资料请关注脚本之家其它相关文章!

相关文章

  • C语言编程题杨氏矩阵算法快速上手示例详解

    C语言编程题杨氏矩阵算法快速上手示例详解

    这篇文章主要为大家介绍了C语言编程题杨氏矩阵算法快速上手的示例详解,有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步早日升职加薪
    2021-10-10
  • 函数式宏定义与普通函数的区别

    函数式宏定义与普通函数的区别

    尽管函数式宏定义和普通函数相比有很多缺点,但只要小心使用还是会显著提高代码的执行效率,毕竟省去了分配和释放栈帧、传参、传返回值等一系列工作,因此那些简短并且被频繁调用的函数经常用函数式宏定义来代替实现
    2013-10-10
  • c++基础学习之如何区分引用和指针

    c++基础学习之如何区分引用和指针

    C语言中只有指针,C++加入了引用,能够起到跟指针类似的作用,下面这篇文章主要给大家介绍了关于c++基础学习之区分引用和指针的相关资料,文中通过示例代码介绍的非常详细,需要的朋友可以参考下
    2021-08-08
  • C++ 的cout格式化输出场景示例详解

    C++ 的cout格式化输出场景示例详解

    这篇文章主要为大家介绍了C++的cout格式化输出场景示例详解,有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步,早日升职加薪
    2023-09-09
  • C语言实现电话簿项目管理

    C语言实现电话簿项目管理

    这篇文章主要为大家详细介绍了C语言实现电话簿项目管理,文中示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
    2021-07-07
  • C语言由浅入深了解变量的应用

    C语言由浅入深了解变量的应用

    这篇文章主要介绍了C语言的变量,变量是C语言语法和语义中一个很重要的知识点,有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步,早日升职加薪
    2022-05-05
  • C++实现单张图片读取和保存

    C++实现单张图片读取和保存

    这篇文章主要为大家详细介绍了C++语言读取和保存单张图片的代码,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
    2018-09-09
  • C语言实现最大间隙问题实例

    C语言实现最大间隙问题实例

    这篇文章主要介绍了C语言实现最大间隙问题的方法,是一个比较经典的算法设计问题,对于学习算法设计有一定的借鉴价值,需要的朋友可以参考下
    2014-09-09
  • C++ const的各种用法详解

    C++ const的各种用法详解

    const名叫常量限定符,用来限定特定变量,以通知编译器该变量是不可修改的。习惯性的使用const,可以避免在函数中对某些不应修改的变量造成可能的改动。本文主要谈谈const的用法,感兴趣的同学可以参考阅读
    2023-04-04
  • Java C++ 算法题解leetcode145商品折扣后最终价格单调栈

    Java C++ 算法题解leetcode145商品折扣后最终价格单调栈

    这篇文章主要介绍了Java C++ 算法题解leetcode145商品折扣后最终价格单调栈示例详解,有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步,早日升职加薪
    2022-09-09

最新评论