C++ 继承与接口知识点小结（二）

矫情吗；* 2022-08-02 15:41 197阅读 0赞

#### 【摘要】 ####

本文主要解决以下几个方面知识点：理解面向对象范式下基本的设计模式；了解继承默认访问控制权限；熟悉派生类如何使用基类成员变量； 掌握 虚函数与纯虚函数在实例化上的必要性与差异性；了解虚函数与普通函数在创建过程中的区别；理解动态联编与静态联编在使用对象上的差异；掌握如何以及为何阻止对象实例化；了解RTTI的使用与特点；熟悉运算符重载的实现，熟悉不能重载的运算符有哪些。

#### 【正文】 ####

#### 检测并修改不适合的继承 ####

> **理解a part of、派生、a kind of、和has some kind of**
> 
> 例：如果鸟是可以飞的，那么鸵鸟是鸟吗？鸵鸟如何继承鸟类？
> 
> 分析：要鸵鸟来继承鸟类，采用组合的方法，把鸟类中的可以被鸵鸟继承的函数挑选出来，这样鸵鸟就不是 a kind of鸟了，而是has some kind of鸟的属性。
> 
>     #include <iostream>
>     #include <string>
>     using namespace std;
>     class bird
>     {
>         public:
>          void eat();
>          void sleep();
>          void fly();
>     };
>     
>     class ostrich
>     {
>         public:
>             bird eat(){cout << "ostrich eat";};
>             bird sleep(){cout << "ostrich sleep";};
>     };
>     
>     int main()
>     {
>         ostrich xiaoq;
>         xiaoq.eat();
>         xiaoq.sleep();
>         return 0;
>     }

> **例：若在逻辑上A是B的“一部分”（a part of），则不允许B从A派生，而是要用A和其它东西组合出B。眼（Eye）、鼻（Nose）、口（Mouth）、耳（Ear）是头（Head）的一部分，所以类Head应该由类Eye、Nose、Mouth、Ear组合而成，而不是派生而成。程序如下：**
> 
>     class Eye
>     {
>     public:
>     void Look(void);
>     };
>     
>     class Nose
>     {
>     public:
>     void Smell(void);
>     };
>     
>     class Mouth
>     {
>     public:
>     void Eat(void);
>     };
>     
>     class Ear
>     {
>     public:
>     void Listen(void);
>     };
>     
>     class Head
>     {
>     public:
>     void Look(void) { m_eye.Look(); }
>     void Smell(void) { m_nose.Smell(); }
>     void Eat(void) { m_mouth.Eat(); }
>     void Listen(void) { m_ear.Listen(); }
>     
>     private:
>     Eye m_eye;
>     Nose m_nose;
>     Mouth m_mouth;
>     Ear m_ear;
>     };
> 
> Head由Eye、Nose、Mouth、Ear组合而成。如果允许Head从Eye、Nose、Mouth、Ear派生而成，那么Head将自动具有Look、Smell、Eat、Listen这些功能。程序十分简短并且运行正确，但是下面这种设计方法却是不对的。
> 
>     class Head : public Eye, public Nose, public Mouth, public Ear
>     {
>     };

> **具体设计模式的基础设计方式**
> 
> **详见：[设计模式 创建型模式 知识点][Link 1]**
> 
> **详址：http://blog.csdn.net/u013630349/article/details/46844069**

> **类继承中私有继承是无法继承并使用父类函数中的公有变量的**

> 题：找出下面程序的错误，并解释它为什么是错的。
> 
>     #include <iostream>
>      using namespace std;
>     
>      class Base {
>         public:
>                 int val;
>                 Base() { val=1;};
>      };
>     
>      class Derive: Base {
>         public:
>                 int val;
>                 Derive(int i) { val=Base::val+i; };
>      };
>     
>      int main(int, char**, char**) {
>         Derive d(10);
>                 cout<<d.Base::val<<endl<<d.val<<endl;
>              return 0;
>      }

> 答案：把`class Derive: Base`改成`class Derive:public Base`。
> 
> 解析：这是个类继承问题。如果不指定public，**C++默认的是私有继承。私有继承是无法继承并使用父类函数中的公有变量的。**

> **子类中设定初始化成员变量**

> 题：（找出下面程序的错误，并解释它为什么是错的。）
> 
>     class base{
>      private: int i;
>      public:   base(int x){i=x;}
>     };
>     class derived: public base{
>      private: int i;
>      public:   derived(int x, int y) {i=x;}
>                void printTotal() {int total = i+base::i;}
>     };
> 
> 解析：要在子类中设定初始成员变量，把derived(int x, int y)改成derived(int x, int y) : base(x)。

> 答案如下：
> 
>     class base
>     {
>     protected: //这里的访问属性需要改变
>     int i;
>     public:  
>     base(int x){i=x;}
>     };
>     
>     class derived: public base
>     {
>      private: 
>        int i;
>      public:
>        derived(int x, int y) : base(x) //以前没有初始化基类的成员变量
>        {
>             i=y;         
>        }
>        void printTotal()
>        {
>             int total = i+base::i;
>        }
>     };

**纯虚函数**

> **虚函数与纯虚函数的比较**

> 详见：[C++ 虚函数与纯虚函数 浅析][C_ _]
> 
> 详址：http://blog.csdn.net/u013630349/article/details/47060705

> **什么是虚指针？**

> 虚指针是一个虚函数的实现细节，带有虚函数的类中的每一个对象都带有一个虚指针指向该类的虚函数表。

> **声明一个类Vehicle，使其称为抽象数据类型，写出类Car和Bus的声明，其中每个类都从类Vehicle里派生。使Vehicle成为一个带有两个纯虚函数的ADT,使Car和Bus不是ADT（抽象数据类型）**
> 
>     class Vehicle
>     {
>         public:
>             virtual void Move()=0;
>             virtual void Haul()=0;
>     };
>     class Car:public Vehicle
>     {
>         public:
>             virtual void Move();
>             virtual void Hual();
>     };
>     class Bus:public Vehicle
>     {
>         pulic:
>             virtual void Move();
>             virtual void Hual();
>     };
> 
>   
> **虚函数入口地址和普通函数有什么不同？**

> 每个虚函数都在vtable中占了一个表项，保存着一条跳转到它的入口地址的指令，当一个包含虚函数的对象被创建的时候，它的头部附加一个指针，指向vtable中相应的位置，调用虚函数的时候，不管你是用什么指针调用的，它先根据vtable找到入口地址再执行，从而实现了动态联编。
> 
> 但是普通函数简单跳转到一个固定的地址。
> 
> **补充：C++只有涉及到多态和虚拟函数就必须要使用动态联编，其他全是静态联编。**

> **C++如何阻止一个类被实例化？**
> 
> 使用抽象类，或者构造函数被声明为`private。`
> 
> **一般在什么时候构造函数被声明成 private 呢？**
> 
> 比如要阻止编译器生成默认的`copy constructor`的时候。
> 
> **什么时候编译器会生成默认的生成`copy constructor`**？
> 
> 只要自己没写，而程序中需要，都会生成。
> 
> **如果你写了一个构造函数，编译器还会生成`copy constructor`**吗？
> 
> 会生成。

**运算符重载和RTTI运行时类型识别**

> C++引入的额外开销主要体现
> 
> 1）编译时候的开销；
> 
> 2）运行时的开销
> 
> ①虚基类
> 
> ②虚函数
> 
> ③RTTI
> 
> ④异常
> 
> ⑤对象的构造和析构
> 
> **运行类型识别RTTI使用需要注意的问题**
> 
> **在分布式系统中，不适用RTTI的一个合理的解释是RTTI行为不可预期及缺乏扩展性。**
> 
> 1）用`typeid()`返回一个typeinfo对象，也可以用于内部类型，当用用于非多态类型时没有虚函数，用typeid返回的将是基类地址；
> 
> 2）不能对void指针进行映射；
> 
> 3）如果p是指针，`typeid(*p)`返回p所指向的派生类类型，`typeid(p)`返回基类类型；如果r是引用，`typeid(r)`返回派生类类型，`typeid(&r)`返回基类类型；
> 
> 4）C++里面的`typeid`运算符返回值是`type_info常量对象的引用。`
> 
> `详见：C++ 宏、范型和RTTI 浅析`
> 
> `详址：http://blog.csdn.net/u013630349/article/details/47071593`

运算符重载

**认识运算符重载**

> 所谓重载，就是重新赋予新的含义，函数重载就是对一个已有的函数赋予新的含义，使之实现新功能｡
> 
> **运算符的重载主要存在两种形式，一种是作为类的成员函数进行使用，另一种则是作为类的友元函数进行使用。**
> 
> **运算符的重载的形式：**

返回类型 operator 运算符符号（参数说明）
    {    
        //函数体的内部实现
    }

> 例如，能否用“+”号进行两个复数的相加，在C++中不能在程序中直接用运算符“+”对复数进行相加运算，用户必须自己设法实现复数相加。
> 
> **运算符重载运算符的运算规则**
> 
> 1）运算符重载函数也是函数，重载的运算符不会改变运算符的优先级、结合型和参数的个数。
> 
> 2）重载运算符不能违反语言的语法规则。
> 
> 3）赋值运算符除外，重载运算符可由派生类继承下去。
> 
> 4）重载运算符**不能使用默认参数。**
> 
> 5）运算符=、()、\[\]和->等操作符必须定义为类的成员函数，将这些操作符定义为友元函数将在编译时标记为错误。
> 
> 6）C++中不能重载的运算符只有5个:
> 
> **. (成员访问运算符)**
> 
> **.\* (成员指针访问运算符)**
> 
> **∷ (域运算符)**
> 
> **sizeof(长度运算符)**
> 
> **?: (条件运算符)**
> 
> 因为前两个运算符不能重载是为了保证访问成员的功能不能被改变,域运算符和sizeof运算符的运算对象是类型而不是变量或一般表达式,不具重载的特征｡
> 
> 7）**友元运算符的参数规则与类成员运算符的参数规则不同，一元运算符必须显示地声明一个参数**，二元运算符必须显示地声明两个参数。类成员运算符重载时，参数中隐含了一个this指针。（另外，C++规定，有的运算符（如赋值运算符、下标运算符、函数调用运算符）必须定义为类的成员函数，有的运算符则不能定义为类的成员函数（如流输入“>>”和流输出“<<”运算符、类型转换运算符））。
> 
> **重载为类的成员函数时，参数个数=原操作数个数-1（后置++、--除外）**，它可以通过this指针自由地访问本类的数据成员，可以少写一个函数的参数，但必须要求运算表达式的第一个参数（即运算符左侧的操作数）是一个类对象。
> 
> **重载为类的友元函数时，参数个数 = 原操作数个数，**且至少应该有一个自定义类型的形参。
> 
> **定义一个重载运算符函数参数表中参数的决定个数**
> 
> 取决于两个主要因素`operator@`
> 
> 1）运算符是一元的（一个参数）还是二元的（两个参数）
> 
> 2）运算符被定义为**全局函数**：对于一元运算符，一个参数；对于二元运算符是两个参数
> 
> 3）运算符是**成员函数**：对于一元运算符没有参数，对于二元元素符是一个参数
> 
> **如何重载增量运算符++和--**
> 
> 运算符`++`和`—-`有前置和后置两种形式，要使用`operator++( )`或`operator--( )`来重载前置运算符，使用`operator++(int)`或`operator--(int)`来重载后置运算符，调用时，参数int被传递给值0。
> 
> **重载流输入运算符和流输出运算符**
> 
> istream 类的对象cin;
> 
> ostream类的对象cout;
> 
> 如果想直接用“<<”和“>>”输出和输入自己声明的类型的数据，必须对它们重载，对“<<”和“>>”重载的函数形式如下：
> 
>     istream & operator >> (istream &，自定义类 &);
>     ostream & operator << (ostream &，自定义类 &);

> 重载运算符“>>”的函数的第一个参数和函数的类型都必须是istream&类型，第二个参数是要进行输入操作的类。
> 
> 重载“<<”的函数的第一个参数和函数的类型都必须是ostream&类型，第二个参数是要进行输出操作的类。
> 
> **只能将重载“>>”和“<<”的函数作为友元函数或普通的函数，而不能将它们定义为成员函数**。

[Link 1]: http://blog.csdn.net/u013630349/article/details/46844069
[C_ _]: http://blog.csdn.net/u013630349/article/details/47060705