【C++ 面试 - 面向对象】每日 3 题（七）

✍个人博客：Pandaconda-CSDN博客

📣专栏地址：http://t.csdnimg.cn/fYaBd

📚专栏简介：在这个专栏中，我将会分享 C++ 面试中常见的面试题给大家~
❤️如果有收获的话，欢迎点赞👍收藏📁，您的支持就是我创作的最大动力💪

 19. 用基类指针初始化派生类和用派生类指针初始化派生类的区别

1、不含虚函数的情况

1. 基 类指针初始化派生类对象：

当我们使用基类指针来初始化派生类对象时，只有基类部分的成员和方法可以被访问和使用，派生类独有的成员和方法是不可访问的。

例如：

class Base {
public:
    void baseMethod() {
        cout << "This is a base class method." << endl;
    }
};
class Derived : public Base {
public:
    void derivedMethod() {
        cout << "This is a derived class method." << endl;
    }
};
int main() {
    Base* basePtr = new Derived();
    basePtr->baseMethod();   // 可以访问基类的成员函数
    //basePtr->derivedMethod();  // 错误：派生类特有的函数无法访问
    delete basePtr;
    return 0;
}

在上面的例子中，通过 Base* 类型的指针 basePtr 初始化了派生类 Derived 的对象。然而，通过 basePtr 只能访问基类 Base 的成员方法，无法访问派生类 Derived 的独有方法 derivedMethod()。

 2. 派生类指针初始化派生类对象：

当我们使用派生类指针来初始化派生类对象时，并不会有任何限制，我们可以访问和使用该派生类及其基类的所有成员和方法。

例如：

class Base {
public:
    void baseMethod() {
        cout << "This is a base class method." << endl;
    }
};
class Derived : public Base {
public:
    void derivedMethod() {
        cout << "This is a derived class method." << endl;
    }
};
int main() {
    Derived* derivedPtr = new Derived();
    derivedPtr->baseMethod();     // 可以访问基类的成员函数
    derivedPtr->derivedMethod();  // 可以访问派生类独有的成员函数
    delete derivedPtr;
    return 0;
}

在上面的例子中，我们使用 Derived* 类型的指针 derivedPtr 初始化了派生类 Derived 的对象。通过 derivedPtr 可以访问基类 Base 的成员方法 baseMethod()，也可以访问派生类 Derived 自己的独有方法 derivedMethod()。

总结起来，使用基类指针初始化派生类对象只能访问基类的成员和方法，无法访问派生类的独有成员和方法；而使用派生类指针初始化派生类对象可以访问派生类及其基类的所有成员和方法。

2、包含虚函数的情况

 1. 基类指针初始化派生类对象：

当我们使用基类指针来初始化派生类对象时，可以通过该指针访问基类的虚函数，但会导致动态绑定的问题。

例如：

class Base {
public:
    virtual void virtualMethod() {
        cout << "This is a base class virtual method." << endl;
    }
};
class Derived : public Base {
public:
    virtual void virtualMethod() {
        cout << "This is a derived class virtual method." << endl;
    }
};
int main() {
    Base* basePtr = new Derived();
    basePtr->virtualMethod();   // 动态绑定，会调用派生类的虚函数
    delete basePtr;
    return 0;
}

在上面的例子中，通过 Base* 类型的指针 basePtr 初始化了派生类 Derived 的对象。通过 basePtr 调用了基类的虚函数 virtualMethod()，但由于动态绑定的特性，实际上调用了派生类 Derived 中重写的虚函数，输出了派生类的信息。

 2. 派生类指针初始化派生类对象：

如果使用派生类指针来初始化派生类对象，同样可以通过该指针访问基类的虚函数，但没有动态绑定问题，直接调用派生类中的实现。

例如：

class Base {
public:
    virtual void virtualMethod() {
        cout << "This is a base class virtual method." << endl;
    }
};
class Derived : public Base {
public:
    virtual void virtualMethod() {
        cout << "This is a derived class virtual method." << endl;
    }
};
int main() {
    Derived* derivedPtr = new Derived();
    derivedPtr->virtualMethod();   // 直接调用派生类的虚函数
    delete derivedPtr;
    return 0;
}

在上面的例子中，我们使用 Derived* 类型的指针 derivedPtr 初始化了派生类 Derived 的对象。通过 derivedPtr 直接调用了派生类的虚函数 virtualMethod()。

总结起来，不管是通过基类指针还是派生类指针初始化派生类对象，都可以访问基类的虚函数。使用基类指针会进行动态绑定，最终调用派生类中的实现；而使用派生类指针直接调用派生类中的实现。

20. 虚 函数的代价是什么？

1. 带有虚函数的类，每一个类会产生一个虚函数表，用来存储指向虚成员函数的指针，增大类。

2. 带有虚函数的类的每一个对象，都会有有一个指向虚表的指针，会增加对象的空间大小。

3. 不能再是内联的函数，因为内联函数在编译阶段进行替代，而虚函数表示等待，在运行阶段才能确定到底是采用哪种函数，虚函数不能是内联函数。

21. 静态 类型和动态类型，静态绑定和动态绑定的介绍

• 静态类型：对象在声明时采用的类型，在编译期既已确定；

• 动态类型：通常是指一个指针或引用目前所指对象的类型，是在运行期决定的；

• 静态绑定（早绑定）：绑定的是静态类型，所对应的函数或属性依赖于对象的静态类型，发生在编译期；

• 动态绑定（晚绑定）：绑定的是动态类型，所对应的函数或属性依赖于对象的动态类型，发生在运行期；

通过对象调用函数则是静态绑定，通过指针或引用调用函数则是动态绑定，即需要通过虚函数指针进行查找。

从上面的定义也可以看出，非虚函数一般都是静态绑定，而虚函数都是动态绑定（如此才可实现多态性）。 举个例子：

#include <iostream>
using namespace std;

class A
{
public:
    /*virtual*/ void func() { std::cout << "A::func()\n"; }
};
class B : public A
{
public:
    void func() { std::cout << "B::func()\n"; }
};
class C : public A
{
public:
    void func() { std::cout << "C::func()\n"; }
};
int main()
{
    C* pc = new C(); //pc的静态类型是它声明的类型C*，动态类型也是C*；
    B* pb = new B(); //pb的静态类型和动态类型也都是B*；
    A* pa = pc;      //pa的静态类型是它声明的类型A*，动态类型是pa所指向的对象pc的类型C*；
    pa = pb;         //pa的动态类型可以更改，现在它的动态类型是B*，但其静态类型仍是声明时候的A*；
    C* pnull = NULL; //pnull的静态类型是它声明的类型C*,没有动态类型，因为它指向了NULL；
    
    pa->func();      //A::func() pa的静态类型永远都是A*，不管其指向的是哪个子类，都是直接调用A::func()；
    pc->func();      //C::func() pc的动、静态类型都是C*，因此调用C::func()；
    pnull->func();   //C::func() 不用奇怪为什么空指针也可以调用函数，因为这在编译期就确定了，和指针空不空没关系；
    return 0;
}  

如果将 A 类中的 virtual 注释去掉，则运行结果是：

pa->func();      //B::func() 因为有了virtual虚函数特性，pa的动态类型指向B*，因此先在B中查找，找到后直接调用；
pc->func();      //C::func() pc的动、静态类型都是C*，因此也是先在C中查找；
pnull->func();   //空指针异常，因为是func是virtual函数，因此对func的调用只能等到运行期才能确定，然后才发现pnull是空指针；

在上面的例子中：

• 如果基类 A 中的 func 不是 virtual 函数，那么不论 pa、pb、pc 指向哪个子类对象，对 func 的调用都是在定义 pa、pb、pc 时的静态类型决定，早已在编译期确定了。

• 同样的空指针也能够直接调用 no-virtual 函数而不报错（这也说明一定要做空指针检查啊！），因此静态绑定不能实现多态；

• 如果 func 是虚函数，那所有的调用都要等到运行时根据其指向对象的类型才能确定，比起静态绑定自然是要有性能损失的，但是却能实现多态特性；

本文代码里都是针对指针的情况来分析的，但是对于引用的情况同样适用。

至此总结一下静态绑定和动态绑定的区别：

• 静态绑定发生在编译期，动态绑定发生在运行期；

• 对象的动态类型可以更改，但是静态类型无法更改；

• 要想实现动态，必须使用动态绑定；

• 在继承体系中只有虚函数使用的是动态绑定，其他的全部是静态绑定；

建议：

绝对不要重新定义继承而来的非虚 (non-virtual) 函数（《Effective C++ 第三版》条款36），因为这样导致函数调用由对象声明时的静态类型确定了，而和对象本身脱离了关系，没有多态，也这将给程序留下不可预知的隐患和莫名其妙的 BUG；另外，在动态绑定也即在 virtual 函数中，要注意默认参数的使用。当缺省参数和 virtual 函数一起使用的时候一定要谨慎，不然出了问题怕是很难排查。 看下面的代码：

#include <iostream>
using namespace std;

class E
{
public:
    virtual void func(int i = 0)
    {
        std::cout << "E::func()\t" << i << "\n";
    }
};
class F : public E
{
public:
    virtual void func(int i = 1)
    {
        std::cout << "F::func()\t" << i << "\n";
    }
};

void test2()
{
    F* pf = new F();
    E* pe = pf;
    pf->func(); //F::func() 1  正常，就该如此；
    pe->func(); //F::func() 0  哇哦，这是什么情况，调用了子类的函数，却使用了基类中参数的默认值！
}
int main()
{
    test2();
    return 0;
}