c++构造函数和析构函数

#include<iostream>
#include<string>
#include<cstring>
using namespace std;

class Boy {
public:
	Boy(const char* pStr, int age) :age(age){
		str = new char[strlen(pStr) + 1];
		strcpy_s(str,strlen(pStr)+1, pStr);
	}
	void print() {
		cout << str << "\t" << age << endl;
	}
	~Boy();
protected:
	char* str;
	int age;
};
Boy::~Boy() {
	cout << "析构函数" << endl;
	delete[] str;
}

int main() {
	{
		Boy boy1("男孩", 21);//会调用析构函数
	}
	cout << "程序结束"<<endl;
	//new一个对象的时候，只有delete才会调用析构。
	{
		Boy* pObject = new Boy("大男孩", 21);
		delete pObject;
		pObject = nullptr;
	}
}

构造函数

构造函数基本形式

函数名和类名相同，没有返回值。

void print()的返回值是void（空）

如果不写构造函数每个类中默认有一个构造函数。

当自己写了构造函数是，默认构造函数自动删除。

构造函数无需手动调用，在构造对象的时候自动调用。

作用：构造对象（初始化数据成员）

构造函数重载（构造函数缺省）是为了构造不同长相的对象

为了更方便的构造不同对象，通常对构造函数缺省处理。

委托构造：允许构造函数调用另一个构造函数，只是要用初始化参数列表写法。

初始化参数列表（只有构造函数有）

构造函数名（参数一，参数二，。。。）;成员一（参数一），成员二（参数二）。。。。{}

避免形参名和数据成员名相同而导致问题。

#include<iostream>
using namespace std;

class Boy {
public:
	Boy(string boyname, int boyage) {
		name = boyname;
		age = boyage;
	}
	//Boy(){}
	Boy() = default;//使用系统默认无参构造函数； 
	void print() {
		cout << name << "\t" << age << endl;
	}

protected:
	string name = "帅哥";
	int age = 21;

};
class baby {
public:
	baby(string nName="", int nAge=21) {
		name = nName;
		age = nAge; 
	}
protected:
	string name;
	int age;
};
//初始化参数列表
string childName = "xiaoli";
class child {
public:
	child(string mname="", int mage=21) :name(mname), age(mage) {
		cout << "初始化参数列表" << endl;
		//继承和类的组合必须采用初始化参数列表
	}
	child(int mage):name(childName),age(mage){}//用全局变量来赋值也可以；
protected:
	string name;
	int age;
};
class man {
public:	
	man(string name,int age):name(name),age(age){}
	man() :man("默认",18) {}//调用上面的构造函数对数据初始化；委托构造
	void print() {
		cout << name << "\t" << age << endl;
	}
protected:
	string name;
	int age;
};
int main() {
	//Boy littleBoy;不能构造无参的了
	Boy littleBoy("boy1", 28);
	littleBoy.print();
	Boy littleBoy1; 

	baby baby1;
	baby baby2("小可爱");
	baby baby3("大可爱", 8);

	man man1;
	man1.print();
	return 0;
}

析构函数

 形式：

1.无返回值

2.无参数

3.函数名：~类名

不写的话也会存在一个默认的析构函数；

析构函数不需要自己调用，对象死亡之前会调用析构函数

析构函数作用：（什么时候需要手动写析构函数）

当类中数据成员是指针，并且动态申请了内存需要写析构函数

用来释放数据成员申请的动态内存（堆区内存）

new一个对象的时候，只有delete才会调用析构。

拷贝构造函数：

拷贝构造函数也是构造函数，形式是一样的，只是参数是固定的，唯一的参数是对对象的引用。

不写拷贝构造函数也存在一个默认的；        

作用：通过一个对象去初始化另一个对象

什么时候调用拷贝构造：

当通过一个对象去创建出另一个新对象的时候需要；

拷贝构造什么时候需要const修饰：

当存在匿名对象赋值操作的时候，必须要const修饰

深浅拷贝

浅拷贝：默认拷贝都是浅拷贝，会引发析构问题。

深拷贝：在拷贝构造函数中做了动态内存申请(把值拷贝到一个新的内存中去)

#include<iostream>
#include <cstring>
#include <string>
using namespace std;
class MM 
{
public:
	MM(const char* mname, int age) :age(age)
	{
		name = new char[strlen(mname) + 1];
		strcpy_s(name, strlen(mname) + 1, mname);
	}
	void print() 
	{
		cout << name << "\t" << age << endl;
	}
	MM(const MM& object) 
	{
		//name = object.name;
		name = new char[strlen(object.name) + 1];
		strcpy_s(name, strlen(object.name) + 1, object.name);
		//name = object.name;
		age = object.age;
	}
	~MM() 
	{
		delete[] name;
	}
protected:
	char* name;
	int age;
};
int main() 
{
	{
		MM mm("baby", 19);
		MM girl(mm);
		MM gm = mm;
		mm.print();
		girl.print();
		gm.print();
	}
	return 0;
}

构造顺序和析构顺序

普通对象，构造顺序与析构顺序相反

new出来的对象，delete会直接调用析构

static对象，最后释放，程序关闭的时候生命周期才结束

#include <iostream>
#include <string>
using namespace std;
class MM 
{
public:
	MM(string name="x") :name(name) {
		cout << name;
	}
	~MM(){
		cout << name;
	}
protected:
	string name;
};
int main() 
{
	{
		MM mm1("A");			//A
		static MM mm2("B");		//B   程序关闭时候才死亡，最后析构
		MM* p3 = new MM("C");	//C
		MM mm4[4];				//xxxx
		delete p3;				//C  delete 直接调用析构
		p3 = nullptr;
								//xxxxAB
	}
	//ABCxxxxCxxxxAB
	return 0;
}

c++结构体

#include <iostream>
#include <string>
using namespace std;
struct MM 
{
	//默认为公有属性
	//类中默认属性是私有属性
//protected:
	string name;
	int age;
public:
	MM(string name) :name(name) 
	{
		cout << "构造函数" << endl;
	}
	MM(const MM& object) 
	{
		name = object.name;
		age = object.age;	
		cout << "拷贝构造" << endl;
	}
	~MM() 
	{

	}
};


int main() 
{
	//采用创建时候赋值的方式，也是调用构造函数
	//MM object = { "lisa",19 };  错误，因为没有两个参数的构造函数
	MM  object = { "lisa" };
	cout << object.name << "\t" << object.age << endl;
	//C++结构体一旦写了构造函数，就必须按照C++类的方式的去用
	MM mm(object);
	cout << mm.name << "\t" << mm.age << endl;





	return 0;
}