深入了解C++继承

private、public、protected和friend深入理解，不说话，直接上代码

//派生类（derived）分为单继承（inherit）和多继承。基类是对派生类的抽象，派生类是对基类的具体化，是基类的延续。派生类也可以看做是基类的组合（多继承）
//公有派生类的对象可以作为基类的对象处理。格式：class <派生类名称>:<继承方式><基类名>。继承方式：(virtual) private,public,protected.
/*
//继承的访问权限：
基类中的私有成员在派生类中是隐藏的，只能在基类内部访问，一般通过public函数访问
派生类中成员不能访问基类的private成员，但可以访问基类中的public和protected成员。
派生类从基类public继承时，基类的成员类型都不变，public\private\protected仍然是public\private\protected。
派生类从基类private继承时，基类的pbulic和protected成员都变成private成员。而基类的private成员不能被访问。
派生类从基类protected继承时，基类的public成员在派生类中变为protected成员，protected成员仍为protected成员。
*/
// //类和结构体的区别：类的成员默认为private，而结构体的成员默认为public
//关于继承：class的继承默认是private继承方式，而结构体是public继承方式

#include<iostream>
using namespace std;
class base
{
public:
//	base();
//	~base();
	void init() {};
	void inita(int x)
	{
		a = x;
	}
	int geta() { return a; }

private:
	int a;
};

class Derived :public base {   //public继承
public:
	void init() {};
	void initb(int y) { b = y; }
	int getb() { return b*geta(); }	//调用基类public成员
private:
	int b;	

};

class private_Derived :private base {	//private继承方式
public:
	void initc(int y, int x)
	{
		c = y;
		//a = x; 不合法，因为a是基类private成员 ，不能直接访问
		inita(x);  //合法
	}
	int getc()
	{
		return c*geta();//调用基类成员函数
	}
private:
	int c;
};

//protected成员 :private继承或public继承，都需要通过函数接口访问，这样很不方便，因此出现了protected成员：可以被本类或派生类的成员函数访问，但不能被外部函数访问。
class pro_base {
public:
	int a;
	void setbc(int x, int y)
	{
		b = x;
		c = y;
	}
	int getb() { return b; }
	int getc() { return  c; }
protected:
	int b;
private:
	int c;
};
//protected继承
class pbase_pro :/*protected*/ pro_base {
public:
	void setbcp(int x, int y, int z)
	{
		b = x;	  //b可以直接访问
		//c = y;//非法
		setbc(x, y);
		p = z;
	}
	int getp() 
	{ 
		p = p + b*getc();
		return p;
	}
private:
	int p;
};


//派生类直接访问基类成员：
//派生类不能直接访问基类private成员，若要访问必须使用基类的成员函数接口访问。但也是有方法的：
/*
直接访问基类private成员的方法有两种
1、增加基类protected成员。
2、将需要访问基类私有成员的派生类成员函数声明为友元。
*/
class fbase {	 //友元
public:
	int x;
	friend class Derived2;
protected:
	int y;
private:
	int z;
};
class Derived1 :virtual fbase {
public:
	//int getz() { return z; } //非法，基类私有成员不可以直接访问
	int gety() { return y; }  //基类protected成员派生类可以直接访问。
	int getx() { return x; }

};
class Derived2 :virtual fbase {
public:
	void setz(int a) { z = a; }	//直接访问
	int getx();
	int getz();
	int gety();
};
int Derived2::getx()
{
	return x;
}
int Derived2::getz()
{
	return z;//友元可以直接访问基类private成员
}
int Derived2::gety()
{
	return y; //基类protected成员可以被派生类直接访问
}


int main(int argc,char** argv)
{
	/*Derived de;//public继承使用案例
	de.inita(12);
	de.initb(5);
	cout << de.getb() << endl; 
	de.init();//默认调用派生类Derived中的init()
	de.base::init();//要调用基类中的init()必须加base::init()限定。*/

	/*private_Derived pd;	 //private继承使用案例
	//pd.geta();//非法
	pd.getc(); */

	/*pbase_pro ob; //protected继承使用 案例
	//ob.setbc();//非法，外部函数不可以直接访问 基类protected继承来的成员
	ob.setbcp(1, 2, 3);//合法
	cout << ob.getp()<<endl; */

	int i(0);//友元使用案例
	Derived2 fb;
	fb.setz(6);
	i = fb.getz();
	cout << i << endl;
	
	return	0;
}