【C++】拷贝构造函数和运算符重载

1.拷贝构造的补充

编译器默认生成的拷贝构造：默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝称为浅拷贝。

• 不写拷贝构造，编译器会自动生成默认拷贝构造，拷贝方式为浅拷贝

• 默认构造函数：对于内置类型成员值拷贝，浅拷贝：按照字节序传值。

• 默认构造函数：对于自定义类型，去调用自定义类型的拷贝构造

class Stack
{
public:
	Stack(int capacity = 4)
	{
		cout << "Stack(int capacity = 4)" << endl;

		_a = (int*)malloc(sizeof(int)*capacity);
		assert(_a);
		_top = 0;
		_capacity = capacity;
	}

	~Stack()
	{
		cout << "~Stack()" << endl;
		free(_a);
		_a = nullptr;
		_capacity = _top = 0;
	}
private:
	int* _a;
	int _top;
	int _capacity;
};
int main()
{
	Stack st1;
	Stack st2(st1);
	return 0;
}

比如上述程序会出现内存问题。Stack内部没有定义拷贝函数，所以编译器会自动生成拷贝构造函数，拷贝方式为浅拷贝。由于Stack成员变量为指针，按照内存序拷贝拷贝的是指针,因此st1和st2指向的是同一个位置。同一块内存空间析构两次所以会出现内存问题。

浅拷贝：

• 1.指向同一块空间，修改数据会相互影响
• 2.这块空间析构时会释放两次，程序会崩溃。
• 解决方案：实现深拷贝

程序2

class Stack
{
public:
	Stack(int capacity = 4)
	{
		cout << "Stack(int capacity = 4)" << endl;
		_top = 0;
		_capacity = capacity;
        //memset是按照一个字节一个字节进行赋值
        //所以初始化最好每个字节初始化为0
		memset(_a, 0, sizeof(int) * 10);
	}
	~Stack()
	{
		cout << "~Stack()" << endl;
		_capacity = _top = 0;
	}
private:
	int _a[10];
	int _top;
	int _capacity;
};
int main()
{
	Stack st1;
	Stack st2(st1);
	return 0;
}

如果存放的是数组，可以正常的拷贝。因为st1存储的数组和st2存储的数组指向的不是同一块空间。

1.1自定义类型的拷贝构造

自定义类型：去调用自定义类型的拷贝构造

程序一

class Stack
{
public:
	Stack(int capacity = 4)
	{
		cout << "Stack(int capacity = 4)" << endl;
		_a = (int*)malloc(sizeof(int)*capacity);
		assert(_a);
		_top = 0;
		_capacity = capacity;
	}
    Stack(Stack& st)
    {
        cout<<"调用Stack的拷贝构造"<<endl;
    }
	~Stack()
	{
		cout << "~Stack()" << endl;
		free(_a);
		_a = nullptr;
		_capacity = _top = 0;
	}
private:
	int* _a;
	int _top;
	int _capacity;
};
class MyQueue{
    private:
    	int _size=0;
    	Stack _st1;
    	Stack _st2;
}
int main()
{
    MyQueue mq1;
    MyQueue mq2(mq1);
    return 0;
}

MyQueue既有自定义类型又有内置类型。对于内置类型，编译器会继续浅拷贝，对于自定义类型调用自定义类型的拷贝构造

1.2总结

1.用户不写拷贝构造编译器会默认生成一个拷贝构造

2.自定义类型成员，去调用这个成员的拷贝构造

3.一般类，自己生成的拷贝构造就够用了。只有像Stack类这种需要自己直接管理资源需要实现深拷贝。

4.对于在堆区上开辟了空间的类，就需要使用深拷贝。

2.运算符重载

C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。

函数名字为：关键字operator后面接需要重载的运算符符号。
函数原型：返回值类型 operator操作符(参数列表)

2.1特征

• 1.不能通过连接其他符号来创建新的操作符：比如operator@

• 2.重载操作符必须有一个类类型或者枚举类型的操作数

• 3.用于内置类型的操作符，其含义不能改变，例如：内置的整型+，不 能改变其含义

• 4.作为类成员的重载函数时，其形参看起来比操作数数目少1

  成员函数的操作符有一个默认的形参this，限定为第一个形参

• 5. *. 、:: 、sizeof 、?: 、. **注意以上5个运算符不能重载。

  .* 域作用符，sizeof ,三目操作符 .操作符

class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
//如果重载定义在类外，为了能够访问成员变量，就需要把成员变量修改为public类型;
//但是这种方法不够好。
//private:
	int _year;
	int _month;
	int _day;
};
//自定义类型，不能直接用各种运算符
//为了自定义类型可以使用各种运算符，制定了运算符重载的规operator 
//返回值 operator运算符 参数列表
bool operator==(Date d1,Date d2)
{
    return d1._year==d2._year
        &&d1._month==d2._month
        &&d1._day==d2._day;
}
//操作符重载的使用方式：
bool test(Date d1,Date d2)
{
    return d1==d2
}

而Python和Java习惯使用内置返回值函数。还有一种方法是使用有元，但是有元会破坏封装。

class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
    //返回私有变量。
    int Getyear()
    {
        return _year;
    }
    //........
private:
	int _year;
	int _month;
	int _day;
};
bool operator==(Date d1,Date d2)
{
    return d1.Getyear()==d2.Getyear()
        &&d1.Getmonth()==d2.Getmonth()
        &&d1.Getday()==d2.Getday();
}
bool test(Date d1,Date d2)
{
    return d1==d2
}

2.1C++最常用的处理方法

C++最常用的是把运算符重载定义为成员函数

class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
    bool operator==(const Date&d)
    {
        return _year==d._year
        &&_month==d._month
        &&_day==d._day;
    }
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
    Date d1(2022,5,17);
    Date d2(2022,5,17);
    if(d1==d2)
    {
        cout<<"=="<<endl;
    }
    return 0;
}
//输出：==

2.3日期类的赋值运算符重载

class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
    //赋值运算符的返回值，返回值是赋值运算符的左值,因为赋值运算符要满足连续赋值 k=i=j j先赋值给i，i再赋值给k;
    //如果出了作用域对象还存在，可以使用引用返回;
    //返回值不可以使用const：比如(k=i)=j;如果返回值是const类型
    //那么(k=i)的返回值是const k,j就不能够对k进行下一步赋值。
    Date& operator=(const Date&d)
    {
        if(this!=&d)
       //如果使用if(*this!=d),就需要重载!=。得不偿失
        {
            _year=d._year;
            _month=d._month;
            _day=d._day;
            //对this指针进行解引用z
        }
        return *this;
    }
private:
	int _year;
	int _month;
	int _day;
};

2.4操作符重载的规则

对于该类有意义的运算符才进行运算符重载；比如日期类相加就无意义，所以就不需要操作符重载。