C++基础13-类和对象之继承1

在 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;
}
#endif

3继承的方式

#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