类和对象-对象特性

Part1初始化列表

语法：

构造函数（）：属性1（值1），属性2（值2）。。。{}

class Person{
Person(int a,int b, int c):m_A(a),m_B(b),m_C(c){}
void print()
{cout<<"A"<<m_A<<endl;
cout<<"B"<<m_B<<endl;
cout<<"C"<<m_C<<endl;
}
private:
int m_A;
int m_B;
int m_C;

};
int main()
{Person p(10,20,30);
p.print();
return 0;
}

Part 2,类对象作为类成员

#include<iostream>
using namespace std;
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 print()
	{
		cout << m_name << "用" << m_phone.m_pname << endl;
	}string m_name;
	Phone m_phone;
};
void test()
{
	Person p("张三", "苹果");
	p.print();
}
int main()
{
	test();
	return 0;
}

构造的顺序是：先调用对象成员的构造，再调用本类构造，析构函数和构造相反

Part3:静态成员

静态成员变量

特点：

1，所有对象共享一份数据

2，在编译阶段分配空间

3，类内声明，类外初始化

class Person
{
public:
	static int m_A;
private:
	static int m_B;//静态成员变量也是有访问权限的
};
int Person::m_A = 10;
int Person::m_B = 10;
void test()
{//两种访问方式
//通过对象
	Person p1;
	p1.m_A = 100;
	cout << "p1:" << p1.m_A << endl;
	Person p2;
	p2.m_A = 200;
	cout << "p1:" << p1.m_A << endl;
	cout << "p2:" << p2.m_A << endl;
	//通过类名
	cout << "m_A:" << Person::m_A << endl;
}
	//cout<<"m_B"<<Person::m_B<<endl;//私有成员不可访问}
	int main()
	{
		test();
		return 0;
	}

静态成员函数：

特性：

1，程序共享同一个函数

2，静态成员函数只能访问静态成员变量

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 << "func2调用" << endl;
	}
};

	int Person::m_A = 10;
	void test()
	{//两种和访问方式
	//1，通过对象
		Person p1;
		p1.func();
		//2,通过类名
		Person::func();
		//Person::func2();//私有权限访问不到
	}
	int main()
	{
	test();
	return 0; }