C++中的继承

#include <iostream>
using namespace std;

class father
{
	public:
		int a;
	private:
		int b;
	protected:
		int c;
};

class son1 : public father
{
	public:
		void fun()
		{
			a = 10;		//父类中是公共权限，子类依然是公共权限
			cout << "公共继承，访问父类公共权限" << endl;
		//	b = 11;		//父类中是私有权限，子类无法访问
			c = 12;		//父类中是保护权限，子类依然是保护权限
			cout << "公共继承，访问父类保护权限" << endl;
		}
};

class son2 : protected father
{
	public:
		void fun()
		{
			a = 10;		//父类中是公共权限，子类变成保护权限
			cout << "保护继承，访问父类公共权限" << endl;
		//	b = 11;		//父类中是私有权限，子类无法访问
			c = 12;		//父类中是保护权限，子类依然是保护权限
			cout << "保护继承，访问父类保护权限" << endl;
		}
};

class son3 : private father
{
	public:
		void fun()
		{
			a = 10;		//父类中是公共权限，子类变成私有权限
			cout << "私有继承，访问父类公共权限" << endl;
		//	b = 11;		//父类中是私有权限，子类无法访问
			c = 12;		//父类中是保护权限，子类变成私有权限
			cout << "私有继承，访问父类保护权限" << endl;
		}
};

int main(void)
{
	son1 s1;
	s1.fun();

	son2 s2;
	s2.fun();

	son3 s3;
	s3.fun();
}

2.父类中所有非静态成员属性都会被子类继承，也就是说会分配空间，只是子类访问不到
3.继承的时候，先构造父类，再构造子类，析构的顺序和构造的顺序相反

1.继承同名成员处理方式
	访问子类的成员，直接访问即可		s.fun();			s.a
	访问父类的成员，加上父类的作用域		s.father::fun();		s.father::a

4.子类的构造函数必须要为父类的初始化成员变量传递参数

1.父类是有参构造函数，子类要为父类传递参数
#include <iostream>
#include <string.h>
using namespace std;

class A
{
	public:
		int a;
		A(int a)
		{
			this->a = a;
			cout << "A constructor" << endl;
			cout << "a = " << this->a << endl;
		}
};

class B : public A
{
	public:
		int b;
		B(int b) : A(b)		//第一种方式，传递一个参数，a和b的值相等，或者直接将b改成数字，直接赋值
		//B(int a, int c) : A(c)		第二种方式，传递两个参数
		{
			this->b = b;
			cout << "B constructor" << endl;
			cout << "b = " << this->b << endl;
		}
};

int main(void)
{
	B var(10);		//第一种方式，传递一个参数，a和b的值相等，或者直接将b改成数字，直接赋值
	//B var(10,11)		第二种方式，传递两个参数
}

2.若父类为无参构造函数，则可以不用传参
3.若父类为有参否早函数，子类不可以为默认构造函数，但可以是无参构造函数，且必须穿参数
B() : A(10);
B var;
以这种方式传参，且父类的参数只能是常数，不能在 main函数中指定

5.多继承的调用顺序

构造函数的调用顺序按照声明的顺序来
class B : public A, public C
{
	public:
		int b;
		B(int a, int b, int c) : C(c), A(a)		//a = 1, c = 3, b = 2，先调用A，后调用C，最后B
		{
			this->b = b;
			cout << "B constructor" << endl;
			cout << "b = " << this->b << endl;
		}
};

int main(void)
{
	B var(1, 2, 3);
}

6.继承中同名成员函数或者对象的调用方法

子类会屏蔽父类的同名成员函数，想要调用需要加上作用域
1.通过对象调用：
	s.fun();
	s.father::fun();
	s.m;
	s.father::m;
2.通过类名调用(静态变量或者静态函数可以不通过对象调用，当然也可以通过对象调用）
	son::fun();
	son::father::fun();
	son::m;
	son::father::m;