c++ 默认构造、拷贝构造、移动构造、赋值

1.案例：

#include <iostream>
using namespace std;
class base
{
public:
	base(int a, int b)
	{
		this->a = a;
		this->b = b;
		cout << "base:" << a << b << endl;
	}
	base(base &b)
	{
		this->a = b.a;
		this->b = b.b;
		cout << "拷贝构造" << a << this->b << endl;
	}
	base& operator=(base &c)
	{
		cout << "赋值" << endl;
		a = c.a;
		b = c.b;
		return *this;
	}
	~base()
	{
		cout << "析构:" << a << b << endl;
	}
public:
	int a;
	int b;
};
int main() {
	base b(1, 2);
	base b2(b);
	base b3(2,3);
	b2 = b3;
	base b4 = b;
}

案例在包含了普通构造，拷贝构造和重载了运算符号，其中有以下几个注意的地方

（1）

base b1=b

调用的是拷贝构造而不是赋值即类初始化是调用了拷贝构造

（2）

系统默认提供了类重载=，但是浅拷贝时存在问题 

 

#include<iostream>
using namespace std;
class demo1
{
public:
	demo1()
	{

	}

	demo1(char *p)
	{
		s= new char[100];
		s = p;
	}
	~demo1()
	{
		delete s;
	}
private:
	char *s;
};
int  main()
{
	char s[10]="12345";
	char *p = s;
	demo1 d(p);
	demo1 d1;
	d1 = d;
}

上面的demo运行会崩溃，问题在与d1=d默认的为浅拷贝，使用同一块地址空间会造成多次析构。

为了避免上述问题，需要对默认的赋值构造进行重载。

#include<iostream>
using namespace std;
class demo1
{
public:
	demo1()
	{

	}

	demo1(char *p)
	{
		s= new char[100];
		s = p;
	}
	demo1 & operator=(const demo1 d)
	{
		s = new char[100];
		strcpy(s, d.s);
	}
	~demo1()
	{
		delete s;
	}
	public:
	 char *s;
};
int  main()
{
	char s[10]="12345";
	char *p = s;
	demo1 d(p);
	demo1 d1;
	d1 = d;
}

浅拷贝变为了深拷贝便能有效的避免这一问题。