Question

让我们假设我们有

class Base
{
    virtual void foo()
    {
        // some default implementation
    }
};

void bar(Base* b)
{
}

有没有办法确定foo对象的b函数是否从bar函数重载？

Answer 1

您不希望检测是否已覆盖虚拟功能。

相反，在函数bar中，如果您希望Base实现将其称为

void bar( Base* p )
{
    p->Base::foo();
}

如果你想要一个虚拟调用，绑定到派生类最多的实现，就把它称为

void bar( Base* p )
{
    p->foo();
}

Answer 2

这是一个非便携，非常脆弱的解决方案。我不会在真正的程序中使用我自己的解决方案。只是很好奇，知道这是否可以完成。我会找到更优雅的方法来解决“真正的问题”。我认为，你真正的问题不仅仅是为了找出一个函数是否过载而进行调整。你在那里看到的'1'必须根据基类的布局进行调整。 1是虚拟表中函数foo的位置。是否要求在bar函数中有一个方便的Base类实例。

#include "stdafx.h"

class Base { 
    public: 
        int l;
        virtual int foo3(){return 5;}; 
        virtual int foo(){return 0;}; 
};

class Base2 { 
    public: 
        virtual int foo2(){return 2;}; 
};

class Derived : public Base, Base2 { 
    public:
        int j;
        int k;
        virtual int foo(){return 1;}; 
        virtual int foo2(){return 5;}; 
};

void bar(Base* b)
{
    Base d;

    int* p;
    int* p2;

    p = (int*)&d;
    p2 = (int*)b;
    p = (int*)(*p);
    p2 = (int*)(*p2);

    int i = p[1];
    int k = p2[1];
    bool bOverLoaded;
    if(i == k)
    {
        bOverLoaded = false;
    }
    else
    {
        bOverLoaded = true;
    }

}

int _tmain(int argc, _TCHAR* argv[])
{
    Derived* p = new Derived();
    bar(p);
}

确定虚函数是否过载

2 个答案: