构造函数和析构函数的概述

类的数据成员不能在类的声明时候初始化,为了解决这个问题? 使用构造函数处理对对象的初始化。
构造函数是一种特殊的成员函数,与其他函数不同,不需要用户调用它,而是创建对象的时候自动调用。
析构函数是对象不再使用的时候,需要清理资源的时候调用。

构造函数
类的构造函数是类的一种特殊的成员函数，它会在每次创建类的新对象时执行。

构造函数的名称与类的名称是完全相同的，并且不会返回任何类型，也不会返回 void。构造函数可用于为某些成员变量设置初始值。

构造函数语法：

类名( ) {  }
1.构造函数，没有返回值也不写void
2.函数名称与类名相同
3.构造函数可以有参数，因此可以发生重载
4.程序在调用对象时候会自动调用构造，无需手动调用，而且只会调用一次

析构函数
析构函数语法：

~类名( ) {  }
1.析构函数，没有返回值，也不写void
2.函数名称与类名相同，在名称前加上符号~
3.析构函数不可以有参数，因此不可以发生重载
4.程序在对像销毁前会自动调用析构，无需手动调用，而且只会调用一次。

#include
using namespace std;
class Person
{
    
public:
   //1.构造函数
   Person()
   {
    
       cout << "构造函数的调用" << endl;
   }
   //2.析构函数
   ~Person()
   {
    
       cout << "析构函数的调用" << endl;
   }
};
int main()
{
    
   Person p;
   return 0;
}

执行结果：
在类创建时调用构造函数
在类销毁时调用析构函数

构造函数详解

两种分类方式：

按参数分为：有参构造和无参构造
按类型分为：普通构造和拷贝构造

#include
using namespace std;
class Person
{
    
public:
    //1.构造函数
    //无参构造（默认构造）
    Person()
    {
    
        cout << "构造函数的调用" << endl;
    }
    //有参构造
    Person(int a)
    {
    
        age = a;
    }
    //拷贝构造函数
    Person(const Person &p)
    {
    
        age =p.age;
    }
    int age;
};

构造函数的调用方法

三种调用方法：

括号法
显示法
隐示转换法

1.括号法

#include
using namespace std;
class Person
{
    
public:
    //1.构造函数
    //无参构造（默认构造）
    Person()
    {
    
        cout << "构造函数的调用" << endl;
    }
    //有参构造
    Person(int a)
    {
    
        age = a;
    }
    //拷贝构造函数
    Person(const Person &p)
    {
    
        age =p.age;
    }
    int age;
};
int main()
{
    
    //默认构造函数调用
    Person p1;
    //括号法
    Person p2(10);//调用有参构造函数
    Person p3(p2);//调用拷贝构造函数
    //注意事项
    //在调用默认构造函数时，不要加小括号()
    //比如： Person p();
    //因为编译器会认为这是一个函数声明，不会认为在创建对象。
        
    return 0;
}

2.显示法

#include
using namespace std;
class Person
{
    
public:
    //1.构造函数
    //无参构造（默认构造）
    Person()
    {
    
        cout << "构造函数的调用" << endl;
    }
    //有参构造
    Person(int a)
    {
    
        age = a;
    }
    //拷贝构造函数
    Person(const Person &p)
    {
    
        age =p.age;
    }
    int age;
};
int main()
{
    
    Person p1;
    //显示法
    Person p2 = Person(10);//有参构造
    Person p3 = Person(p2);//拷贝构造
    Person(10);  //称为匿名对象 特点：当前行执行结束后，系统会立即回收掉匿名对象
    //注意事项
    //不要利用拷贝构造函数初始化匿名对象
    // 比如：Person(p3);
    //原因：编译器会认为Person(p3);等价于Person p3;会报重定义的错误
    return 0;
}

3.隐式转换法

#include
using namespace std;
class Person
{
    
public:
    //有参构造
    Person(int a)
    {
    
        age = a;
    }
    //拷贝构造函数
    Person(const Person &p)
    {
    
        age =p.age;
    }
    int age;
};
int main()
{
    
    //隐式转换法
    Person p1 = 10;//有参构造
    Person p2 = p1;//拷贝构造
    system("pause");
    return 0;
}

拷贝构造函数的调用时机

C++中拷贝构造函数调用时机通常有三种情况

1.使用一个已经创建完毕的对象来初始化一个新对象
2.值传递的方式给函数参数传值
3.以值方式返回局部对象

#include
using namespace std;
class Person
{
    
public:
    Person()
    {
    
        cout << "person默认构造函数调用" << endl;
    }
    Person(int a)
    {
    
        age = a;
        cout << "person有参构造函数调用" << endl;
    }
    Person(const Person&p)
    {
    
        age = p.age;
        cout << "person拷贝构造函数调用" << endl;
    }
    ~Person()
    {
    
        cout << "person析构函数调用" << endl;
    }
    int age;
};

1.使用一个已经创建完毕的对象来初始化一个新对象

void test01()
{
    
    Person p1(20);
    Person p2(p1);
    cout << "p2的年龄为" << p2.age << endl;
}

2.值传递的方式给函数参数传值

void dowork(Person p)//此处传的是形参，会将实参拷贝一份，也就会出现拷贝构造函数
{
    

}
void test02()
{
    
    Person p;
    dowork(p);
}
int main()
{
    
    test02();
    return 0;
}

输出结果：

3.以值方式返回局部对象

Person dowork2()
{
    
    Person p1;
    return p1; //返回是以拷贝构造函数返回的
}
void test03()
{
    
    Person p = dowork2();
}
int main()
{
    
    test03();
    return 0;
}

输出：

构造函数的调用规则

默认情况下，c++编译器编译器至少给一个类添加三个函数

1.默认构造函数（无参，函数体为空）
2.默认析构函数（无参，函数体为空）
3.默认拷贝构造函数，对属性进行值拷贝

构造函数调用规则如下：

1. 如果用户定义有参函数，c++不再提供默认无参构造，但是会提供默认拷贝构造(切记)
2. 如果用户定义拷贝构造函数，c++不会再提供其他构造函数

#include
using namespace std;
class Person
{
    
public:
    int age;
};
int main()
{
    
    Person a1;
    a1.age = 18;
    Person a2(a1);  //编译器自己提供拷贝构造函数，会对属性进行值拷贝
    cout << a2.age << endl;
    system("pause");
    return 0;
}

深拷贝与浅拷贝

深拷贝：简单的赋值操作
浅拷贝：在堆区重新申请空间，进行拷贝操作

#include
using namespace std;
class Person
{
    
public:
    Person()
    {
    
        cout << "Person的默认构造函数" << endl;
    }
    Person(int a,int height)
    {
    
        age = a;
        Height=new int(height);
        cout << "Person的有参构造函数" << endl;
    }
    ~Person()
    {
    
        //将堆区开辟的数据进行释放
        if (Height != NULL)
        {
    
            delete Height;
            Height == NULL;
        }
        cout << "Person的析构函数" << endl;
    }
    int age;
    int* Height;
};
int main()
{
    
    Person a1(18,160);
    cout << a1.age << " " << *a1.Height << endl;
    Person a2(a1);
    cout << a2.age << " " << *a2.Height << endl;
    system("pause");
    return 0;
}

这段代码会报错，原因是空间被重复释放
这就是浅拷贝的局限
图解：

所以我们可以自己实现拷贝构造函数，实现深拷贝
代码如下：

#include
using namespace std;
class Person
{
    
public:
    Person()
    {
    
        cout << "Person的默认构造函数的调用" << endl;
    }
    Person(const Person&p)
    {
    
        age = p.age;
        Height = new int(*p.Height);
        cout << "Person的拷贝构造函数的调用" << endl;
    }
    Person(int a,int height)
    {
    
        age = a;
        Height=new int(height);
        cout << "Person的有参构造函数的调用" << endl;
    }
    ~Person()
    {
    
        //将堆区开辟的数据进行释放
        if (Height != NULL)
        {
    
            delete Height;
            Height==NULL;
        }
        cout << "Person的析构函数的调用" << endl;
    }
    int age;
    int* Height;
};
int main()
{
    
    Person a1(18,160);
    cout << a1.age << " " << *a1.Height << endl;
    Person a2(a1);
    cout << a2.age << " " << *a2.Height << endl;
    system("pause");
    return 0;
}