继承和多态

1. 继承的优缺点

优点：
（1）子类可以灵活地改变父类中的已有方法；
（2）能够最大限度的实现代码重用。
缺点：
（1）子类无法在运行时改变与父类的继承关系；
（2）修改父类的某些方法，可能会影响到所有的子类；
（3）继承会使系统的架构层次增多，给开发和维护带来困难。

2. 子类不能继承父类的私有成员，只能通过父类的成员函数来访问父类的私有成员

3. 继承方式

在从父类派生一个子类时可以有 3 种派生方式。分别为 public、private 和 protected 。其中 public 派生方式表示父类中的公有方法和受保护方法仍然为私有方法、共有方法和受保护方法。private 派生方式表示父类中的公有方法、受保护方法在子类中都是私有的。protected 派生方式表示示父类中的公有方法、受保护方法在子类中都是受保护的。

4. 如何访问被隐藏的基类成员？

#include <iostream>
#include <cstring>

#define MAXLEN 128 //定义一个宏

using namespace std;

class CEmployee //定义员工类
{
protected: //定义 protected 数据成员
    char m_szName[MAXLEN]; //定义员工姓名
public:
    CEmployee() //定义默认构造函数
    {
        memset(m_szName, 0, MAXLEN); //初始化 m_szName
    }
    void SetName(const char* pszName) //设置员工姓名
    {
        strcpy(m_szName, pszName);
    }
    char* GetName()const //获取员工姓名
    {
        return (char*) m_szName;
    }
    void OutputName() //输出员工姓名
    {
        cout << "CEmployee-->员工姓名: " << m_szName << endl;
    }
};

class COperator : public CEmployee //定义一个操作员类，从 CEmployee 类派生而来
{
private:
    char m_szPassword[MAXLEN]; //定义密码
public:
    COperator() //构造函数
    {
        memset(m_szPassword, 0, MAXLEN);
    }
    void SetPassword(const char* pszPassword) //设置密码
    {
        strcpy(m_szPassword, pszPassword);
    }
    char* GetPassword()const //获取密码
    {
        return (char*) m_szPassword;
    }
    bool Login() //定义登录方法
    {
        if (strcmp(m_szName, "MR")==0 //比较用户名
            && strcmp(m_szPassword, "KJ")==0) //比较密码
        {
            cout << "登录成功!" << endl; //输出信息
            return true; //设置返回值
        }
        else
        {
            cout << "登录失败!" << endl; //输出信息
            return false; //设置返回值
        }
    }
    void OutputName() //输出员工姓名
    {
        cout << "COperator-->员工姓名: " << m_szName << endl;
    }
};

int main(int argc, char* argv[])
{
    COperator Operator;
    Operator.SetName("sk");
    Operator.OutputName();
    return 0;
}

上述代码中 CEmployee 类和 COperator 类都定义了一个 OutputName() 方法。在 main 函数中执行 Operator.OutputName(); 语句将访问的是子类（COperator 类）中的方法，请对该语句进行修改，使其能够访问父类（CEmployee 类）中的 OutputName() 方法。

在本题中，父类 CEmployee 定义了一个 OutputName() 公有方法。子类 COperator 又定义了一个 OutputName() 方法。那么在子类中将存在两个 OutputName() 方法。默认情况下，子类对象调用的 OutputName 方法将是子类中定义的方法。如果需要访问父类中的方法需要进行强制类型转换。
例如：

((CEmployee)Operator).OutputName();

5. 构造函数和析构函数的调用顺序

请写出下面代码的运行结果。

#include <iostream>

using namespace std;

class A
{
public:
    A()
    {
        cout << "A 构造函数被调用！" << endl;
    }
    ~A()
    {
        cout << "A 析构函数被调用！" << endl;
    } 
};

class B : public A
{
public:
    B()
    {
        cout << "B 构造函数被调用！" << endl;
    }
    ~B()
    {
        cout << "B 析构函数被调用！" << endl;
    } 
};

class C : public B
{
public:
    C()
    {
        cout << "C 构造函数被调用！" << endl;
    }
    ~C()
    {
        cout << "C 析构函数被调用！" << endl;
    } 
};

int main(int argc, char* argv[])
{
    C object;
    return 0;
}

输出结果为：

A 构造函数被调用！
B 构造函数被调用！
C 构造函数被调用！
C 析构函数被调用！
B 析构函数被调用！
A 析构函数被调用！

类 C 继承自类 B，而类 B 又继承自类 A 。当构建一个 C 对象时，将至顶向下执行基类的构造函数，最后执行自身的构造函数。因此，本题中将首先调用类 A 的构造函数，然后调用类 B 的构造函数，最后调用类 C 的构造函数。当 C 类对象释放时，将至下向上执行析构函数。本题中将首先调用 C 类的析构函数，然后调用 B 类的析构函数，最后调用 A 类的析构函数。

6. 子类和父类的关系

下面有关基类与其派生类的叙述中，正确的是：
A．派生类对象不能赋给基类对象
B．派生类对象的地址不能赋给其基类的指针变量
C．基类对象不能赋给派生类对象
D．基类对象的地址能赋给其派生类的指针变量

选 C

子类在继承基类时，通常会额外添加一些属性或方法。也就是子类除了具有基类的功能外，还添加了一些自己的功能。将子类对象赋值给基类对象是完全合法的，因为基类能够访问到它所定义的方法。与之相反，将一个基类赋值给子类对象是非法的，因为子类具有基类不具备的行为。上述描述中选项 A 是错误的，选项 C 是正确的。选项 B 和选项 D 围绕的对象的地址赋值。这其实与对象间的赋值原理是相同的。子类对象的地址是可以赋值给基类指针对象的，而基类对象的地址是不能够赋值给子类指针对象的。所以选项 B 和选项 D 都是错误的。

7. 动态绑定

请写出下面代码的运行结果。

#include <iostream>

using namespace std;

class Shape
{
public:
    Shape()
    {
        cout << "Shape was invoked!" <<endl;
    }
    virtual void Draw()
    {
        cout << "Draw Shape!" << endl;
    }
};

class Circle : public Shape
{
public:
    Circle()
    {
        cout << "Circle was invoked!" << endl;
    }
    void Draw()
    {
        cout << "Draw Circle!" << endl;
    }
};

int main(int argc, char* argv[])
{
    Shape *shape = new Circle(); //定义一个基类指针对象
    shape->Draw(); //调用 Draw 方法
    delete shape; //释放对象
    return 0;
}

输出结果是：

Shape was invoked!
Circle was invoked!
Draw Circle!

本题中关键代码是 main 函数中的前两行语句。

Shape *shape = new Circle();
shape->Draw();

第一行语句定义了一个 Shape 类型的指针对象，但是调用的是子类的构造函数构建对象。第二行语句调用 Draw 方法。由于 Shape 类中的 Draw 方法为虚方法（virtual），所以在执行 shape->Draw();语句时将采用动态绑定的机制，也就是根据运行时 shape 对象的实际类型来确定具体调用哪一个方法。在本题中，将调用 Circle 类的 Draw 方法，因为 shape 对象是通过 Circle 类的构造函数创建的。此外，还需要注意一点，就是调用 Circle 类的构造函数时，会先调用父类 Shape 的构造函数，然后再调用 Circle 类的构造函数。

8. 简述虚函数的用法和作用

在定义类的成员函数时，如果在函数前使用 virutal 关键字，表示该成员函数为虚函数。虚函数采用动态绑定的机制，当调用虚函数时，它会根据运行时对象的实际类型来确定具体调用哪个函数，而不是根据对象定义时的数据类型来确定。虚函数是现实多态性的最佳方式。

注意：父类中定义为虚方法，子类中重新定义该方法（函数名和参数列表相同）时，则该方法永远是虚方法，无论是否使用 virtual 关键字。此种情况就不是方法的隐藏了，而是方法的改写或覆盖。

9. 一个父类写了一个 virtual 函数，如果子类覆盖它的函数不加 virtual，也能实现多态? 在子类的空间里，有没有父类的这个函数，或者父类的私有变量？

在父类中定义一个虚函数，子类在改写该函数时，可以不加 virtual 关键字，它默认也是虚函数，不影响多态的实现。在子类的空间里有父类的虚函数，也有父类的所有变量（静态成员变量除外）。

注意：此时所说的情况是子类的空间里，子类可以通过父类的成员函数访问父类的私有成员，所以子类的空间中是有父类的虚函数和所有变量。但是父类中的静态成员变量在内存中只有一份，所以子类的空间中是没有父类的静态成员变量的。

10. 隐藏父类重载的所有方法

请指出下面代码中的错误，并说明原因。

#include <iostream>

using namespace std;

class Animal
{
public:
    void Cry() 
    {
        cout << "Unname animal can cry!" << endl;
    }
    void Cry(char* szName) 
    {
        cout << szName << " animal can cry!" << endl;
    }
};

class Bird : public Animal 
{
public:
    void Cry()
    {
        cout<<"Bird can cry!" << endl;
    }
};

int main(int argc, char* argv[])
{
    Bird Bird;
    Bird.Cry("bird");
    return 0;
}

语句 Bird.Cry("bird"); 编译错误。

上述代码中子类 Bird 隐藏了父类中的 Cry() 方法。但是在父类中有两个重载版本的 Cry() 方法。Bird 类将隐藏所有父类同名的方法,，因此语句 Bird.Cry("bird"); 试图访问父类中的 void Cry(char* szName) 重载方法时出现编译错误。

当子类隐藏父类中的方法时，会连同父类中同名的重载方法一同隐藏，因此，子类对象无法访问父类中重载的其他方法。

11. 类成员函数的重载、覆盖和隐藏区别

重载：是指在同一个类中有多个同名的方法，这些方法参数类型、参数个数或者方法属性（const 属性）不同。
覆盖：是指父类中定义了一个虚方法，子类中又重新定义了的该方法。通过覆盖父类的虚方法，可以实现动态绑定。
隐藏：是指子类重新定义了父类中的非虚方法，此时，子类中的方法将隐藏父类中的方法。有两种情况会发生隐藏：
- 如果子类的函数与父类的函数同名，但是参数不同。此时，不论有无 virtual 关键字，父类的函数将被隐藏。
- 如果子类的函数与父类的函数同名，并且参数也相同，但是父类函数没有 virtual 关键字。此时，父类的函数被隐藏。

12. const 对象不能够调用非 const 方法

13. 在程序中，重载成员函数可以实现静态多态性，而虚函数可以实现动态多态性。它们在范围上有着明显的不同。重载成员函数发生在同一个类中；虚函数需要在父类和子类中才能得到体现。

14. 析构函数为什么要设计为虚函数？

析构函数设计为虚函数，在动态绑定时可以保证子类的析构函数能够被调用，有效阻止了内存泄露的产生。

考虑这样一种情况：定义一个基类类型的指针，调用子类的构造函数为其构建对象，当对象释放时，先调用父类的析构函数还是先调用子类的析构函数，再调用父类的析构函数呢？答案是如果析构函数是虚函数，则先调用子类的析构函数，然后再调用父类的析构函数，如果析构函数不是虚函数，则只调用父类的析构函数。可以想象，如果在子类中为某个数据成员在堆中分配了空间，父类中的析构函数不是虚方法，上述情况将使子类的析构函数不会被调用，其结果是对象不能被正确地释放，导致内存泄露的产生。

15. 动态多态的两个必要条件

父类需要定义虚函数，子类改写该函数
定义一个基类指针，调用子类构造函数构建对象

多态性分为静态多态性和动态多态性两种。其中静态静态性是指在编译期间确定具体执行哪一项操作，它主要是通过方法重载和运算符重载来实现的；动态多态性是指在运行时确定具体执行哪一项操作。它主要是通过虚函数来实现的。

16. 类占用的内存空间

关于 a 的定义，请判断 sizeof(a) 的结果。

class a
{
public:
    virtual void funa( );
    virtual void funb( );
    void func( );
    static void fund( );
    static int si;
private:
    int i;
    char c;
};

sizeof(a) = 12

本题中虚拟方法表指针占 4 个字节，i 成员占 4 个字节，c 成员占 1 个字节。但是由于字节对齐，c 成员当前 “ 索引位置 ” 是 9 不是 4 的整数倍，需要额外在分配 3 个字节空间。因此 sizeof(a) 的结果为 12。

如果类中含有虚方法，则编译器需要为类构建虚拟方法表，类中需要有一个指针，指向这个虚拟方法表的地址。在 32 位的系统中，它占用 4个字节。

类中的静态成员是被类所有实例所共享的，它不计入 sizeof 计算的空间。
类成员采用字节对齐的方式分配空间。

17. 类的继承和多态

以下程序的输出结果是什么？

#include <iostream>

using namespace std;

class A
{
public:
    void f(void)
    {
        cout << "A::f" << " ";
    }
    virtual void g(void)
    {
        cout << "A::g" << " ";
    }
};

class B : public A
{
public:
    void f(void)
    {
        cout << "B::f" << " ";
    }
    void g(void)
    {
        cout << "B::g" << " ";
    }
};

int main()
{
    A* pA = new B;
    pA->f();
    pA->g();
    B* pB = (B*)pA;
    pB->f();
    pB->g();
    return 0;
}

输出结果为：A::f B::g B::f B::g

main 函数中首先定义了一个类 A 的指针对象，调用子类 B 的构造函数进行构建。语句 pA->f(); 将调用类 A 中的 f 方法，因为类 A 中的 f 方法是普通方法，不是虚方法，编译器将根据 pA 定义时的类型（类 A）确定调用哪一个类的方法。 pA->g(); 语句将调用类 B 中的 g 方法，因为类 A 中的 g 方法为虚方法，编译器将根据 pA 运行时的类型（由类 B 的构造函数构建）来确定调用哪一个类的 g 方法。接着又定义了一个 B 指针对象 pB，将其指向 pA 对象。语句 pB->f(); 将调用类 B 的 f 方法，因为 f 是普通方法，pB 定义的类型是 B 指针类型。语句 pB->g(); 调用类 B 中的 g 方法。

18. 类的多层继承

请写出下面程序的运行结果：

#include <iostream>

using namespace std;

class A
{
public:
    virtual void print(void)
    {
        cout << "A::print()" << endl;
    }
};

class B : public A
{
public:
    virtual void print(void)
    {
        cout << "B::print()" << endl;
    }
};

class C : public B
{
public:
    virtual void print(void)
    {
        cout << "C::print()" << endl;
    }
};

void print(A a)
{
    a.print();
}

int main()
{
    A a, *pa, *pb, *pc;
    B b;
    C c;
    
    pa = &a;
    pb = &b;
    pc = &c;
    
    a.print();
    b.print();
    c.print();
    
    pa->print();
    pb->print();
    pc->print();
    
    print(a);
    print(b);
    print(c);
    return 0;
}

输出结果为：

A::print()
B::print()
C::print()
A::print()
B::print()
C::print()
A::print()
A::print()
A::print()

第一组输出语句 a.print();b.print();c.print(); 的输出结果为 A::print() B::print() C::print() 。因为对象 a、b、c 的类型分别为类 A、类 B 和类 C。它们会各自调用各自类中定义的 print 方法。

第二组输出语句 pa->print();pb->print();pc->print(); 的输出结果为 A::print() B::print() C::print() 。因为pa、pb 和 pc 对象分别指向类 A 对象 a、类 B 对象 b 和类 C 对象 c。

第三组输出语句是本题的难点，也是本题的精华 print(a);print(b);print(c); 。他们都调用 print 函数来输出语句，而 print 函数包含了一个类A类型的参数a，该函数采用值传递方式。语句 print(a); 执行结果为 A::print() ，这没有任何疑问。关键是语句 print(b); 和 print(c); 的执行结果。调用 print(b); 语句时，由于 print 函数采用值传递，将调用类 A 的拷贝构造函数（系统默认提供）根据实际参数 b 来构建类 A 对象。在 print 函数体中参数 a 的实际类型为 A。因此调用 print(b); 语句输出结果为A::print()，print(c); 语句也同样输出 A::print() 。

如果在本题中将 print 函数修改为引用方式传递，例如：

void print(A &a)
{
    a.print();
}

则第三组的输出结果为：A::print() B::print() C::print() 。

19. 怎样定义一个纯虚函数？含有纯虚函数的类称为什么？

纯虚函数的定义是在定义虚函数的基础上，在虚函数末尾添加 “ = 0 ” ，同时函数没有函数体，也就是没有函数的实现部分。含有纯虚函数的类被称为抽象类，不能够实例化一个抽象类，即不能定义抽象类对象。

在 C++语言中，除了能够定义虚函数之外，还可以定义纯虚函数，也就是通常所说的抽象函数。一个包含纯虚函数的类被称为抽象类，抽象类是不能够被实例化的，通常用于实现接口的定义。
例如：

#define MAXLEN 128  //定义一个宏
class CEmployee  //定义一个抽象类
{
protected:
    int m_nID;  //定义员工 ID
    char m_szName[MAXLEN];  //定义员工姓名
    char m_szDepart[MAXLEN];  //定义所属部门
public:
    virtual void OutputName() = 0;  //定义抽象方法
};

上述代码中为 CEmployee 类定义了一个纯虚方法 OutputName 。纯虚方法的定义是在虚方法定义的基础上在末尾添加 “ = 0 ” 。对于包含纯虚方法的类来说，是不能够实例化的。抽象类通常用于作为其他类的父类，从抽象类派生的子类如果不是抽象类，则子类必须实现父类中的所有纯虚函数。
例如：

class COperator : public CEmployee  //定义一个操作员类，从 CEmployee 类派生而来
{
public:
    COperator()
    {
        strcpy(m_szName, "MR");
    }
    virtual void OutputName()  //实现纯虚方法
    {
        cout << "操作员姓名: " << m_szName << endl;  //输出操作员姓名
    }
};

class CSystemManager : public CEmployee  //定义一个管理类，从 CEmployee 类派生而来
{
public:
    CSystemManager()
    {
        strcpy(m_szName, "MRSoft");
    }
    virtual void OutputName()  //实现纯虚方法
    {
        cout << "系统管理员: " << m_szName << endl;  //输出操作员姓名
    }
};

上述代码从 CEmployee 类派生了两个子类，分别为 COperator 和 CSystemManager 。这两个类分别实现了父类的纯虚方法 OutputName 。下面定义一个 CEmployee 类的指针，然后分别利用 COperator 类的构造函数和 CSystemManager 类的构造函数创建对象，并调用 OutputName 方法。

int main()
{
    CEmployee *pWorker;  //定义 CEmployee 类型指针对象
    pWorker = new COperator();  //调用 COperator 类的构造函数为 pWorker 赋值
    pWorker->OutputName();  //调用 COperator 类的 OutputName 方法
    delete pWorker;  //释放 pWorker 对象
    pWorker = NULL;  //将 pWorker 对象设置为空
    //调用 CSystemManager 类的构造函数与为 pWorker 赋值
    pWorker = new CSystemManager();
    pWorker->OutputName();  //调用 CSystemManager 类的 OutputName 方法
    delete pWorker;  //释放 pWorker 对象
    pWorker = NULL;  //将 pWorker 对象设置为空
    return 0;
}

运行结果为：

操作员姓名: MR
系统管理员: MRSoft

在抽象类中也可以定义普通的数据成员和成员函数，但是不能够实例化抽象类。一个类无论有多少个方法，只要有一个方法是抽象方法（纯虚函数），那么这个类就是抽象类。

20. 什么是多继承？它的格式是什么？

多继承是指一个子类能够从多个类派生，也就是它可以同时具有多个父类。它的语法格式与单继承类似。只是可以指定多个父类。
例如：

class CWaterBird : public CBird, public CFish

C++语言除了支持单继承外，还支持多继承，即允许一个子类同时从多个类派生。下面通过一个例子来介绍多继承的设计过程。我们需要设计一个鸟类，它具有飞翔功能，然后设计一个鱼类，它具有水里游的功能。如果我们设计既可以飞翔，又可以在水中游的水鸟类，则可以直接从鸟类和鱼类派生。

#include <iostream>

using namespace std;
 
class CBird  //定义一个鸟类 
{
public:
    void FlyInSky()
    {
        cout << "鸟能够在天空中翱翔！" << endl;
    }
    void Breath()
    {
        cout << "鸟能够呼吸！" << endl;
    }
};

class CFish  //定义一个鱼类 
{
public:
    void SwimInWater()
    {
        cout << "鱼能够在水中游！" << endl;
    }
    void Breath()
    {
        cout << "鱼能够呼吸！" << endl;   
    } 
};

class CWaterBird : public CBird, public CFish  //定义水鸟类 
{
public:
    void Action()
    {
        cout << "水鸟既能飞又能游！" << endl; 
    }
};

int main()
{
    CWaterBird waterbird;
    waterbird.FlyInSky();
    waterbird.SwimInWater();
    waterbird.CBird::Breath();
    waterbird.CFish::Breath();
    return 0;
}

运行结果为：

鸟能够在天空中翱翔！
鱼能够在水中游！
鸟能够呼吸！
鱼能够呼吸！

上述代码定义了鸟类 CBird，定义了鱼类 CFish、然后从鸟类和鱼类派生了一个子类水鸟类 CWaterBird。水鸟类自然继承了鸟类和鱼类的所有共有和受保护的成员。因此 CWaterBird 类对象能够调用 FlyInSky 和 SwimInWater 方法。在 CBird 类中提供了一个 Breath 方法，在 CFish 类中同样提供了 Breath 方法，如果 CWaterBird 类对象调用 Breath 方法，需要在 Breath 方法前具体指定类名。
例如：

Waterbird.CFish::Breath();  //调用 CFish 类的 Breath 方法
Waterbird.CBird::Breath();  //调用 CBird 类的 Breath 方法

21. 虚继承的作用

在多继承中，子类可以同时拥有多个父类，如果这些父类还有相同的父类（祖先类），那么在子类中就会有两份祖先类。例如，类 B 和类 C 均继承于类 A，如果类 D 派生于类 B 和类 C，那么类 D 中将有两份类 A。为了防止在多继承中，子类存在重复的父类情况，可以在父类继承时使用虚继承。即在类 B 和类 C 继承类 A 时使用 virtual 关键字 。
例如：

class B : virtual public A
class C : virtual public A

在程序开发过程中，多继承虽然带来了很多方便，但是很少有人愿意使用它，因为多继承会带来很多复杂的问题，并且多继承能够完成的功能，通过单继承同样可以实现。因此，在开发应用程序时，如果能够使用单继承实现，尽量不要使用多继承。

22. 设计模式

设计模式汇总

最后编辑于：2017.12.07 01:49:20

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 158,736评论 4赞 362
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 67,167评论 1赞 291
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 108,442评论 0赞 243
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 43,902评论 0赞 204
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 52,302评论 3赞 287
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 40,573评论 1赞 216
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 31,847评论 2赞 312
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 30,562评论 0赞 197
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 34,260评论 1赞 241
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 30,531评论 2赞 245
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 32,021评论 1赞 258
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 28,367评论 2赞 253
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 33,016评论 3赞 235
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 26,068评论 0赞 8
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 26,827评论 0赞 194
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 35,610评论 2赞 274
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 35,514评论 2赞 269

继承和多态

继承和多态

1. 继承的优缺点

2. 子类不能继承父类的私有成员，只能通过父类的成员函数来访问父类的私有成员

3. 继承方式

4. 如何访问被隐藏的基类成员？

5. 构造函数和析构函数的调用顺序

6. 子类和父类的关系

7. 动态绑定

8. 简述虚函数的用法和作用

9. 一个父类写了一个 virtual 函数，如果子类覆盖它的函数不加 virtual，也能实现多态? 在子类的空间里， 有没有父类的这个函数，或者父类的私有变量 ？

10. 隐藏父类重载的所有方法

11. 类成员函数的重载、覆盖和隐藏区别

12. const 对象不能够调用非 const 方法

13. 在程序中，重载成员函数可以实现静态多态性，而虚函数可以实现动态多态性。它们在范围上有着明显的不同。重载成员函数发生在同一个类中；虚函数需要在父类和子类中才能得到体现。

14. 析构函数为什么要设计为虚函数？

15. 动态多态的两个必要条件

16. 类占用的内存空间

17. 类的继承和多态

18. 类的多层继承

19. 怎样定义一个纯虚函数？含有纯虚函数的类称为什么？

20. 什么是多继承？它的格式是什么？

21. 虚继承的作用

22. 设计模式

推荐阅读更多精彩内容

9. 一个父类写了一个 virtual 函数，如果子类覆盖它的函数不加 virtual，也能实现多态? 在子类的空间里，有没有父类的这个函数，或者父类的私有变量？