C++学习——类对象作为类成员的案例、new运算符动态分配内存

类对象作为类成员

类对象作为类成员的时候 构造顺序是先将类对象一一构造，然后构造自己，析构的顺序是相反

//类对象作为类成员的案例
//类对象作为类成员的时候 构造顺序是先将类对象一一构造，然后构造自己，析构的顺序是相反
class Phone
{
public:
	Phone()
	{
		cout << "手机的默认构造函数调用" << endl;
	}
	Phone(string name)
	{
		mPhoneName = name;
		cout << "手机的构造函数" << endl;
	}
	~Phone()
	{
		cout << "手机的析构函数调用" << endl;
	}
	string mPhoneName;
};

class Game
{
public:
	Game()
	{
		cout << "游戏的默认构造函数调用" << endl;
	}
	Game(string name)
	{
		mGameName = name;
		cout << "游戏的构造函数" << endl;
	}
	~Game()
	{
		cout << "游戏的析构函数调用" << endl;
	}

	string mGameName;
};

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

	//初始化成员列表
	Person(string name, string phoneName, string gameName) : m_Name(name), m_Pone(phoneName), m_Game(gameName)
	{
		cout << "Person的构造函数" << endl;
	}

	void playGame()
	{
		cout << m_Name << "拿着" << m_Pone.mPhoneName << "玩" << m_Game.mGameName << endl;
	}

	~Person()
	{
		cout << "Person的析构函数调用" << endl;
	}
	string m_Name;  //这里如果用char *要考虑深拷贝和浅拷贝的问题 内部释放问题 用string就没事
	Phone m_Pone;
	Game m_Game;
};

void test01()
{
	//Person p;
	//p.m_Pone.mPhoneName = "华为";
	//p.m_Game.mGameName = "斗地主";
	Person p("老王", "华为", "斗地主");
	p.playGame();

}

explicit关键字的作用

加了explicit可以防止隐式类型转换

//explicit关键字作用
class MyString
{
public:
	MyString(const char * str)
	{

	}

	explicit MyString(int a)  //加了explicit可以防止隐式类型转换，即不能用MyString str3 = 10
	{
		mSize = a;
	}
	
	char * mStr;
	int mSize;
};
void test02()
{
	MyString str = "abc";  //相当于MyString str = MyString("abc")，隐式类型转换
	MyString str2(10);   //这样就比较明确是调用int类型的形参
	//MyString str3 = 10;// 做什么用途？？str2字符串为"10"，字符串的长度为10
}

new运算符动态分配内存

new和malloc的区别

1. new出来的对象，都会返回该类型的指针；malloc返回void* ，还要进行强转
2. new会调用构造函数；malloc不会调用构造函数
3. new是运算符；malloc是函数
4. new配合delete用， malloc配合free用

当用void* 接受new出来的指针，会出现释放的问题

可以通过new来开辟数组，用delete[] 释放；用new开辟数组一定要调用默认构造函数，所以一定要提供默认构造

//动态分配内存
//new运算符使用
class Student
{
public:
	Student()
	{
		cout << "默认构造函数" << endl;
	}

	Student(int a)
	{
		cout << "有参构造函数" << endl;
	}

	~Student()
	{
		cout << "析构函数" << endl;
	}
};
void test03()
{
	// (1)、new和malloc的区别
	//Student st;  //开辟的是栈区
	Student *st = new Student; //在堆区开辟

	//所有new出来的对象，都会返回该类型的指针
	//malloc返回void* ，还要进行强转
	//malloc会调用构造吗？  不会  new会调用构造
	//malloc是函数， new是运算符
	//释放堆区的空间是delete, delete也是运算符
	//new配合delete用， malloc配合free用
	delete st;

	// (2)、当用void* 接受new出来的指针，会出现释放的问题
	void *p = new Person;
	delete p; //这时候不会调用析构函数，无法释放


	// (3)、可以通过new来开辟数组
	// 但是需要特别注意的是，用new开辟数组一定要调用默认构造函数，所以一定要提供默认构造
	Student *nArray = new Student[10];

	//在栈上开辟数组，可以指定有参构造函数
	Student mArray[10] = { Student(1), Student(2) };

	//释放new出来的数组对象
	delete[] nArray;
	
}