c++类和对象之对象的初始化和清理（构造函数和析构函数）

1、构造函数和析构函数

对象的初始化和清理是两个非常重要的安全问题，一个对象或者变量没有初始状态，对其使用后是未知的。
同样的使用完一个对象或变量，没有及时清理，也会造成一定的安全问题

c++利用的构造函数和析构函数解决上述问题，这两个函数将会被编译器自动调用，完成对象的初始化和清理工作。

• 对象的初始化和清理工作是编译器强制要我们做的事情，因此如果我们不提供构造和析构，编译器会提供编译器提供的构造函数和析构函数是空实现

//构造函数：主要作用在于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无需手动调用
//构造函数的语法：类名(){}
/*
1、构造函数，没有返回值
2、构造名称和类名相同
3、构造函数可以有参数，因此可以发生函数重载
4、程序在调用对象时候会自动调用构造，无需手动调用，而且只会调用一次
*/

//析构函数：主要作用在于对象销毁前系统自动调用，执行一些清理工作
//析构函数的语法：~类名(){}
/*
1、析构函数没有返回值
2、函数名称与类名相同，在名称前加上符号~
3、析构函数 不可以有参数，因此不可以发生重载
4、程序在对象销毁前会自动调用析构，无需手动调用，而且只会调用一次
*/

class Person{
public:
	//构造函数
	Person() {
		cout << "构造函数的调用" << endl;
	}


	//析构函数
	~Person() {
		cout << "析构函数的调用" << endl;
	}
};

void test01()
{
	Person p1;//局部变量，在栈上的数据，test01在执行完毕后，释放这个对象，会自动调用析构函数
}

//构造和析构函数都是必须有的实现，如果我们自己不提供，编译器会提供一个空实现的构造和析构！！！！！！！
int main()
{
	test01();

	Person p1;//main函数还没有执行完毕，所以不会执行析构函数

	system("pause");
	return 0;
}

这段代码的输出结果是
构造函数调用
析构函数调用
构造函数调用
请按任意键继续
析构函数调用

2、 构造函数的分类及调用

构造函数两种分类方式

按参数分为：有参构造和无参构造(无参又称为默认构造函数)
按类型分为：普通构造和拷贝构造

三种调用方式

括号法
显示法
隐式转换法

分类

class Person
{
public:
    int age = 0;
    //默认构造（普通构造）
    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;
    }

};

调用
1、括号法

//Person p;//默认函数构造调用
//Person p2(10);//有参构造函数调用
//Person p3(p2);//拷贝构造函数的调用

注意事项1、
调用默认构造函数时候，不要加();
Person p();不会创建对象 因为这行代码，编译器会认为是一个函数的声明！！！！

2、显示法

Person p1;
Person p2 = Person(10);//有参构造
Person p3 = Person(p2);//拷贝构造

等号右边 Person（10）；匿名对象 特点：当前行结束后，系统会立即回收匿名对象，立即析构

注意事项2、
不要利用拷贝函数构造函数初始化匿名对象 ;因为编译器认为Person(p3) 等价 Person p3; （对象的声明）
// Person(p3);//报错 重复声明

3、隐式转换法

Person p4 = 10;//相当于 Person p4 = Person（10）；  有参构造函数的调用
Person p5 = p4;//拷贝函数构造   

3、拷贝构造函数调用时机

c++中拷贝构造函数调用时机通常有三种：

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

class Person
{
public:
    int age = 0;
    //默认构造(普通构造)
    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;
    }
};

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

void test03()
{
    Person q1(20);
    Person q2(q1);
    cout << "p2的年龄" << q2.age<<endl;
}

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

void dowork(Person p)//这就相当于拷贝构造函数
{
    //但在这里拷贝出的q的值不会改变，因为是值传递
}

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

Person dowork()
{
    Person p;
    return p;//返回时，会调用拷贝构造函数
}

4、构造函数的调用规则

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

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

构造函数的调用规则如下

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

5、深拷贝和浅拷贝

面试可能遇到的问题！

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

class Person
{
public:
    int age = 0;
    int* height;
    //构造函数(普通构造)
    Person()//默认构造
    {
        cout << "Person的默认构造函数调用" << endl;
    }

    Person(int a,int h)
    {
        age = a;
        height = new int(h);
        cout << "Person的有参构造函数调用" << endl;
    }
    //浅拷贝（简单的复制操作）
    //Person(const Person& p)
    //{
    //    age = p.age;
    //    height = p.height;//在这里可能引发堆区内存重复释放的问题
    //    cout << "Person的拷贝构造函数调用" << endl;
    //}

    //利用深拷贝来解决浅拷贝问题
    Person(const Person& p)
    {
        age = p.age;
        //height = p.height;  简单的复制操作,编译器的默认操作
        height = new int(*p.height);//自己开辟空间，防止重复操作堆区内存空间
        cout << "Person的拷贝构造函数调用" << endl;
    }
    //析构函数
    ~Person()
    {
        //析构函数正是手动释放堆区内存的时机
        if (height != NULL)
        {
            delete height;
            height = NULL;
        }
        cout << "Person的析构函数调用" << endl;
    }
}；

！！！！
当有属性在堆区开辟内存时，会引发浅拷贝构造函数导致的错误，因为浅拷贝是简单拷贝工作，所以它存放的height的地址是同一块堆区内存，会重复释放同一块内存。所以要解决这一问题，我们要利用深拷贝构造函数来解决它，就是自己写一个拷贝构造函数，将复制的内存指向另外一块堆区内存
总结：如果有属性在堆区开辟的，要自己写一个深拷贝构造函数，防止浅拷贝带来的重复释放的问题

对象成员

c++类中的成员可以是另一个类的对象，我们称该成员为 对象成员
例如

class A{};
class B
{
    A a;
};

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

初始化列表

//m_Phone(pname)相当于 Phone m_Phone = pname;(隐式转换法)
	Person7(string name, string pname) :m_name(name), m_Phone(pname)

先构造成员对象，再构造自身
先析构自身，再析构类对象

静态成员

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

1、静态成员变量
    所有对象共享一份数据
	在编译阶段分配内存
	**类内声明，类外初始化**
2、静态成员函数
    所有对象共享一个函数
	静态成员函数只能访问静态成员变量

使用规则

class Person
{
public:
	//静态成员函数
	static void func()
	{
		m_a = 100;//静态成员函数可以访问 静态成员变量，所有对象共享一份数据
		//m_b = 200;  //静态成员函数，不可以访问非静态成员变量
		// 因为 静态成员函数只有一份数据，所有对象共享一个函数，当创建多个对象时，编译器无法区分是哪个对象的数据；
	}
	void func3()
	{
	}
	static int m_a;//静态成员变量
	int m_b;       //非静态成员变量


	//静态成员函数也是有访问权限的
private:
	static void func2()
	{
		cout << "static void func2()调用" << endl;
	}

};

int Person::m_a = 0;//静态成员变量再类内声明，类外初始化
//有两种访问方式
void test()
{
	//1、通过对象访问
	Person8 p;
	p.func();

	//2、通过类名访问
	Person::func();
	//Person::func2();   类外访问不到静态私有成员函数
	//Person::func3();   非静态成员函数 不能通过类名访问
}