C++构造函数梳理

构造函数

#include <iostream>
using namespace std;
class Person
{
public:
	//构造函数	
	Person();

	//析构函数	
	~Person();

private:

};

//构造函数	
//1. 没有返回值  不用写void
//2. 函数名 与 类名相同
//3. 可以有参数  ，可以发生重载
//4. 构造函数 由编译器自动调用一次 无须手动调用
Person::Person()
{
	cout << "Person的构造函数调用" << endl;
}

//析构函数
//1. 没有返回值   不用写void
//2. 函数名 与类名相同  函数名前 加 ~
//3. 不可以有参数 ，不可以发生重载
//4.析构函数 也是由编译器自动调用一次，无须手动调用
Person::~Person()
{
	cout << "Person的析构函数调用" << endl;
}

//执行完后，会调用析构函数。原因：栈中创建的内容，会在函数调用结束后释放
void test()
{
	Person p;
}

int main() {
	test();
	return 0;
}

构造函数分类

1. 按照参数分类： 无参构造(默认构造函数) 和 有参构造
2. 按照类型分类： 普通构造函数、拷贝构造函数

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

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

	Person(int age)
	{
		m_Age = age;
		cout << "Person的有参构造函数调用" << endl;
	}


	//拷贝构造函数,加const是为了避免修改实参（本体）对象的值，而使用引用是因为函数调用本身为值传递（本质是拷贝），
    //若使用对象会造成函数调用时在值传递过程中会循环调用
	Person(const Person &p)  
	{
		cout << "Person的拷贝构造函数调用" << endl;
		m_Age = p.m_Age;
	}

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

	int m_Age;
	
};

int main(){
	test();
	//Person p(18);
	//Person p2(p);
	//cout << "p2的年龄： " << p2.m_Age << endl;


	system("pause");
	return EXIT_SUCCESS;
}

构造函数的调用

//构造函数的调用
void test()
{     
	Person p;

	//1、括号法
    //注意事项一 
	//不要用括号法 调用无参构造函数  Person p3();  编译器认为代码是函数的声明
	Person p1(10);
	Person p2(p);

	//2、显示法
	Person p3 = Person(10); //有参构造
	Person p4 = Person(p3); //拷贝构造
    //p3,p4在栈中创建，遵循先进后出规则，所以先调用p3的构造函数，再调用p4的构造函数，然后调用p4的析构函数再调用p3的析构函数

	Person(10); //匿名对象  特点： 当前行 执行完后 立即释放

	//注意事项二
	//不要用拷贝构造函数 初始化 匿名对象 Person(p3); 编译器认为Person(p3) ==> Person p3对象实例化,如果已经有p3  p3就重定义

	
	//3、隐式法  不建议使用，可读性不高
	Person p5 = 10; //Person p5 = Person(10);
    //拷贝构造
	Person p6 = p5;

}

拷贝构造函数的调用时机

//1、用已经创建好的对象来初始化新的对象
void test()
{
	Person p1(18);

	Person p2 = Person(p1); // 等价 Person p2 = p1;    

	cout << "p2的年龄：" << p2.m_Age<< endl;

}

//2、值传递的方式 给函数参数传值，会调用拷贝构造函数
void doWork(Person p)
{

}
void test02()
{
	Person p1(100);

	doWork(p1);

}

//3、以值方式 返回局部对象
Person doWork2()
{
	Person p;
	return p;//当返回p的时候会调用拷贝构造，返回一个新的Person对象给调用方
}

void test03()
{
	Person p = doWork2(); //返回一个新的Person对象给调用方并命名为p
}

/*	
	编译器优化代码后 release版本代码类似以下：
	void doWork2( Person &p ){};

	Person p;
	doWork2(p);
*/

构造函数使用规范

1. 编译器会给一个类 至少添加3个函数： 默认构造（空实现）、析构函数（空实现） 、 拷贝构造（对所有的属性进行值拷贝，逐字节拷贝）

2. 如果我们自己提供了 有参构造函数，编译器就不会提供默认构造函数，但是依然会提供拷贝构造函数

3. 如果我们自己提供了 拷贝构造函数，编译器就不会提供其他构造函数（ 默认构造（空实现））

深拷贝浅拷贝

深拷贝与浅拷贝的问题以及解决

1. 如果有属性开辟到堆区，利用编译器提供拷贝构造函数会调用浅拷贝来复制对象，自定义析构函数释放对象时，析构函数会重复释放堆区内存

2. 利用深拷贝解决浅拷贝问题

3. 自己提供拷贝构造函数，实现深拷贝

class Person
{
public:

	Person( char * name ,int age )
	{
		m_Name = (char *) malloc(strlen(name) + 1);

		strcpy(m_Name, name);

		m_Age = age;
	}

	/*
	*自定义析构函数，未复制的对象在堆区开辟新人空间
	*/
	Person(const Person&p)
	{
	   m_Name =(char*)malloc(strlen(p.m_Name) + 1);
	   strcpy(m_Name, p.m_Name);
	   m_Age = p.m_Age;
	}

	~Person()
	{
		if (m_Name != NULL)
		{
			cout << "Person析构调用" << endl;
			free(m_Name);
			m_Name = NULL;
		}
	}

	char * m_Name; //姓名
	int m_Age;     //年龄
};


void test01()
{
	Person p("德玛西亚", 18);
	cout << "姓名： " << p.m_Name << " 年龄： " << p.m_Age << endl;

	Person p2(p);
	cout << "姓名： " << p2.m_Name << " 年龄： " << p2.m_Age << endl;
}

深拷贝

进行深拷贝时会在堆区创建两块内存用来存储m_name的内容，p1,p2对象引用的是不同的地址。而使用浅拷贝时，使用的时同一块内存地址，p1在销毁时正常，p2在销毁是调用析构函数时会报错误。