class person{
protected:
	string _name;
	int _age;
};
class student :public person
{
public:
	int _No;
};
void test01()
{
	student sobj;
	//1.子類對象可以賦值給父類對象/指針/引用
	person pobj = sobj;
	person* pp = &sobj;
	person& rp = sobj;
	//2.基類對象不可以賦值給派生類對象
	//sobj = pobj;
	//3.基類的指針可以通過強制類型轉換賦值給派生類的指針
	pp = &sobj;
	student* ps1 = (student*)pp;//這種情況是可以的
	ps1->_No = 10;
	pp = &pobj;
	student* ps2 = (student*)pp;//這種情況轉換時雖然可以，但存在越界訪問的問題
	ps2->_No = 10;
}

class Base {
public:
	Base(){
		m_A = 100;
	}
	void func(){
		cout << "Base - func()調用" << endl;
	}
	void func(int a){
		cout << "Base - func(int a)調用" << endl;
	}
public:
	int m_A;
};
class Son : public Base {
public:
	Son(){
		m_A = 200;
	}
	//當子類與父類擁有同名的成員函數(shù)，子類會隱藏父類中所有版本的同名成員函數(shù)
	//如果想訪問父類中被隱藏的同名成員函數(shù)，需要加父類的作用域
	void func()
	{
		cout << "Son - func()調用" << endl;
	}
public:
	int m_A;
};
void test01()
{
	Son s;
	cout << "Son下的m_A = " << s.m_A << endl;
	cout << "Base下的m_A = " << s.Base::m_A << endl;
	s.func();
	s.Base::func();
	s.Base::func(10);
}

class Base {
public:
	static void func()
	{
		cout << "Base - static void func()" << endl;
	}
	static void func(int a)
	{
		cout << "Base - static void func(int a)" << endl;
	}
	static int m_A;
};
int Base::m_A = 100;
class Son : public Base {
public:
	static void func()
	{
		cout << "Son - static void func()" << endl;
	}
	static int m_A;
};
int Son::m_A = 200;
//同名成員屬性
void test01()
{
	//通過對象訪問
	cout << "通過對象訪問： " << endl;
	Son s;
	cout << "Son  下 m_A = " << s.m_A << endl;
	cout << "Base 下 m_A = " << s.Base::m_A << endl;
	//通過類名訪問
	cout << "通過類名訪問： " << endl;
	cout << "Son  下 m_A = " << Son::m_A << endl;
	cout << "Base 下 m_A = " << Son::Base::m_A << endl;
}
//同名成員函數(shù)
void test02()
{
	//通過對象訪問
	cout << "通過對象訪問： " << endl;
	Son s;
	s.func();
	s.Base::func();
	cout << "通過類名訪問： " << endl;
	Son::func();
	Son::Base::func();
	//出現(xiàn)同名，子類會隱藏掉父類中所有同名成員函數(shù)，需要加作作用域訪問
	Son::Base::func(100);
}

class person
{
public:
	person()
	{
		_count++;
	}
protected:
	string _name;
public:
	static int _count;//統(tǒng)計人數(shù)
};
int person::_count = 0;
class student:public person
{
protected:
	int _stuNum;
};
class graduate :public student
{
protected:
	string course;
};
void test()
{
	student s1;
	student s2;
	student s3;
	graduate s4;
	cout << "人數(shù)" << person::_count << endl;
	student::_count = 0;
	cout << "人數(shù)" << person::_count << endl;
}

class person
{
public:
	person(const char* name = "pxl")
		:_name(name)
	{}
	person(const person& p)
		:_name(p._name)
	{}
	person& operator=(const person& p)
	{
		if (this != *p){
			_name = p._name;
		}
		return *this;
	}
	~person()
	{}
protected:
	string _name;
};
class student :public person
{
public:
	student(const char* name, int num)
		:person(name)//顯示調用基類的構造函數(shù)初始化基類成員
		, _num(num)
	{}
	student(const student& s)
		:person(s)//注意這里有個隱式的切片操作 person& p = s;
		, _num(s._num)
	{}
	student& operator=(const student& s)
	{
		if (this != &s){
			person::operator=(s);//調用基類的operator=完成基類的賦值
			_num = s._num;
		}
		return *this;
	}
	~student()
	{
		cout << "~student()" << endl;
		//注意這里會自動調用父類析構
	}
protected:
	int _num;
};
void test()
{
	student s1("ppp", 20);
	student s2(s1);
	student s3("xxx", 30);
	s1 = s3;
}

class A{
public:
	int _a;
};
class B:public A
{
public:
	int _b;
};
class C :public A
{
public:
	int _c;
};
class D :public B, public C
{
public:
	int _d;
};
int main()
{
	D d;
	d.B::_a = 1;
	d.C::_a = 2;
	d._b = 3;
	d._c = 4;
	d._d = 5;
	system("pause");
	return 0;
}