【c++】类和对象3—初始化列表、类对象作为类成员、静态成员

---

初始化列表

作用：c++提供了初始化

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

#include<iostream>
using namespace std;

class Person
{
public:
	//1、传统初始化操作
	/*Person(int a, int b, int c) {
		m_a = a;
		m_b = b;
		m_c = c;
	}*/

	//2、初始化列表（固定数值 不易更改）
	/*Person() :m_a(10), m_b(20), m_c(30)
	{

	}*/

	//3、初始化列表（可以灵活更改）
	Person(int a, int b, int c) :m_a(a), m_b(b), m_c(c)
	{

	}
	
	int m_a;
	int m_b;
	int m_c;
};

void test()
{
	//1、
	//Person p(10, 20, 30);

	//2、
	//Person p;

	//3、
	Person p(30, 20, 10);

	cout << "m_a=" << p.m_a << endl;
	cout << "m_b=" << p.m_b << endl;
	cout << "m_c=" << p.m_c << endl;
}

int main()
{
	test();
	system("pause");
	return 0;
}

类对象作为类成员

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

构造的顺序：先调用对象成员的构造，再调用本类构造
析构的顺序：先调用本类构造，再调用对象成员的构造

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

class  Phone
{
public:
	Phone(string name)
	{
		m_PName = name;
		cout << "phone构造" << endl;
	}
	~Phone()
	{
		cout << "phone析构" << endl;
	}
	string m_PName;
};

class Person
{
public:
	//初始化列表可以告诉编译器调用哪一个构造函数
	Person(string name, string pName):m_Name(name),m_Phone(pName)
	{
		cout << "person构造" << endl;
	}
	~Person()
	{
		cout << "person析构" << endl;
	}

	void show()
	{
		cout << m_Name << "使用" << m_Phone.m_PName << "手机" << endl;
	}

	string m_Name;
	Phone m_Phone;
};

void test()
{
	//当类中成员是其它类对象时，我们称该成员为对象成员
	//构造的顺序：先调用对象成员的构造，再调用本类构造
	//析构的顺序：先调用本类构造，再调用对象成员的构造
	Person p("张三", "苹果x");
	p.show();
}

int main()
{
	test();
	system("pause");
	return 0;
}

输出：
phone构造
person构造
张三使用苹果x手机
person析构
phone析构

静态成员

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

静态成员分为：
1、静态成员变量
所有对象共享同一份数据；
在编译阶段分配内存；
类内声明，类外初始化。

#include<iostream>
using namespace std;

class Person
{
public:
	static int m_A;//静态成员变量

private:
	static int m_B;//静态成员变量也是有访问权限
};
//类内声明，类外初始化
int Person::m_A = 10;
int Person::m_B = 20;

void test()
{
	//静态成员变量两种访问方式
	//1、通过对象
	Person p1;
	cout << "p1.m_A=" << p1.m_A << endl;

	Person p2;
	cout << "p1.m_A=" << p1.m_A << endl;//共享一份数据
	cout << "p2.m_A=" << p2.m_A << endl;

	//2、通过类名
	cout << "m_A=" << Person::m_A << endl;
	//cout << "m_B=" << Person::m_B << endl;//私有权限访问不到
}

int main()
{
	test();
	system("pause");
	return 0;
}

输出：
p1.m_A=10
p1.m_A=10
p2.m_A=10
m_A=10

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

#include<iostream>
using namespace std;

class Person
{
public:
	//静态成员函数
	static void func()
	{
		cout << "func调用" << endl;
		m_A = 100;//静态成员函数可以访问静态成员变量
		//m_B = 100;//错误，静态成员函数不可以访问非静态成员变量，无法区分到底是那个对象的
	}
	static int m_A;//静态成员变量
	int m_B;//非静态成员变量
private:
	//静态成员函数也是有访问权限的
	static void func2()
	{
		cout << "fun2调用" << endl;
	}
};
int Person::m_A = 10;

void test()
{
	//静态成员变量两种访问方式
	//1、通过对象
	Person p1;
	p1.func();
	//2、通过类名
	Person::func();
	//Person::func2();//私有权限访问不到
}

int main()
{
	test();
	system("pause");
	return 0;
}

---