C++继承

继承
#include <iostream>
using namespace std;
class Father
{
public:
	int a;
protected:
	int b;
private:
	int c;
public:
	Father()
	{
		a = 100;
		b = 200;
		c = 300;
	}
public:
	void show()
	{
		cout << a << " " << b << " " << c << endl;
	}
};
class Son : private Father //继承方式改变为protected
{
public:
	int d = 400;
public:
	void SSS()
	{
		cout << a << " " << b << " " << c << endl;//私有成员在子类中不能用 受保护成员可以
		cout << d << endl;
	}
};
class ss :  Son
{
public:
	void show()
	{
		cout << a << b << c << d << endl;
	}
};
//继承会继承父类成员并修改父类成员在子类成员中的属性       
// 继承方式      父类     子类     父类      子类         父类    子类
// public        public->public    protected->protected  private->不可见
// protected     public->protected protected->protected  private->不可见
// private       public->private   protected->private    private->不可见
//父类成员在子类中访问方式最高不会高过继承方式
//类的默认继承方式为private
int main()
{
	Son s;

	cout << sizeof(s) << endl;//16 4*4 abcd
	s.show();
	s.SSS();
}





继承的构造析构
#include <iostream>
using namespace std;
class Father
{
public:
	int a;
protected:
	int b;
private:
	int c;
public:
	Father(int n)
	{
		cout << "Father" << endl;
	}
	~Father()
	{
		cout << "~Father" << endl;
	}
public:
	void show()
	{
		cout << a << " " << b << " " << c << endl;
	}
};
class Son : public Father //继承方式改变为protected
{
public:
	int d = 400;
public:
	Son(int n) : Father(n) 
	{
		cout << "Son" << endl;
	}
	~Son()
	{
		cout << "~Son" << endl;
	}
};
//继承的构造析构顺序 父子~子~父 有参构造先传参要先给父类传参
//但s(10)会赋给子类先 由于初始化列表在构造函数执行前即可赋值 
// 所以用初始化列表提前赋值父类
int main()
{
	Son s(10);
	cout << s.d << endl;
	return 0;
}



继承重名问题：
#include <iostream>
using namespace std;
class Father
{
public:
	int a;
protected:
	int b;
private:
	int c;
public:
	Father()
	{
		a = 100;
	}
	~Father()
	{
		cout << "~Father" << endl;
	}
public:
	void show()
	{
		cout << a << " " << b << " " << c << endl;
	}
};
class Son : public Father //继承方式改变为protected
{
public:
	int a = 400;
public:
	Son() 
	{
		a = 200;
	}
	~Son()
	{
		cout << "~Son" << endl;
	}
};
//继承关系中如果父子类成员变量或函数重名 优先使用子类 
//如果想使用父类成员需要在成员名字前使用父类类名+：：（作用域）
int main()
{
	Son s;
	cout << s.a << endl;
	cout << sizeof(s) << endl;
	cout << s.Father::a << endl;
	return 0;
}


虚继承：  //多继承一般不太用于面向对象  一般就是分叉收口时用a-b a-c b-d c-d
#include <iostream>
using namespace std;
class AA
{
public:
	int a;
public:
	AA()
	{
		a = 100;
	}
};
class BB : virtual public AA 
{
public:
	int b = 200;
public:
	BB() 
	{
		b = 200;
	}
};
class CC : virtual public AA  //分叉虚继承
{
public:
	int c = 300;
public:
	CC()
	{
		c = 200;
	}
};
class DD : public BB,public CC     //多继承
{
public:
	int d = 400;
	DD()
	{
		d = 400;
	}
};
int main()
{
	DD dd;
	cout << dd.d << endl;
	cout << sizeof(dd) << endl; //bb 8 cc 8 dd 4 = 20 多继承数据冗余

	return 0;
}


类与结构体的区别：
struct FF  //类的默认访问修饰符private  安全级别大于结构体默认访问修饰符  public
{
public:
	int a;
public:
	FF()
	{
		a = 100;
	}
public:
	void show()
	{
		cout << "wp" << endl;
	}

};