对象的构造和析构函数

　　构造函数和析构函数，分别对应变量的初始化和清理，变量没有初始化，使用后果未知；没有清理，则会内存管理出现安全问题。

构造函数和析构函数写法

　　构造函数：与类名相同，没有返回值，不写void，可以发生重载，可以有参数，编译器自动调用，只调用一次。

　　析构函数：~类名，没有返回值，不写void，不可以发生重载，不可以有参数，编译器自动调用，只调用一次。

构造函数和析构函数的作用域是public下才可以调用到，不写默认private，调用不到。

　　如果程序猿不提供，系统会默认提供，构造和析构函数，函数体为空。

class Person{
public:
    Person(){
        cout << "无参构造函数" << endl;
    }
    ~Person(){
        cout << "无参析构函数" << endl;
    }
};

void test01(){
    Person p;
}

int main(){
    
    test01();
    system("pause");
    return 0;
}

构造函数的分类和调用

　　按照参数分类：有参构造和无参构造；按照类型分类：普通构造和拷贝构造函数。

class Person{
public:
    Person(const Person &a){
        age = a.age;
        cout << "拷贝构造函数" << endl;
    }
    ~Person(){
        cout << "无参析构函数" << endl;
    }

    int age;
};

　　拷贝构造函数必须加const，因为防止修改，本来就是用现有的对象初始化新的对象。

class Person{
public:
    Person(){
        cout << "无参构造函数" << endl;
    }
    Person(int a){
        cout << "有参构造函数" << endl;
    }
    Person(const Person &a){
        cout << "拷贝构造函数" << endl;
    }
    ~Person(){
        cout << "无参析构函数" << endl;
    }
};

void test02(){

    Person p(1); //有参构造函数
    Person p1(p); //拷贝构造函数
    Person p2; //无参构造函数  不能写成Person p2(); 编译器以为是声明，不是构造函数

    //显示调用
    Person p4 = Person(100); //有参构造函数
    Person p5 = Person(p4); //拷贝构造函数
    //Person(100);单独这句叫匿名对象，编译器如果发现对象是匿名的，在这行代码之后就释放对象
    //Person(p5);不能用拷贝构造函数初始化匿名对象,写成左值，编译器认为是Person p5,对象的声明，写成右值表示赋值构造函数

    //隐式调用
    Person p7 = 100; //隐式类型转换，相当于Person p7 = Person(100);编译器找到一个有参构造进行转换
    Person p8 = p7; //相当于Person p8 = Person(p7);
}

　　注意事项：（1）无参构造函数使用：Person p2; 不能写成Person p2(); 编译器以为是声明，不是构造函数；（2）显示调用和隐式调用的区别；（3）匿名对象的特点

 拷贝构造函数使用的时机

　　（1）使用已经创建好的对象初始化新对象；（2）以值传递的方式来给函数参数传值；（3）以值方式返回局部对象（不常用，一般不返回局部对象）

//使用已经创建好的对象初始化新对象
void test03(){
    Person p1;
    p1.age = 10;
    Person p2(p1); 
}

//以值传递的方式来给函数参数传值
void dowork(Person p1){ //值传递方式，实际上形参是一个拷贝，因此Person p1 = Person(p);

}

void test04(){
    Person p;
    p.age = 10;
    dowork(p);
}

//以值方式返回局部对象
Person dowork2(){
    Person p1;
    return p1;
}

void test05(){
    Person p = dowork2();
}

　　对于使用已创建好的对象进行初始化对象时的补充：

void test01(){
    Person p1; //无参构造函数
    Person *p2 = new Person(p1); //拷贝构造函数

    Person *p3 = new Person(30); //有参构造函数
    Person *p4 = new Person(*p3); //拷贝构造函数

    Person p5 = p1; //拷贝构造函数
    Person *p6 = p3; //赋值指针，和p3操作指针地址相同
}

　　注意事项：第三种返回局部对象，一般Debug下是先21行使用无参构造，再22行返回对象的拷贝，然后Person p = p1；但Release下是先26行处理Person p；dowork2(Person &p)；然后再21行，只有无参构造。

构造函数的调用规则

　　系统会默认给一个类提供三个函数：默认构造函数（无参，函数体为空）、默认拷贝构造和析构函数（无参，函数体为空），其中默认拷贝构造可以实现简单的值拷贝。

　　提供了有参构造函数，就不提供默认构造函数；提供了拷贝构造函数，就不会提供其他构造函数。

深拷贝和浅拷贝

　　只有当对象的成员属性在堆区开辟空间内存时，才会涉及深浅拷贝，如果仅仅是在栈区开辟内存，则默认的拷贝构造函数和析构函数就可以满足要求。

class Person{
public:
    Person(){
    }

    //有参构造
    Person(char *name_, int age_){
        name = (char *)malloc(strlen(name_)+1);//可以直接调用现有的成员属性
        strcpy(name, name_);

        age = age_;
    }

    //自定义拷贝构造函数
    Person(const Person &a){
        age = a.age;
        name = (char *)malloc(strlen(a.name) + 1);
        strcpy(name, a.name);
    }

    ~Person(){
        if (name != NULL){
            free(name);
            name = NULL;
        }
    }

    char *name;
    int age;
};

void test05(){
    //这样的初始化是栈区初始化，默认拷贝构造函数和默认析构函数也是可以的
    //Person p;
    //p.name = "namnana";
    //p.age = 23;

    //调用有参构造这是堆区初始化，必须自定义拷贝构造函数和析构函数
    Person p("namnana", 23); 

    Person p1(p);
}

 　　具体原因则是默认构造函数只能实现值拷贝，因此涉及堆区开辟内存时，会将两个成员属性指向相同的内存空间，从而在释放时导致内存空间被多次释放，使得程序down掉。（与C语言中结构体的深拷贝和浅拷贝相同）

 初始化列表

　　一般通过有参构造进行初始化，另外也可以通过初始化列表进行初始化

class Person{
public:
    Person(){
    }

    //有参构造初始化数据
    Person(int a_, int b_, int c_){
        a = a_;
        b = b_;
        c = c_;
    }

    //1. 初始化列表进行初始化数据
    Person(int a_, int b_, int c_) : a(a_), b(b_), c(c_){}

    //2. 这种情况是固定参数初始化
    Person() :a(10), b(20), c(30){}

    int a;
    int b;
    int c;
};

void test05(){
    Person p1(10, 20, 30);//针对1.
    Person p2;//针对2.
}

　　类对象作为类成员属性，构造顺序先将对象一一构造，然后构造自己，析构的顺序是相反的。 

explicit关键字

　　为了防止构造函数中的隐式类型转换，加了explicit，只能显式调用

class Person{
public:
    Person(){
    }

    //有参构造初始化数据
    explicit Person(const char*str_){
        str = (char *)malloc(sizeof(char)*100);
        strcpy(str,str_);
    }

    ~Person() {
        if (str != NULL){
            free(str);
            str = NULL;
        }
    }

    char *str;
};

void test05(){
    //Person p = "abc"; 隐式调用

    Person p ("abc"); //显式调用
}