为什么在调用父类虚函数

xiethree

#include <iostream>
using namespace std;

class X {
public:
    int k;
    X():k(12){
    }

    void fun(){
        cout<<"x class::fun k="<<k<<endl;
    }

    virtual void get1() {
        cout<<"父类 get"<<endl;
    }

};

class Y :public X{
public:
    Y():X(){
        cout<<"Y 构造函数"<<endl;
    };
    virtual void get1() {
        cout<<"子类 get"<<endl;
    }

};

int main() {
    X x;
    Y* py=(Y*)&x;
    py->fun();
    py->k;
    py->get1();     //为什么这里会调用父类的get1，而不是子类的get1
    return 0;
}

cpp2019

子类指针指向父类的实例？不明白你这么写有什么的特殊意义！

1.         Y* py = new Y();
   
2.         py->fun();
   
3.         py->k;
   
4.         py->get1();
   

复制代码

tony666

多态的实现时基于 虚函数表的，调用哪个类的函数，在你new对象的时候就已经确定了。

xiethree

cpp2019 发表于 2021-7-12 00:44
子类指针指向父类的实例？不明白你这么写有什么的特殊意义！

看到有人说，面试时碰到过这种题

xiethree

cpp2019 发表于 2021-7-12 00:44
子类指针指向父类的实例？不明白你这么写有什么的特殊意义！

你最后怎么会显示子类get,我在vs2013和gcc中都是显示调用是父类的虚函数get

xiethree

tony666 发表于 2021-7-12 08:34
多态的实现时基于 虚函数表的，调用哪个类的函数，在你new对象的时候就已经确定了。

没有new啊 ，看有别人发的面试题，试下 按理解是应该调用子类虚函数get ，可结果反而调用父类虚函数

yoobaby

可以简单的理解：

  Y* py=(Y*)&x; //取地址时取的x.get1()；比如是：0x1111 的地址，此时已经固定了函数的地址了，你强转也那个0x1111也是不会变的啊。

cpp2019

这下应该能够明白吧

1. #include <iostream>
   
2. using namespace std;
   
3. 
   
4. class X
   
5. {
   
6. public:
   
7.         int k;
   
8.         X() :k(12) {
   
9.         }
   
10. 
    
11.         void fun() {
    
12.                 cout << "x class::fun k=" << k << endl;
    
13.         }
    
14. 
    
15.         virtual void get1() {
    
16.                 cout << "父类 get" << endl;
    
17.         }
    
18. 
    
19. };
    
20. 
    
21. class Y :public X
    
22. {
    
23. public:
    
24.         Y() :X() {
    
25.                 cout << "Y 构造函数" << endl;
    
26.         };
    
27.         virtual void get1() {
    
28.                 cout << "子类 get" << endl;
    
29.         }
    
30. 
    
31. };
    
32. 
    
33. int main()
    
34. {
    
35.         Y objY;
    
36.         Y* pObjY1 = (Y*)&objY;
    
37.         pObjY1->fun();
    
38.         pObjY1->k;
    
39.         pObjY1->get1();
    
40.         cout << "--------华丽的分割符--------" << endl;
    
41. 
    
42.         Y* pObjY = new Y;
    
43.         pObjY->fun();
    
44.         pObjY->k;
    
45.         pObjY->get1();
    
46.         delete pObjY;
    
47.         cout << "--------华丽的分割符--------" << endl;
    
48. 
    
49.         Y objY2;
    
50.         objY2.fun();
    
51.         objY2.k;
    
52.         objY2.get1();
    
53.         cout << "--------华丽的分割符--------" << endl;
    
54. 
    
55.         cout << "\n这个py完全就是父类X的实例，跟子类Y没半点儿关系！" << endl;
    
56.         cout << "上边三个都是子类Y，可以看到Y的构造函数输出\n" << endl;
    
57.         X x;
    
58.         Y* py = (Y*)&x;
    
59.         py->fun();
    
60.         py->k;
    
61.         py->get1();
    
62. 
    
63.         return 0;
    
64. }

复制代码

xiethree

好吧，谢谢各位

CEveryC

用派生类的指针指向父类的对象，这么做是不合理的啊。