在 C++中可重用性(software reusability)是通过继承(inheritance)这一机制来实现的。 如果没有掌握继承性,就没有掌握类与对象的精华。
总结：
1、只要是父类中的private成员，不管是什么继承方式，儿子都访问不了，但它是存在在儿子之中的
2、如果是公有（public）继承， 儿子中的访问控制权限保持不变。
3、如果是保护(protected)继承, 儿子中父亲中除了private成员，其余在儿子中都是protected
4、如果是私有(private)继承， 儿子中的父亲的除了private成员，其余在二中都是private成员。
5、查看能否调用的//三看原则：
(1) 看调用的成员变量是在类的内部还是类的外部
(2) 看儿子继承方式，
(3) 当前变量在儿子中的变量在父亲中的访问控制权限
6、构造方法和析构方法不继承
5.1 类和类之间的关系
has-A，uses-A 和 is-A
has-A 包含关系，用以描述一个类由多个“部件类”构成。实现has-A关系用类成员表示，即一个类中的数据成员是另一种已经定义的类。
uses-A 一个类部分地使用另一个类。通过类之间成员函数的相互联系，定义友员或对象参数传递实现。
is-A 机制称为“继承”。关系具有传递性,不具有对称性。
5.2继承
类的继承,是新的类从已有类那里得到已有的特性。或从已有类产生新类 的过程就是类的派生。原有的类称为基类或父类,产生的新类称为派生类或子类。
派生类的组成：
派生类中的成员,包含两大部分,一类是从基类继承过来的,一类是自己增加的成员。从基类继承过过来的表现其共性,而新增的成员体现了其个性。
几点说明:
1,全盘接收,除了构造器与析构器。基类有可能会造成派生类的成员冗余,所以说基类是需设计的。
2,派生类有了自己的个性,使派生类有了意义。
5.3、 继承的⽅式
5.3.1 语法
class 派⽣类名:[继承⽅式] 基类名 {
派⽣类成员声明;
};
一个派生类可以同时有多个基类,这种情况称为多重继承,派生类只有一个基类, 称为单继承。
protected 对于外界访问属性来说,等同于私有,但可以派生类中可见。
public继承：
当类的继承方式为公有继承时,基类的公有和保护成员的访问属性在派生类中不变,而基类的私有成员不可访问。即基类的公有成员和保护成员被继承到派生类 中仍作为派生类的公有成员和保护成员。派生类的其他成员可以直接访问它们。无论派生类的成员还是派生类的对象都无法访问基类的私有成员。
protected继承：
保护继承中,基类的公有成员和私有成员都以保护成员的身份出现在派生类 中,而基类的私有成员不可访问。派生类的其他成员可以直接访问从基类继承来的 公有和保护成员,但是类外部通过派生类的对象无法访问它们,无论派生类的成员 还是派生类的对象,都无法访问基类的私有成员。
private继承：
当类的继承方式为私有继承时,基类中的公有成员和保护成员都以私有成员身份出现在派生类中,而基类的私有成员在派生类中不可访问。基类的公有 成员和保 护成员被继承后作为派生类的私有成员,派生类的其他成员可以直接 访问它们,但 是在类外部通过派生类的对象无法访问。无论是派生类的成员还是通过派生类的对 象,都无法访问从基类继承的私有成员。通过多次私有继承后,对于基类的成员都 会成为不可访问。因此私有继承比较少用。
private成员在子类中依然存在，但是却无法访问到。不论何种方式继承基类，派生类都不能直接使用基类的私有成员 。
如何恰当使用public，protected，private继承方式：
1、需要被外界访问的成员直接设置为public
2、只能在当前类中访问的成员设置为private
3、只能在当前类和子类中访问的成员设置为protected（protected成员的访问权限介于public和private之间。 ）
1类和类之间的关系
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
using namespace std;
class A
{
public:void func() {cout << "funcA" << endl;}int a;
};//类B拥有类A的成员变量， B has A ，//类B 依赖于 类A 依赖度高
class B
{
public:void funcB() {}A a;
};
//耦合度 高内聚 低耦合//类C 的成员方法 需要类A的形参， C use A,//类C 依赖于 类A
class C
{
public:void funcC(A *a) {}void funcC2(){}
};//D继承与A 类D 如果是继承类A 类 D is A 。//类D继承与A 耦合度很高
class D :public A
{
public:void funcD() {cout << this->a << endl;}};class E :public D
{
};
int main(void)
{return 0;
}2继承的基本概念
#if 1
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string>using namespace std;class Student
{
public:Student(){}Student(int id, string name){this->id = id;this->name = name;}void printS() {cout << "id = " << this->id << ", name = " << this->name << endl;}int id;
private:string name;
};//创建一个新的学生类，增加score、功能
class Student2
{
public:Student2(int id, string name, int score){this->id = id;this->name = name;this->score = score;}void printS() {cout << "id = " << this->id << ", name = " << this->name << endl;cout << "score = " << this->score << endl;}
private:int id;string name;//addint score;
};//通过继承创建一个新的学生类
class Student3 :public Student
{
public://Student3(int id, string name, int score) //{// this->id = id;// this->name = name; //无法访问父类的私有成员// this->score = score;//}Student3(int id, string name, int score) :Student(id, name) //利用父类的构造方法进行初始化部分数据成员{this->score = score;}void printS() {Student::printS();cout << "score = " << this->score << endl;}
private:int score;
};int main(void)
{Student3 s3(1, "zhang3", 80);s3.printS();return 0;
}
#endif3继承的方式
#if 1
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <memory>using namespace std;//规则1， 只要是父类中的private成员，不管是什么继承方式，儿子都访问不了
//规则2， 如果是公有（public）继承， 儿子中的访问控制权限保持不变。
//规则3， 如果是保护(protected)继承, 儿子中父亲中除了private成员，其余在儿子中都是protected
//规则4， 如果是私有(private)继承， 儿子中的父亲的除了private成员，其余在二中都是private成员。class Parent
{
public:int pub; //在类的内部 和 外部 都能访问。
protected:int pro; //在类的内部可以访问， 在类的外部不可以访问
private:int pri; //在类的内部可以访问， 在类的外部不可以访问
};//公有继承
class Child :public Parent
{
public:void func(){cout << pub << endl; //pub父类的public成员变量，在public继承 类的 【内部 外部】可以访问。
cout << pro << endl;//pro 是父类protected成员变量 在public继承类的 【内部】可以访问。外部访问不了 //此时的pro在孙子能够访问，说此时pro不是private成员，而是protected成员//cout << pri << endl; //pri 是父类private成员变量 在public继承类的 【内部,外部】[不]可以访问。}};//孙子类
class SubChild : public Child
{void sub_func(){cout << pro << endl;}
};//保护继承
class Child2 :protected Parent
{
public:void func2() {pub;//此时pub通过protected继承 能够在类的内部访问。 //pub 在类的内部可以访问， 类的外部访问不了， 类的儿子可以访问//pub 就是protected成员pro;//pro 根pub 是一样的性质，pro也是protected成员//pri;}
};class Sub_child2 :public Child2
{
public:void sub_func2() {pub;pro;}
};//私有继承
class Child3 :private Parent
{
public:void func3(){pub;//pub 在类的内部可以访问。在类的内部可以访问，类的外部不能访问。//pub 在儿子中访问不了，说明pub在Child3中是 私有成员pro;//pro 根pub的性质是一样， 也是私有成员。//pri;}
};class Sub_Child3 :public Child3
{
public:void sub_fun3(){//pub;//pro;}
};//三看原则：
//1 看调用的成员变量是在类的内部还是类的外部
//2 看儿子继承方式，
//3 当前变量在儿子中的变量在父亲中的访问控制权限int main(void)
{Child c1;c1.func();c1.pub;//c1.pri;Child2 c2;//c2.pub;//c2.pro;Child3 c3;//c3.pub;//c3.pro;c1.pub;return 0;
}
#endif
4继承方式的练习
#if 0
#include<iostream>
using namespace std;
class A
{
private:int a;
protected:int b;
public:int c;A(){a = 0;b = 0;c = 0;}void set(int a, int b, int c){this->a = a;this->b = b;this->c = c;}
};class B : public A
{
public:void print(){//cout << "a = " << a; //a是父类的私有成员访问不了cout << "b = " << b; //b 此时是保护成员，类的内部可以访问cout << "c = " << c << endl; //c 此时是公有成员，类的内部可以访问}
};class C : protected A
{
public:void print(){//cout << "a = " << a; //a是父类的私有成员访问不了cout << "b = " << b; //b 在子类中是protected权限，类的内部可以访问。cout << "c = " << c << endl; //c 子类的protected成员，类的内部可以访问。}
};class D : private A
{
public:void print(){//cout << "a = " << a; //a是父类的私有成员访问不了cout << "b = " << b << endl; //b 此时是private成员，类的内部可以访问。cout << "c = " << c << endl; //c 此时是private成员，类的内部可以访问。}
};int main(void)
{A aa;B bb;C cc;D dd;aa.c = 100; //c 是公有 ，类的外部可以访问。bb.c = 100; //Bpublic 继承与A ，保持权限不变，c 是公有， 类的外部可以访问//cc.c = 100;
//C protected 继承与A， c 在此类中是protected成员，类的外部不能访问。
//dd.c = 100; //D private 继承与A， c在此类中private成员，类的外部不能访问。aa.set(1, 2, 3); //set在父类中是公有权限，类外能访问bb.set(10, 20, 30); //set是public继承，在子类中是public权限，在类外能访问//cc.set(40, 50, 60); //set是protected继承，set在子类中是保护权限 类外不能否访问//dd.set(70, 80, 90); //set是private继承，set在子类中是私有权限 类外不能否访问bb.print(); //print 是定义在B类 public成员函数，在类的外部可以访问。cc.print(); //print 是定义在C类 public成员函数，在类的外部可以访问。dd.print(); //print 是定义在D类 public成员函数，在类的外部可以访问。return 0;
}
#endif
