源代码：
class A {
public:
int A_a;
protected:
int A_b;
private:
int A_c;
};
class pub_B :public A {
public:
void test() {
A_a = 2;
A_b = 2;
A_c = 2; //无法访问
}
int pub_B_a;
protected:
int pub_B_b;
private:
int pub_B_c;
};
class pro_B :protected A {
public:
void test() {
A_a = 2;
A_b = 2;
A_c = 2; //无法访问
}
int pro_B_a;
protected:
int pro_B_b;
private:
int pro_B_c;
};
class B :private A {
public:
void test() {
A_a = 2;
A_b = 2;
A_c = 2; //无法访问
}
int pri_B_a;
protected:
int pri_B_b;
private:
int pri_B_c;
};
void Test() {
pub_B b1;
b1.A_a;
b1.A_b; //无法访问
b1.A_c; //无法访问
b1.pub_B_a;
b1.pub_B_b; //无法访问
b1.pub_B_c; //无法访问
pro_B b2;
b2.A_a; //无法访问
b2.A_b; //无法访问
b2.A_c; //无法访问
b2.pro_B_a;
b2.pro_B_b; //无法访问
b2.pro_B_c; //无法访问
pro_B b3;
b3.A_a; //无法访问
b3.A_b; //无法访问
b3.A_c; //无法访问
b3.pri_B_a;
b3.pri_B_b; //无法访问
b3.pri_B_c; //无法访问
}
实验总结：
子类不管以何种方式继承基类，都无法访问基类的私有成员。
二：友元类的继承测试：源代码：
#includeusing namespace std; class A { private : int A_a; //私有变量 friend class C; }; class B :public A { //类B继承类A private: int B_b; //私有变量 }; class C { public: void Test() { B b; C c; b.A_a; //b继承A类 } }; class D :public C { public: void Test() { A a; //创建对象A B b; //创建对象B } };
实验总结：
友元类：在一个类中，利用关键friend将其他类声明为友元。
友元关系不能传递，是单向的。
多态： 1.虚函数的多态性：源代码：
#include
using namespace std;
class animal { //创建动物类
public:
void sleep() {
cout << "animal sleep" << endl; //动物睡觉
}
virtual void breath() { //动物呼吸 （虚函数）
cout << "animal breath" << endl;
}
};
class fish :public animal { //创建鱼类继承动物
public:
void sleep() {
cout << "fish sleep" << endl; //鱼类睡觉
}
void breath() { //鱼类呼吸
cout << "fish breath" << endl;
}
};
int main() {
fish fh; //创建鱼类对象
animal* A = &fh;
A->sleep(); //测试
A->breath(); //测试
}
#includeusing namespace std; class animal { //创建动物类 public: void sleep() { cout << "animal sleep" << endl; //动物睡觉 } virtual void breath() { //动物呼吸 （虚函数） cout << "animal breath" << endl; } }; class fish :public animal { //创建鱼类继承动物 public: void sleep() { cout << "fish sleep" << endl; //鱼类睡觉 } void breath() { //鱼类呼吸 cout << "fish breath" << endl; } }; int main() { fish fh; //创建鱼类对象 animal* A = &fh; A->sleep(); //测试 A->breath(); //测试 }
运行结果：
2.析构函数的多态性
源代码：
#includeusing namespace std; class animal { //创建动物类 public: animal() { //构造函数 cout << "animal constructor" << endl; } virtual ~animal() { //虚析构函数 cout << "animal destructor" << endl; } void sleep() { cout << "animal sleep" << endl; //动物睡觉 } virtual void breath() { //动物呼吸 （虚函数） cout << "animal breath" << endl; } }; class fish :public animal { //创建鱼类继承动物 public: fish() { //构造函数 cout << "fish constructor" << endl; } ~fish() { //析构函数 cout << "fish destructor" << endl; } void sleep() { cout << "fish sleep" << endl; //鱼类睡觉 } void breath() { //鱼类呼吸 cout << "fish breath" << endl; } }; int main() { fish fh; //创建鱼类对象 animal* A = &fh; A->sleep(); A->breath(); delete A; //销毁指针 }
运行结果：
知识点总结：
- 继承，基类和派生类
（1）继承：描述的是两个类之间的关系，被继承的类称为父类，继承的类称为子类。
优点：提高代码的利用性，
提高代码的维护性，
让类与类之间产生关系，是多态的前提。
特性：
传递性：子类可以调用父类以及父类以上所有父类的属性和方法
单根性：一个子类不能同时继承两个或两个以上的父类
- 基类：（父类）
实现多态性，通过虚函数和继承机制，实现基类指针指向不同的子类对象。
特殊：为了实现类中的拷贝构造函数和赋值运算符不被调用的基类uncopyable;
不被设计为基类的类：string和STL容器都不被设计为基类使用‘’
- 派生类（子类）
- 友元关系与继承
- 基类和派生类转换，复制控制和继承，析构函数
（1）类型转换：公有派生类对象可以被当做基类的对象使用，反之不可。因为公有派生类 继承了 基类的东西，即派生类的内容比基类只多不少，基类的对象访问接口和派生类 的一样， 因此可以直接当做基类的对象使用。
派生类的对象可以隐含转化为基类对象
派生类的对象可以初始化基类的引用
派生类的指针可以隐含转化为基类的指针
通过基类的对象名，指针只能使用从基类继承的成员
