每日练习（多态）

1、

答案：选B

解析：

2、

答案：选d

解析：

3、

答案：选c
解析：
选项 A：C++语言的多态性分为编译时的多态性和运行时的多态性
分析：
C++ 中的多态性确实可以分为两种类型：
编译时多态性（静态多态性）：通过函数重载和运算符重载实现，编译器在编译阶段就能确定调用哪个函数。
运行时多态性（动态多态性）：通过虚函数机制实现，编译器无法在编译阶段确定调用哪个函数，而是在运行时根据对象的实际类型动态绑定到相应的函数。
这一说法是正确的。
结论：此选项正确。
选项 B：编译时的多态性可通过函数重载实现
分析：
编译时多态性主要通过以下方式实现：
函数重载：根据参数的类型、个数或顺序不同，编译器在编译阶段就能确定调用哪个函数。
运算符重载：同样属于编译时多态的一种形式。
因此，这一说法是正确的。
结论：此选项正确。
选项 C：运行时的多态性可通过模板和虚函数实现
分析：
运行时多态性主要是通过虚函数机制实现的，即通过动态绑定（Dynamic Binding），在运行时根据对象的实际类型调用相应的函数。
模板是一种泛型编程工具，主要用于实现编译时多态性（如函数模板和类模板）。虽然模板也可以用于某些形式的运行时行为，但它并不是实现运行时多态性的主要手段。
因此，说“运行时的多态性可通过模板实现”是不准确的。
结论：此选项错误。
选项 D：实现运行时多态性的机制称为动态绑定
分析：
运行时多态性确实是通过**动态绑定（Dynamic Binding）**实现的。动态绑定是指在运行时根据对象的实际类型，将函数调用绑定到相应的函数实现。
这一说法是正确的。
结论：此选项正确。
4、

答案：选d
解析：
选项 A：基类和派生类原型相同的函数至少有一个是虚函数即可
分析：
在 C++ 中，要实现运行时多态（即动态绑定），基类中必须将某个成员函数声明为虚函数。这样，当通过基类指针或引用调用该函数时，编译器会在运行时根据实际对象的类型动态绑定到相应的派生类函数。
如果基类中的函数不是虚函数，即使派生类重写了该函数，调用时也会直接调用基类的函数，无法实现多态。
因此，这一说法是正确的。
结论：此选项正确。
选项 B：假设重写成功，通过指针或者引用调用虚函数就可以实现多态
分析：
要实现多态，确实需要通过基类指针或引用调用虚函数。这是运行时多态的核心机制之一。
然而，仅仅通过指针或引用调用虚函数还不够，基类中的函数必须被声明为虚函数，且派生类必须正确地重写该函数。
因此，这一说法是不全面的，但基本正确。
结论：此选项部分正确，但不够完整。
选项 C：在编译期间，通过传递不同类的对象，编译器选择调用不同类的虚函数
分析：
多态的实现是基于运行时绑定（Dynamic Binding），而不是编译时绑定（Static Binding）。编译器在编译期间无法确定实际调用的是哪个函数，因为这取决于运行时对象的实际类型。
因此，这一说法是错误的。
结论：此选项错误。
选项 D：只有在需要实现多态时，才需要将成员函数设置成虚函数，否则没有必要
分析：
这一说法是正确的。虚函数的主要作用是支持运行时多态。如果程序不需要实现多态行为，就没有必要将成员函数声明为虚函数。
声明虚函数会引入一定的开销（如虚拟表的维护），因此只有在需要多态的情况下才应该使用虚函数。
结论：此选项正确。
5、

答案：选择AF;
解析：
知识点：
重载（Overloading）：
定义：在同一作用域内，允许存在多个同名函数，但它们的参数列表必须不同（包括参数类型、个数或顺序）。
特点：
发生在同一个类中或全局作用域中。
编译器通过参数列表区分不同的重载函数。
与继承无关。
重写（Override）：
定义：派生类中重新定义基类中的虚函数，以实现运行时多态。
特点：
必须发生在继承体系中。
要求函数的原型完全相同（返回类型、函数名、参数列表等）。
基类中的函数必须被声明为 virtual。
重定义（Redeclaration/Re-definition）：
定义：在不同的作用域中重新声明或重新定义一个已存在的符号（如变量、函数等）。
特点：
可以发生在同一类的不同作用域中，也可以发生在继承体系中。
与继承关系无关，主要涉及作用域规则。
分析：

6、

答案：选B

解析：
选项 A：如果父类和子类都有相同的方法，参数个数不同，将子类对象赋给父类对象后，采用父类对象调用该同名方法时，实际调用的是子类的方法
分析：
这里涉及两个概念：重载和多态。
重载：同一个类中可以定义多个同名函数，只要它们的参数列表不同（包括参数类型、个数或顺序）。编译器通过参数列表区分不同的重载函数。
多态：通过虚函数机制实现运行时多态，即在继承体系中，基类指针或引用可以指向派生类对象，并在运行时根据实际对象的类型动态绑定到相应的函数。
如果父类和子类都有相同的方法名，但参数个数不同，这属于重载，而不是多态。
当将子类对象赋给父类对象（即通过基类指针或引用指向派生类对象）时，调用方法的行为取决于是否使用了虚函数机制：
如果父类中的方法是虚函数，且子类重写了该方法，则调用的是子类的方法（多态行为）。
如果父类中的方法不是虚函数，则调用的是父类的方法，与参数无关。
因此，选项 A 的描述不准确，因为它混淆了重载和多态的概念。
结论：此选项错误。
选项 B：选项全部都不正确
分析：
我们需要逐一验证其他选项是否正确，才能判断选项 B 是否成立。
如果其他选项均不正确，则选项 B 正确；否则，选项 B 错误。
结论：暂不作结论，需继续分析其他选项。
选项 C：重载和多态在C++面向对象编程中经常用到的方法，都只在实现子类的方法时才会使用
分析：
重载：可以在任何类中使用，不仅限于子类。例如，在一个类中可以定义多个同名函数，只要它们的参数列表不同即可。重载与继承无关。
多态：通常发生在继承体系中，通过虚函数机制实现。虽然多态确实与子类有关（因为子类需要重写基类的虚函数），但它并不是“只在实现子类的方法时才会使用”。基类中必须声明虚函数，才能实现多态。
因此，选项 C 的描述不准确。
结论：此选项错误。
在这个代码中：
类 A 定义了一个方法 test(float a)。
类 B 继承自 A，并定义了一个方法 test(int b)。这两个方法的参数类型不同，属于重载，而不是多态。
在 main 函数中，a 是一个指向 A 类的指针，初始指向 A 的对象，后来被赋值为指向 B 的对象。
调用 a->test(1.1) 时：
a 是指向 A 类的指针，因此调用的是 A 类中的 test(float a) 方法。
即使 a 指向的是 B 对象，由于 test(float a) 和 test(int b) 是重载方法，而不是多态方法（没有虚函数机制），所以不会发生动态绑定。
输出结果是 1.1，而不是 1。
7、

答案：选D

解析：

8、

答案：选D

解析：
纯虚函数（Pure Virtual Function）：
纯虚函数是一种特殊的虚函数，其定义以 = 0; 结尾。
纯虚函数没有函数体，仅在类中声明。
它的作用是强制派生类实现该函数。
抽象类（Abstract Class）：
如果一个类中包含至少一个纯虚函数，则该类称为抽象类。
抽象类不能被实例化，即不能直接创建对象。
派生类对纯虚函数的处理：
派生类必须实现基类中的所有纯虚函数，否则派生类仍然是抽象类。
如果派生类未实现某个纯虚函数，则派生类也是抽象类。

9、

答案：选B

知识点：
抽象类：
抽象类是包含至少一个纯虚函数的类。
抽象类不能被实例化，即不能直接创建对象。
合法操作：
可以声明指向抽象类的指针或引用。
可以定义与抽象类相关的函数（如参数为抽象类类型或返回值为抽象类类型的函数）。
不能直接创建抽象类的对象。
解析：
选项 A：A fun(int);
分析：
这是一个函数声明，表示函数 fun 的返回类型是 A，参数是一个整数。
由于 A 是抽象类，无法直接作为返回类型，因为抽象类不能被实例化。
因此，这个声明是不合法的。
结论：此选项错误。
选项 B：A* p;
分析：
这是一个指针声明，表示 p 是一个指向 A 类型对象的指针。
即使 A 是抽象类，仍然可以声明指向抽象类的指针，因为指针本身并不需要实例化对象。
因此，这个声明是合法的。
结论：此选项正确。
选项 C：int fun(A);
分析：
这是一个函数声明，表示函数 fun 的返回类型是 int，参数是一个 A 类型的对象。
由于 A 是抽象类，不能直接作为参数类型，因为抽象类不能被实例化。
因此，这个声明是不合法的。
结论：此选项错误。
选项 D：A obj;
分析：
这是一个对象声明，表示 obj 是一个 A 类型的对象。
由于 A 是抽象类，不能被实例化，因此不能直接创建 A 类型的对象。
因此，这个声明是不合法的。
结论：此选项错误。
10、

答案：选D

知识点：
虚表（Vtable）：
虚表是 C++ 中用于支持多态的一种机制，主要用于存储类中所有虚函数的地址。
每个包含虚函数的类都会生成一张虚表，该表在运行时动态创建，并与对象实例关联。
虚表中的条目对应类中的每个虚函数，指向实际被调用的函数实现。
虚表的特点：
每个类一张虚表：每个包含虚函数的类都会有一张自己的虚表，即使子类没有重写基类的虚函数，也会生成新的虚表。
运行时生成：虚表是在程序运行期间动态生成的，而不是在编译时确定的。
共享性：同一类的所有对象共享同一张虚表，但不同类的对象可能有不同的虚表。
解析：

11、

答案：选a；
解析：

12、

答案：B
解析：
选项 A：A::x()
错误。虽然 A::x() 是基类的实现，但由于 B 重写了 x()，并且调用的是 B 类的对象，因此不会调用 A::x()。
选项 B：B::x()
正确。B 重写了 A::x()，并且通过 B 类的对象调用，因此调用的是 B::x()。
选项 C：A::x() B::x()
错误。调用顺序不会同时包含 A::x() 和 B::x()，因为 B::x() 已经覆盖了 A::x()。
选项 D：B::x() A::x()
错误。调用顺序不会同时包含 B::x() 和 A::x()，并且 B::x() 是最终被调用的方法。
13、

答案：c
解析：

以上就是今天多态的练习，感兴趣的可以做一下。