1.  拷贝构造函数

什么时候会调用拷贝构造函数  ？

           使用一个已经创建好的对象来初始化一个新的对象。

    Student mya("zhang3",22);
            //如果是在定义一个对象通过另一个对象来初始化，那么会调用拷贝构造函数
    Student myb(mya);
    //等同于Student myb = mya;

        特点：   值传递的方式给函数参数传值

代码示例如下：

class Student{
public:
    Student()
    {
        cout<<Student()<<endl;
    }
    Student(char *name,int age){
       this->name = new char[256];
       strcpy(this->name,name);
       this->age = age;
       cout<<Student(char *name,int age)<<endl;
    }
    //如果我们没有自己定义拷贝构造函数，编译器就会帮助我们自动生成默认的拷贝构造函数---浅拷贝--值的拷贝
//    Student(Student &other) //Student &other = mya
//    {
//        this->name = other.name;
//        this->age = other.age;
//        cout<<Student(Student &other)<<endl;
//    }
    //自定义深拷贝 --在进行值的拷贝的同时，也要给指针变量申请新的堆空间
    Student(const Student &other) //Student &other = mya
    {
        //申请堆空间
        this->name = new char[256];
        //值的拷贝
        strcpy(this->name,other.name);
        this->age = other.age;
       cout<<Student(Student &other)<<endl;
    }
    ~Student(){
        //析构函数一般用来  释放 成员的内存空间
        delete []name;
        cout<<~ Student()<<endl;
    }
    void show()
    {
        cout<<this->name<< <<this->age<<endl;
    }
private:
    char *name;
    int age;
};
int main()
{
    Student mya("zhang3",22);
    //如果是在定义一个对象通过另一个对象来初始化，那么会调用拷贝构造函数
    Student myb(mya);
    //Student myb = mya;

    return 0;
}

2.  赋值函数

           当一个类的对象对另一个对象进行直接赋值时会调用赋值函数

    Data mya;
    mya.setName("zhangsan");
    Data myb;
    //赋值重载
    myb = mya; //编译器会转换成 myb.operator=(mya)  

如果程序员没有自定义赋值运算符函数。系统会调用自动生成的默认赋值函数（如下面代码注释部分）

什么时候需要自定义赋值函数？

如果类定义中存在指针或者引用变量或对象，对象与对象进行赋值时就会出现内存泄漏。

为了防止这种情况发生我们就需要自定义赋值函数。

（我的理解就是   ->  当申请了堆空间的时候 ）

代码示例如下

class Data
{
public:
	Data(){
		name = new char[256];
	}
	~Data(){
		delete[]this->name;
	}
	
	void setName(const char *name) {
		strcpy(this->name,name);
	}
	/*
	//如果没有自定义赋值函数，系统执行自动生成的默认赋值函数 ---(系统自动生成的赋值函数底层原型)
	void operator=(Data &ra) //Data &ra = mya
	{
		this->name = ra.name;
	} */
	//系统调用默认的赋值函数会造成内存泄漏  /所以我们需要只需要自定义赋值函数
	void operator=(Data &ra) //Data &ra = mya
	{
		strcpy(this->name, ra.name);
	}
private:
	char * name; //姓名
};
int main()
{
	Data mya;
	mya.setName("zhangsan");
	Data myb;
	//赋值重载
	myb = mya; //编译器会转换成 myb.operator=(mya)  

	return 0;
}

总结：

当我们对两者不够了解时，很容易错写，错用。

拷贝构造函数就是在对象被创建的时候调用的，而赋值函数只能被创建好的对象调用

代码

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<string>
using namespace std;
static int i = 0;
class Student
{
private:
	int age;
	string name;
public:
	/*
	构造函数
	*/
	Student(int age, string name)
	{
		this->age = age;
		this->name = name;

		cout << "构造函数" << endl;
	}
	/*
	无参构造函数
	*/
	Student() { cout << "无参构造函数" << endl; }
	/*
	拷贝构造函数
	*/
	Student(const Student & stur)
	{
		age = stur.age;
		name = stur.name;
		cout << "拷贝构造函数" << endl;
	}
	/*
	析构函数
	*/
	~Student()
	{
		cout << "析构函数" << endl;

	}
	void print()
	{
		cout << age << endl;
	}
};

Student fun(int age, string name)
{
	Student stu(age, name);   // stu是局部变量，在函数执行完将会进行析构
	return stu;//会存在Student temp = stu，在主调函数中如果有变量接受  temp的话就不会立刻释放
}

void fun2(const Student stur)
{
	cout << "fun2" << endl;
}


return 0;
}

四种调用方法

int main()
{
	Student stu1(12,"lisi");

#if 0
	//第一种调用方式
	Student stu2(stu1);

	//第二种
	Student stu3 = stu1;

	//注：以下方式不行
	 Student stu3;
	 stu3 = stu1;// 这是先调用无参构造创建，然后再赋值
#endif
	//第三种作为函数的返回值时会存在  Student temp = stu;
	fun(10, "张三");
	cout << "fun执行完了" << endl;//temp在此之前被析构，相当于匿名对象，使用完就会被析构

#if 0
	Student stu4 = fun(11, "王五");//这种情况  stu4= 这一过程没有调用拷贝构造函数，而是直接将temp转正为stu4
	cout << "fun执行完了" << endl;//temp被转正为stu4

	//第四种，作为函数参数使用时
	fun2(stu1);//存在Student stur = stu1

#endif
	

运行结果

方式1与2

方式3  不用变量接收，执行完以后临时对象立刻被析构

方式3  使用变量接受，临时对象转正

方式4  存在Student stur = stu1

1.拷贝构造函数的特点：

函数名和类型名一样

Object(const Object& obj)
{
}

上面的形参里面需要加上“&”,目的是为了防止无限的构造，形成死递归。

加上const,目的是常引用，不能改变里面的值

2.通过例子引入拷贝构造：

问：下面的fun函数在调用的过程中创建了几个对象？（答：五个）

加了引用，就会减少对象构建次数（四次）

上图的fun函数中为什么要加const呢？到底加不加const？
不想形参改变实参加const，想让形参改变实参就不加const。取决于我们想不想修改参数。

3构造对象的时候使用引用返回与不使用引用返回的问题：

3.1不使用引用返回：

3.2引用返回——从已经死亡的地址接收值不牢靠：

以引用返回就是返回这个对象的地址

所以：对象的生存期不受fun函数的影响，就可以用引用返回

4.缺省的拷贝构造和等号运算符重载

当我们不写拷贝构造函数和等号运算符重载，系统会自动生成浅拷贝。

5.深拷贝和浅拷贝的问题

5.1浅拷贝导致的重复析构问题：

浅拷贝就是将seqade内容直接赋值给seqb，解析如下图：

那么seqb.data也只想seqa.data指向的内容时，如果在析构的时候我们析构了seqb,seqb.data所指向的内容就会被释放掉，等到seqa时候的时候，会出现重复析构同一空间而导致出错的问题。

5.2浅拷贝会导致内存泄漏的问题：

代码如下图：


内存解析图如下：

6.重写拷贝构造

当我们重写了拷贝构造之后就会把seqa的值赋值给seqb，然后seqb开辟一片和seqa等大小的堆区空间，再把seqa堆区的内容拷贝到seqb中，

7.总结

凡是在类中设计成指针或者设计指向内核态对象，就要写自己的拷贝构造和等号运算符重载。
（指针、文件指针/线程、信号量、互斥量）