有如下C++代码：
struct A{
void foo(){printf("foo");}
virtual void bar(){printf("bar");}
A(){bar();}
};
struct B:A{
void foo(){printf("b_foo");}
void bar(){printf("b_bar");}
}; 那么
A *p = new B; p->foo(); p->bar();
输出为：
[单选题]
A *p=new B; // A类指针指向一个实例化对象B，
B类继承自A类，先调用A类的无参构造函数，bar()输出bar，再调用B类的默认构造函数。（注：根据深度探索C++对象模型中的构造函数语意学，这里派生类B有一个带有默认构造函数的Base
class,因此编译器必须为没有申明构造函数的B类合成一个默认构造函数！）
p->foo(); //执行B类里的foo()函数，因为foo不是虚函数，采用静态联编，所以直接调用父类的foo函数，输出foo；
p->bar();//执行B类的bar()函数, 该函数为虚函数，采用动态联编，调用子类的实现，输出b_bar。
编辑于 2016-07-29 13:56:56
回复(0)
A *p=newB;
本来，基类指针p是用来指向基类对象的，如果用它来指向派生类对象，则进行指针类型转换
——将派生类B对象的指针先转换为基类A对象的指针，然后再赋给p；
所以基类指针p指向的不是派生类，而是派生类对象中的基类部分，已经转化为基类了！
当然，无法使用基类指针取调用派生类对象中的成员函数，所以p->foo();调用的是基类的函数！
~
虚函数突破了这一限制，在派生类的基类部分中，派生类的虚函数取代了基类原来的虚函数，
因此使用基类指针调用派生类对象后，调用虚函数时就调用了派生类的虚函数。
~
总之：
1. 首先，必须要有指针引领，p->f()，而且这个指针一定是由基类定义的；
2. 把基类定义的指针指向派生类，这是一个强制类型转换的过程，把派生类强制转化为基类，所以这个时候调用函数，肯定调用的还是基类的；
3. 虚函数的功能就是，用派生类的函数替代同名基类的虚函数，这个时候再进行强制类型转换，保留的函数就是派生类的。
——将派生类B对象的指针先转换为基类A对象的指针，然后再赋给p；
所以基类指针p指向的不是派生类，而是派生类对象中的基类部分，已经转化为基类了！
当然，无法使用基类指针取调用派生类对象中的成员函数，所以p->foo();调用的是基类的函数！
~
虚函数突破了这一限制，在派生类的基类部分中，派生类的虚函数取代了基类原来的虚函数，
因此使用基类指针调用派生类对象后，调用虚函数时就调用了派生类的虚函数。
~
总之：
1. 首先，必须要有指针引领，p->f()，而且这个指针一定是由基类定义的；
2. 把基类定义的指针指向派生类，这是一个强制类型转换的过程，把派生类强制转化为基类，所以这个时候调用函数，肯定调用的还是基类的；
3. 虚函数的功能就是，用派生类的函数替代同名基类的虚函数，这个时候再进行强制类型转换，保留的函数就是派生类的。
编辑于 2018-03-07 08:41:01
回复(0)
这道题，考察的就是多态。
多态的条件：1、有继承关系。2、父类有虚函数、3、子类重写父类同名的虚函数。
显然：
1、该题中foo只满足1、3点，所以foo不会发生多态。当父类指针指向子类对象时，父类对象调用父类的函数。
2、该题中bar满足多态的条件，所以会发生多态。当父类指针指向子类对象时，父类对象会调用子类中的发生多态的函数。
编辑于 2023-05-01 10:22:50
回复(0)
#include <bits/stdc++.h>
using std::string;
using std::vector;
using std::pair;
using i64 = long long;
const int INF = 1e9;
class father{
public:
void stru(){std::cout << "father is constructing!\n";};
virtual void father_two() {std::cout << "this is ur 2nd father...\n";};
father() {stru();};
};
class son: public father{
public:
void stru() {std::cout << "that is a son\n";};
void father_two() override {std::cout << "now it's son here!\n";};
son() {std::cout << "son is constructing...\n";};
};
class grand: public son{
public:
void stru() {std::cout << "this is grand......\n";};
void father_two() override {std::cout << "now it's grand here!\n";};
grand() {std::cout << "grand is constructing///\n";};
};
int main() {
father *p = new grand;
p -> stru();
p -> father_two();
return 0;
} 拿3个类试验了一下，大概懂了。
继承链： father -> son -> grand构造顺序规则
创建子类对象时，会先调用基类的构造函数，再调用子类的构造函数。因为子类对象中包含基类子对象，必须先把父亲“造好”，才能继续造儿子。
因此构造时会依次调用father()、son()和grand()，输出
father is constructing! son is constructing... grand is constructing///
来到 p -> stru();
因为father类的stru不是虚函数，静态绑定到father::stru，输出
father is constructing!然后
p->father_two()
father_two是虚函数，动态绑定类，而p实际指向一个grand对象，因此调用的是grand::father_two。输出：
now it's grand here!因此，最终输出
father is constructing! son is constructing... grand is constructing/// father is constructing! now it's grand here!
编辑于 2025-09-18 14:14:41
回复(0)
首先，创建一个指向子类B的父类指针p，这是多态的一种典型用法。然后调用p的两个成员函数foo和bar，分别输出"foo"和"bar"。 由于A中的构造函数调用了bar()，因此在创建B对象时先调用A的构造函数，在A的构造函数中又调用了虚函数bar()，但此时对象还没有完全构造完成，因此调用的是A中的bar()。所以先输出了"bar"。接下来，p指向了B对象，并且通过指针p调用B中的成员函数foo()和bar()。 在C++中，当派生类重定义基类中的非虚函数时，在派生类中定义新版本后就无法直接访问基类版本的该函数。因此，当执行p->foo()时，会去寻找父类A中对应的函数foo()，而不是子类B中重写/隐藏了父类A中同名非虚函数。 而对于虚函数bar()而言，在父类A中已经声明为虚函数，在子类B中被重写，并且通过多态性实现动态绑定。所以执行p->bar()时会根据实际对象类型确定要调用哪一个版本的虚函数，在这里即为B::bar()。从而输出"foob_bar"。
发表于 2023-04-25 16:51:50
回复(0)
问题信息
-
扫描二维码，关注牛客网
- 意见反馈
-
下载牛客APP，随时随地刷题
扫一扫，把题目装进口袋
- 求职之前，先上牛客
-
扫描二维码，进入QQ群
扫描二维码，关注牛客公众号
- 公司地址：北京市朝阳区北苑路北美国际商务中心K1座一层-北京牛客科技有限公司
- 联系方式：010-60728802 投诉举报电话：010-57596212（朝阳人力社保局）
- 牛客科技© All rights reserved admin@nowcoder.com
- 京ICP备14055008号-4 增值电信业务经营许可证 营业执照 人力资源服务许可证
-
京公网安备
11010502036488号
【解析】A * p = new B; // A 的指针指向 B 的对象。
当执行 new B 时，调用 B 的无参构造函数，由于 B 继承 A，所以先调用 A 的构造函数，在 A 的构造函数中调用了虚函数 bar()，这时调用的是 A 的 bar()。如果在构造函数或析构函数中调用虚函数，则运行的是为构造函数或析构函数本人类型定义的版本，因为在构造子类的时候，首先回去调用父类的默认构造函数，此时子类还是未初始化的，所以不可能调用子类函数；
p->foo(); 因为 foo() 不是虚函数，所以执行的是 A 的 foo()；
【静态联编和动态联编知识点讲解】
更多C++基础专业知识讲解，点击链接即可查看
https://www.nowcoder.com/link/zxyl-cpp89