【C++】构造函数和析构函数

对象初始化-构造函数

构造函数是类实例化的时候会自动调用的初始化函数，如果用户不写编译器会提供一个空实现的默认构造函数；

构造函数跟类名同名，可以传参，可以发生函数重载

class Animal {//这是一个类
public:
    Animal(){
        //这是构造函数    
    }
    ~Animal(){
        //这是析构函数    
    }
};

构造函数的分类

按传参区分：有参构造和无参构造

按类型区分：普通构造和拷贝构造

class Animal {//这是一个类
public:
    int age;
    Animal(){
        //这是普通构造/无参构造    
    }
    Animal(int a){
        //这是普通构造/有参构造    
    }
    Animal(const Animal& a){
        age = a.age;
        //这是拷贝构造/有参构造
	}
};

构造函数的调用

构造函数的调用方式有三种：

1、括号法

Animal dog(10);

2、显示法

Animal dog = Animal(10);

3、隐式转换法

Animal dog = 10;//等同于Animal dog = Animal(10);

拷贝构造的应用

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

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

   Animal dog(10);//初始化一个类
   //使用一个已经初始化完成的对象来初始化新对象
   Animal cat(dog);//把初始化完成的对象当传输传入
   

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

   void fun(Animal p){
   	//当实参传入函数给形参是，会触发拷贝构造函数
   }
   int main(){
   	Animal dog;//实例一个对象
   	fun(dog);//将对象当实参传入函数
   }
   

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

   Animal fun()
   Animal dog;
   return dog;//返回类
   //函数调用的地方应该用Animal对象接收，不用考虑函数结束堆栈释放数据问题
   }
   int main(){
   	Animal cat = fun();//相当于隐式转换法Animal cat = dog;
   }
   

构造函数调用规则

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

1．默认构造函数(无参，函数体为空)

2．默认析构函数(无参，函数体为空)

3．默认拷贝构造函数，对属性进行值拷贝

构造函数调用规则如下：

如果用户定义有参构造函数，c++不在提供默认无参构造，但是会提供默认拷贝构造

如果用户定义拷贝构造函数，c++不会再提供其他构造函数

深拷贝和浅拷贝

浅拷贝：简单的赋值拷贝操作

深拷贝：在堆区重新申请空间，进行拷贝操作

class Animal {//这是一个类
public:
    int* age;//用于申请内存
public:
    Animal(int a){ //这是有参构造  
        age = new int(a);//申请内存
    }
//如果不写拷贝构造函数，系统使用默认构造函数，那么使用的就是浅拷贝，相当于把age的内存地址直接复制给新对象的age
//这样会导致重复释放堆区问题，一个对象释放掉了，另一个对象再释放就会报错
    Animal(const Animal& a){//定义拷贝构造
        //age = a.age//编译器自带的浅拷贝，直接赋值
        age = new int(*a.age);//深拷贝，重新申请内存
    }
    ~Animal(){//析构函数，释放内存
        if(age != NULL){
            delete age;
        }
    }
};

总结：如果属性有在堆区开辟的，一定要自己提供拷贝构造函数，防止浅拷贝带来的问题

初始化列表

作用： C++提供了初始化列表语法，用来初始化属性

语法： 构造函数()：属性1(值1),属性2（值2）… {}

示例：

class Animal {
public:
传统方式初始化
//Person(int a, int b, int c) {
// m_A = a;
// m_B = b;
// m_C = c;
//}
    
//初始化列表方式初始化
Animal (int a, int b, int c) :m_A(a), m_B(b), m_C(c) {}

private:
int m_A;
int m_B;
int m_C;
};

int main() {
Animal dog(1, 2, 3);
}

类对象作为类成员

class A {
	//这是第一个类
}
class B
{
	A a；//第二个类成员是第一个类
}

B类中有对象A作为成员，A为对象成员

那么当创建B对象时，A对象的构造函数先调用，也就是说，要想实例B对象，B对象需要的成员必须先存在

在释放B对象时，B对象的析构函数先调用，先把大的结构释放了，再释放小的部分；如果小的先被释放，大的对象还存在，此时调用大的必然会出异常；

静态成员

静态成员就是在成员变量和成员函数前加上关键字static，称为静态成员

静态成员分为：

**静态成员变量 **

• 所有对象共享同一份数据
• 在编译阶段分配内存
• 类内声明，类外初始化

class Person
{
public:
//静态成员函数特点：
//1 程序共享一个函数
//2 静态成员函数只能访问静态成员变量
    static void func()
    {
        m_A = 100;//访问静态成员变量
        //m_B = 100; //错误，不可以访问非静态成员变量
    }
	static int m_A; //静态成员变量，类内声明
    int m_B; 
private:
//静态成员函数也是有访问权限的
    static void func2()
    {
    	cout << "func2调用" << endl;
    }
};
int Person::m_A = 10; //静态成员变量，类外定义
void test01()
{
//静态成员变量两种访问方式
//1、通过对象
Person p1;
p1.func();
//2、通过类名
Person::func();
//Person::func2(); //私有权限访问不到
}
int main() {
test01();
system("pause");
return 0;
}

**静态成员函数 **

• 所有对象共享同一个函数
• 静态成员函数只能访问静态成员变量

对象释放-析构函数

析构函数是类释放的时候会调用的函数；比如在函数里实例的类，函数结束时类也会跟着一起释放，就是调用析构函数；如果用户不写编译器会提供一个空实现的默认析构函数；

析构函数名跟类名很像，只是前边多了一个~符号，析构函数不能传参，故也不能发生函数重载

class animal {//这是一个类
public:
    animal(){
        //这是构造函数    
    }
    ~animal(){
        //这是析构函数    
    }
};