掘根宝典之C++包含对象的类，私有继承，保护继承，三大继承方式总结

包含对象成员的类

包含，组合和层次化：一个类里面的类成员之一是个类对象

我们来看个例子

#include
using namespace std;
class AA
{
private:
	int a_;
public:
	AA(int a):a_(a){}
	void A()
	{
		cout << a_ << endl;
	}
};
class BB
{
private:
	AA t;
	int b_;
public:
	BB(int a,int b):t(a),b_(b){}
	void B()
	{
		t.a_ = 9;//不可以，a_是AA类的私有成员，在BB类无法直接使用
		t = { 9 };//可以
		cout << b_ << endl;
		t.A();//可以直接调用AA类的公有函数
	}
};
int main()
{
	BB t(2, 3);
	t.B();
}

这里的访问权限可能会让大家有一点绕。实际上并没有。

我们把AA类视为类，把BB类视为main函数，这样子BB类对AA类的访问权限就明白了。

私有继承

在C++中，私有继承是一种继承方式，它定义了一个私有派生类，也称为派生类。私有继承意味着派生类继承了基类的所有成员，但这些成员在派生类中是私有的，对外部不可见。

要进行私有继承请使用private关键字，或者不使用任何关键字（因为private是默认值，因此省略访问限定符也将导致私有继承）

格式如下

class 派生类名:private 基类名
{
}


或者

class 派生类名:基类名
{
}

 使用私有继承时，只能在派生类的方法里使用基类的方法

私有继承允许使用类名和作用域解析运算符来调用基类的方法

我们看个例子

#include
using namespace std;
class AA
{
private:
	int a_;
public:
	AA(int a):a_(a){}
	void A()

	{
		cout << a_ << endl;
	} 
};
class BB :AA
{
private:
	int b_;
public:
	BB(int a,int b):AA(a),b_(b){}
	void B()
	{
		A();//可以
		AA::A();//可以
	}
};

int main()
{
	BB r(2, 3);
	r.B();

}

 我们怎么通过派生类访问基类对象呢？当然是用强制类型转换

我们看个例子

#include
using namespace std;
class AA
{
private:
	int a_;
public:
	AA(int a):a_(a){}
	void A()

	{
		cout << a_ << endl;
	} 
};
class BB :AA
{
private:
	int b_;
public:
	BB(int a,int b):AA(a),b_(b){}
	AA& B()
	{
		return (AA&)*this;//派生类强制转换为基类
	}
};

int main()
{
	BB r(2, 3);
	AA t=r.B();
	t.A();

}

在私有继承中，未进行显式类型转换的派生类引用或指针，无法赋值给基类的引用或指针

#include
using namespace std;
class AA
{
private:
	int a_;
public:
	AA(int a):a_(a){}
	void A()

	{
		cout << a_ << endl;
	} 
};
class BB :AA
{
private:
	int b_;
public:
	BB(int a,int b):AA(a),b_(b){}

};

int main()
{
	BB r(2, 3);
	AA& t = r;//这是不行的
	AA* y = &r;//这是不行的
}

 保护继承

保护继承是私有继承的变体。保护继承在列出基类时使用关键字protected:

class 派生类名:protected 基类名
{
}

使用保护继承时，基类的公有成员和保护成员都成为派生类的保护成员。和私有继承一样，基类的接口在派生类中也是可用的，但是在继承层次结构之外是不可用的。当从派生类派生出另一个类时，私有继承和保护继承的区别就体现出来了。使用私有继承时，第三代类将不能使用基类的接口，这是因为基类的公有方法在派生类中变成私有方法；使用保护继承时，基类的公有方法在第二代中变成受保护的，因此第三代派生类可以使用它们。 

三种继承方式的比较

公有继承(public)继承、私有继承(private)、保护继承(protected)是常用的三种继承方式。

1.公有继承(public)

　　公有继承的特点是基类的公有成员和保护成员作为派生类的成员时，它们都保持原有的状态，而基类的私有成员仍然是私有的，不能被这个派生类的子类所访问。

2.私有继承(private)

　　私有继承的特点是基类的公有成员和保护成员都作为派生类的私有成员，并且不能被这个派生类的子类所访问。

3.保护继承

　　保护继承的特点是基类的所有公有成员和保护成员都成为派生类的保护成员，并且只能被它的派生类成员函数或友元访问，基类的私有成员仍然是私有的。

三种不同继承方式的基类特性和派生类特性

	公有继承	保护继承	私有继承
公有成员变为	派生类的公有成员	派生类的保护成员	派生类的私有成员
保护成员变成	派生类的保护成员	派生类的保护成员	派生类的私有成员
私有成员变为	只能通过基类接口访问	只能通过基类接口访问	只能通过基类接口访问
能否隐式向上转换	是	是（但只能在基类里）	否

 注：隐式向上转换:意味着无需进行显式类型转换，就可以将基类指针或引用指向派生类对象

在上图中：

　　1.基类成员对派生类都是：public和protected的成员是可见的，private的成员是不可见的。

　　2.基类成员对派生类的对象来说：要看基类的成员在派生类中变成了什么类型的成员。如：私有继承时，基类的公有成员和私有成员都变成了派生类中的私有成员，因此对于派生类中的对象来说基类的公有成员和私有成员就是不可见的。为了进一步理解三种不同的继承方式在其成员的可见性方面的区别，下面从三种不同角度进行讨论。

对于公有继承方式

　　1.基类成员对其对象的可见性：公有成员可见，其他不可见。这里保护成员同于私有成员。

　　2.基类成员对派生类的可见性：公有成员和保护成员可见，而私有成员不可见。这里保护成员同于公有成员。

　　3.基类成员对派生类对象的可见性：公有成员可见，其他成员不可见。

　　所以：在公有继承时，派生类的对象可以访问基类中的公有成员；派生类的成员函数可以访问基类中的公有成员和保护成员。这里，一定要区分清楚派生类的对　　象和派生类中的成员函数对基类的访问是不同的。

对于私有继承方式

　　1.基类成员对其对象的可见性：公有成员可见，其他成员不可见

　　2.基类成员函数对派生类的可见性：公有成员和保护成员是可见的，而私有成员是不可见的。

　　3.基类成员对派生类对象的可见性：所有成员都是不可见的。

　　所以：在私有继承时，基类的成员只能由直接派生类访问，而无法向下继承。

对于保护继承方式

这种继承方式与私有继承方式的情况相同。两者的区别仅在于对派生类的成员而言，而对于基类成员有不同的可见性。(可见性也就是可访问性)。

关于可访问性还有另外一种说法。这种规则中，称派生类的对象对基类访问为水平访问，称派生类的派生类对基类的访问为垂直访问。

1 #include
 2 class A{
 3 private:
 4     int privatedataA;
 5 protected:
 6     int protecteddataA;
 7 public:
 8     int publicdataA;
 9 };
10 //基类A的派生类B(公有继承)
11 class B :public A{
12 
13 public:
14     void funcA()
15     {
16         int b;
17         b = privatedataA;
18         //错误：基类中的私有成员在派生类中不可见
19         b = protecteddataA;
20         //正确：基类的保护成员在派生类中是保护成员
21         b = publicdataA;
22         //正确：基类的公共成员在派生类是公共成员
23     }
24 };
25 //基类A的派生类C 私有继承
26 class C :private A{
27 
28 public:
29     void funcA()
30     {
31         int c;
32         c = privatedataA;
33         //错误：基类中的私有成员在派生类中不可见
34         c = protecteddataA;
35         //正确：基类的保护成员在派生类中是私有成员
36         c = publicdataA;
37         //正确：基类的公共成员在派生类是私有成员
38     }
39 };
40 //基类A的派生类D 保护继承
41 class D :protected A{
42 public:
43     void funcA()
44     {
45         int d;
46         d = privatedataA;
47         //错误：基类中的私有成员在派生类中不可见
48         d = protecteddataA;
49         //正确：基类的保护成员在派生类中是保护成员
50         d = publicdataA;
51         //正确：基类的公共成员在派生类是保护成员
52     }
53 };
54 void main()
55 {
56     int value;
57     B objB;
58     value = objB.privatedataA;//错误：基类的私有成员在派生类不可见，对对象不可见
59     value = objB.protecteddataA;//错误：基类的保护成员在派生类中是保护成员，对对象不可见
60     value = objB.publicdataA;//错误：基类的公共成员在派生类中是公共成员，对对象可见
61 
62     C objC;
63     value = objC.privatedataA;//错误：基类的私有成员在派生类不可见，对对象不可见
64     value = objC.protecteddataA;//错误：基类的保护成员在派生类中是私有成员，对对象不可见
65     value = objC.publicdataA;//错误：基类的公共成员在派生类中是私有成员，对对象不可见
66 
67     D objD;
68     value = objD.privatedataA;//错误：基类的私有成员在派生类不可见，对对象不可见
69     value = objD.protecteddataA;//错误：基类的保护成员在派生类中是保护成员，对对象不可见
70     value = objD.publicdataA;//错误：基类的公共成员在派生类中是保护成员，对对象不可见
71     system("pause");
72 }