笔记5 · C++构造函数/析构函数及浅拷贝深拷贝

首先类的成员有成员变量和成员函变量两种。

成员函数之间可以相互调用，成员函数内部可以访问成员常量。私有成员只能类的内部访问；如果想在外部访问内部的成员变量，必须使用对象来访问公有成员函数，通过公有成员函数间接访问私有成员变量。

首先，创建对象： <类名>  <对象名>

可以用：对象 . <成员变量>；对象 . <成员函数> ;    对象指针 -> <成员变量>；对象指针 -> <成员函数>  ;

构造函数(Constructor)：是一种特殊的成员函数，它的名字和类名相同，且没有没有返回值，不需要用户显示的调用，而是在创建对象时自动运行。

构造函数的特性：

1. 可以有参数，也可以无参数，无返回值。

2. 特殊时手动调用

3. 能被重载

 构造函数的参数列表：

#include <iostream>
using namespace std;

class Student{
protected:
    int m_a;
    int m_b;
public:
//构造1
    Student():m_a(1), m_b(2)
    {}

//构造2
    Student(int a, int b):m_a(a), m_b(b)
    {}

//构造3的写法和构造2达到了一样的效果
    Student(int a, int b)
    {
        m_a = a;
        m_b = b;
    } 
   
//析构
    ~Student(){}

};

构造函数的参数列表，其函数体为空或不为空，在其函数的首部与函数体之间添加了一个冒号“ : ”,后面紧跟m_a(1), m_a(2)等语句，就是说将1这个静态值给成员变量m_a。以此类推m_a(a), m_a(b)就是将a这个临时变量交给成员变量m_a。

构造函数参数列表常用作用：

1. 初始化常成员变量

2. 初始化封闭类成员对象

3.继承时初始化父类

任何生成对象的过程，都需要说明对象是使用哪个构造函数初始化的，即便定义对象数组，也要对数组中的每个元素进行初始化进行说明。

在定义类时，如果一个构造函数都不写，则编译器自动生成一个默认的构造函数(无参)来为初始化对象服务。如果用户写了构造函数，那么编译器不会自动生成默认构造函数。一个类不一定会有默认构造函数，但一定会有拷贝构造函数。

对一个已知对象进行拷贝(初始化)，编译系统会自动调用一种构造函数——拷贝构造函数，如果用户未定义拷贝构造函数，则会调用默认拷贝构造函数。

拷贝构造函数：调用时机

1. 当一个类的对象初始化另一个类的对象时；

2. 当一个类对象作为值传递时；

3. 当一个类对象作为函数返回值时。

浅拷贝和深拷贝：

Student stu1("小明", 20, 80);//普通的初始化

Student stu2 = stu1;//调用拷贝构造函数进行初始化

void func(Student& obj)
{
     //TODO...   
}
func(stu2);//以值传递的形式初始化

Student func()//以函数返回值的方式调用拷贝构造函数
{
    Student stu;
    return stu;
}

以上方式，如果用户自己不写拷贝构造函数，那么编译器会自动生成一个默认的拷贝构造函数。例如，return语句会返回一个对象，不过为了返回局部对象销毁，也为了防止通过返回值修改原来的对象，编译器不会直接返回这个对象，而是根据这个对象先创建出一个临时对象(匿名对象)， 再将这个临时对象返回。而创建这个对象的过程，就是以拷贝构造函数进行的，会调用拷贝构造函数。

浅拷贝产生原因：
当用户成员变量以指针变量的形式出现时，于编译系统在我们没有自己定义拷贝构造函数时，会在拷贝对象时调用默认拷贝构造函数，进行的是浅拷贝！即对指针name拷贝后会出现两个指针指向同一个内存空间，最终造成了指针悬挂。

当用户对指针类型的变量进行释放时，最终就造成了，释放来两次的效果。释放两次在Linux终端运行中的表现为：已放弃

如何解决？

对于一些简单的类，使用默认的拷贝构造函数一般就够了，我没有必要显示地定义一个功能类似的拷贝构造函数。当当前类持有其他资源时，如：动态分配的内存，指向其他的数据指针等，就必须要写用户自定义的拷贝构造函数了，调用用户自定义的拷贝构造函数的过程，就是深拷贝的过程。以完整地拷贝对象所有数据，让原有数据和新生对象相互独立，彼此之间不受影响。

如何书写拷贝构造函数：

#include <iostream>

using namespace std;
class student
{
    private:
        int m_age;
	char *m_name;

    public:
	student() : m_age(0)
	{
	    cout<<"I am constructor1"<<endl;
	    m_name = new char[100];
	}
	student(int age, char *name) : m_age(age)
	{
	    cout<<"I am constructor2"<<endl;
	    m_name = new char[100];
	    strcpy(m_name, name);
	}
	student(const student &s)//使用自己的拷贝构造函数
	{
	    cout<<"i am deepcopy_constructor"<<endl;
	    m_age = s.m_age;
	    m_name = new char[100];
            strcpy(m_name, s.m_name);
	}
	~student()//析构函数的书写方式
	{
	    cout<<"--------i am destructor!-----------"<<endl;
	    delete[] m_name;
	}

	void show(void);
};

void student::show(void)
{
    cout<<"m_age = "<<m_age<<endl;
    cout<<"m_name = "<<m_name<<endl;
}

int main(void)
{
    student stu1();
    student stu2(22, "xia");
    student stu3 = stu2;

    stu3.show();
    //func(stu3);
	
    return 0;
}

而析构函数和构造函数相反， 析构函数在对象消亡时会调用析构函数。析构函数的书写方式和构造类似，在函数的前面需要加上一个波浪号“~”。

析构函数的特点：

1.、无参数、无返回值

2、销毁对象时自动调用

4、不能被重载(一个类只能有一个析构函数)

5、构造函数和析构函数都不能被继承

在函数内部创建的变量属于局部对象，他和局部变量类似，位于栈区，函数执行结束的时候会调用这些对象的析构函数。