派生类/内嵌类的拷贝构造函数与重载等号

末蓝、 2022-05-15 07:05 330阅读 0赞

### 拷贝构造,也是一种构造函数,也是没有被继承下来的,子类中也需要进行相应的调整 ###

规则:

子类

当子类不自实现时,默认调用父类的拷贝构造  
若自实现,不做特殊处理,此时只会调用父类的构造器  
特殊处理:显示调用父类的拷贝函数

内嵌子对象  
子类不自实现时拷贝构造,默认调用内嵌子对象的拷贝构造  
若自实现,不作特殊处理,此时只会调用内嵌子对象的构造器,此时失去了拷贝的构造意义  
特殊处理:此时会调用内嵌类的拷贝函数

其中父类和内嵌子对象的拷贝构造函数正常书写,子类以及子类的子类格式如下

派生类名::派生类名(const 派生类名& another):基类名(参数表),内嵌子对象(another.对象名)
    {
        派生类新增成员
    }

实现案例如下:

class C {
    public:
    	C(int z) {
    		c = z;
    		cout << "C()" << endl;
    	}
    	int c;
    };
    
    class A {
    public:
    	A(int i) {
    		cout << "A()" << endl;
    		a = i;
    	}
    
        A(const A& another) {
    		this->a = another.a;
    		cout << "copy use A" << endl;
    	}
    
    	int a;
    };
    
    class B :public A {
    public:
    	B(int i,int j,int z):A(i),c(z) {   
    		cout << "B()" << endl;  
    		this->b = j;
    	}
    
    	B(const B& another):A(another),c(another.c)  
    	{    
    		this->b = another.b;
    		cout << "copy use B" << endl;
    	}
    	int b;
    	C c;
    };

### 重载等号 ###

赋值运算符函数不是构造器,可以被继承,所以语法上就没有那么复杂,格式如下

子类& 子类::operator=(const 子类&another)
    {
         父类::operator=(another);
    }

至于子类的=重载,只需在赋值运算符函数中调用父类和内嵌类的赋值运算符函数就可以了

首先在父类和构造类中各自实现=重载函数,然后在子类进行调用

我们对刚才的实例稍加修改

#include <iostream>
    using namespace std;
    class C
    {
    public:
    	C(int z) :c{ z } {
    		cout << "C()" << endl;
    	}
    
    	C& operator=(const C& another) {
    		if (&another == this)
    			return *this;
    
    		cout << "using operator =A" << endl;
    		this->c = another.c;
    		return *this;
    	}
    	int c;
    };
    
    class A {
    public:
    	A(int x) {
    		a = x;
    		cout << "A()" << endl;
    	}
    
    	A& operator=(const A& another) {
    		if (&another == this)
    			return *this;
    
    		cout << "using operator =A" << endl;
    		this->a = another.a;
    		return *this;
    	}
    	int a;
    
    
    };
    
    class B:public A {
    public:
    	B(int x,int y,int z):A(x),c(z) {
    		b = y;
    		cout << "B()" << endl;
    	}
    
    	B& operator=(const B& another) {
    
    		if (&another == this)
    			return *this;
    
    		cout << "using operator =B" << endl;
    		A::operator=(another);  //这里调用父类的重载,必须遵循这个格式,如果不加A::前缀名,会发生递归而出错
    		c = another.c;          //内嵌对象调用
    		this->b = another.b;
    		return *this;
    	}
    	C c;  //内嵌类
    	int b;
    };