类与对象（补充）

一、static成员
概念：声明为static的类成员成为类的静态成员（静态成员变量、静态成员函数）。
注：1.静态成员变量必须在类外定义，定义时不添加static关键字
  2.静态成员变量在对象生成之前生成
  3.静态成员为所有类对象所共享，不属于某个具体实例
  4.类静态成员访问方式：类名::静态成员 /对象.静态成员
  5.静态成员函数，没有this指针，不能访问任何非静态成员，只能访问静态成员
  6.静态成员也有public、private、protected三种访问级别，也可以具有返回值

class Test
{
public:
	Test(int data = 0) :m_data(data)
	{
		m_count++;//每构造一个对象就++，统计构造的对象个数
	}
	~Test()
	{
		m_count--;//每析构一个对象就--
	}
public:
	static int GetCount()//静态成员函数只能访问静态成员
	{
		return Test::m_count;
	}
private:
	int m_data;
	static int m_count;//静态成员变量是所有对象共享的
};
int Test::m_count = 0;

void main()
{
	Test t1;
	{
		//出了作用域t2，t3就被析构
		Test t2;
		Test t3;
		cout << Test::GetCount() << endl;//count = 3
	}
	cout << Test::GetCount() << endl;//count = 1
}

全局函数、友元函数、静态成员函数都没有this指针。

二、友元类
  “friend class 类名”
  友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员。
注：1.友缘关系是单向的。如，在A类中声明B类为其友元类，那么在B类中可以访问A类的非公有成员，但反过来不行。
  2.在A类中声明B类为其友元类时，要对B类做前置声明
  3.友元关系不能传递

class Stu;//前置声明

class Test
{
	friend class Stu;//友元类
public:
	Test()
	{}
private:
	void show()const
	{
		cout << "This is Test::show()" << endl;
	}
private:
	int m_a = 0;
	int m_b = 0;
};

class Stu
{
public:
	void fun(const Test &t)
	{
		t.show();//Stu为Test的友元类，可以直接访问Test的私有成员函数
	}
	void print(const Test &t)
	{
		t.show();
	}
private:
	int m_x = 0;
	int m_y = 0;
};

void main()
{
	Test t;
	Stu s;
	s.fun(t);
	s.print(t);
}

三、内部类
概念：如果一个类B定义在另一个类A的内部，那么类B就叫内部类。
注：1.内部类是外部类的友元类，内部类可以直接访问外部类中的static、枚举成员；但外部类不是内部类的友元
  2.内部类可以定义在外部类的public、protected、private
  3.sizeof（外部类）=外部类，与内部类没关系
  4.实例化内部类对象时，要加其外部类名称及作用域限定符

class A
{
public:
	class B
	{
	public:
		void show(const A &a)
		{
			cout << k<< endl;
			cout << a.m_a << endl;
		}
	private:
		int m_x;
	};
private:
	int m_a;
	static int k;
};
int A::k = 0;

void main()
{
	A::B b;//实例化内部类对象
	A a;
	b.show(a);
}