复制构造函数

基本概念

//不写复制构造函数
#include<bits/stdc++.h>
using namespace std;
class Complex
{
    public:
        double real,imag;
};
int main(void)
{
    Complex c1;//调用缺省无参构造函数
    c1.imag=4,c1.real=3;//手动初始化
    Complex c2(c1);//调用编译器自带的缺省复制构造函数，将c2初始化成和c1一样
    std::cout<<c2.real<<ends<<c2.imag; //3 4
    return 0;
}

//自己写复制构造函数
#include<bits/stdc++.h>
using namespace std;
class Complex
{
    public:
        double real,imag;
        Complex(double,double);
        Complex(const Complex&);
};
Complex::Complex(double r,double i)
{
    real=r;
    imag=i;
}
Complex::Complex(const Complex &C)
{
    real=C.real;
    imag=C.imag;
    std::cout<<"Copy Constructor Called"<<endl;
}//自己定义了，则编译器默认自带的复制构造函数不存在
int main(void)
{
    Complex c1(3,4);
    Complex c2(c1);
    std::cout<<c2.real<<ends<<c2.imag<<endl;
    //Copy Constructor Called
    //3 4
    return 0;
}

复制构造函数起作用的两种情况

1.用一个对象初始化另一个对象

#include<bits/stdc++.h>
using namespace std;
class A
{
    public:
        int x;
        A(int);
        A(const A&);
};
A::A(const A& a)
{
    x=a.x;
    std::cout<<"Copy Constructor Called"<<endl;
}
A::A(int n)
{
    x=n;
}
int main(void)
{
    A c1(3);
    c1.x=4;
    A c2=c1;//初始化语句，非赋值语句，等价于A c2(c1)
            //Copy Constructor Called
    return 0;
}

2.如果某个函数的参数是类的对象，调用该函数时，类的复制构造函数会被调用

#include<bits/stdc++.h>
using namespace std;
class A
{
    public:
        int x;
        A(int);
        A(const A&);
};
A::A(const A& a)
{
    x=a.x;
    std::cout<<"Copy Constructor Called"<<endl;
}
A::A(int n)
{
    x=n;
}
void getA(const A c)//参数得是对象，不可以是对象的引用或者指针
{
    std::cout<<c.x<<endl;
}
int main(void)
{
    A c1(3);//通过构造函数初始化
    getA(c1);//调用函数时，可以理解系统执行了一句A c(c1)的语句
    //Copy Constructor Called
    //3
    return 0;
}

注意：对象间的赋值不会导致复制构造函数的调用
**

常引用（const X&）参数的使用

四个字总结构造函数和复制构造函数

构造函数：自食其力
复制构造函数：拿来主义