C++ 不使用虚函数从基类调用派生类函数

嗨，假设我有这样的代码

// base class                                                                                                                                                

    class A {

    public:

      int CallMyFct(PtrToFCT what){
        return what(10);
      }

    };

    class B : public A {
      int myInt;

    public:
      B():myInt(10){}

      int myFct1(int val){
        return myInt+val;
      }

      int myFct2(int val){
        return myInt*2+val;
      }


      void Call(void){
        int rez1=CallMyFct(&myFct1);
        if (rez1!=20)
          cout << "You are wrong" << endl;

        int rez2=CallMyFct(&myFct2);
        if (rez2!=30)
          cout << "You are wrong" << endl;
      }

    };

//基类
甲级{
公众：
int CallMyFct（PtrToFCT what）{
返回什么（10）；
}
};
B类：公共A{
int-myInt；
公众：
B（）：myInt（10）{}
int myFct1（int val）{
返回myInt+val；
}
int myFct2（int val）{
返回myInt*2+val；
}
作废通知（作废）{
int rez1=CallMyFct（&myFct1）；
如果（rez1！=20）
cout您必须将要调用的函数定义为
静态
，并提供附加参数以将其传递到对象实例（而不是
这个
，如果将其作为常规成员函数调用，它们将获得这些参数）。
您可以使用
[boost:：function]更清晰地执行您喜欢的操作
，也称为C++2011中的
中的
std:：function
。您没有说明为什么不能使用虚拟函数。不清楚此方法是否比虚拟函数提供了性能增强，但不使用虚拟函数还有其他原因

在任何情况下，这都符合（我的解释）您从基类调用函数的要求，这些基类在不使用虚拟函数的情况下根据实际派生类的不同行为有所不同。我并不完全清楚您想要使用的示例。如果此机制不满足您的需要，请澄清这些需要

#include <iostream> 
#include <boost/bind.hpp>
#include <boost/function.hpp>

class A{
protected:
    typedef boost::function<int (int)> CallbackFunc;
    // A knows it can call *something* with a particular signature
    // but what is called can be overridden by the derived class.
    CallbackFunc m_callbackFunc;
public:
    A()  
    {
    m_callbackFunc = boost::bind(&A::same,this,_1); 
    } 
    int same(int val) const { return val; }
    int simulateVirtual(int val) const { return m_callbackFunc(val); }
}; //end class A

class B : public A {
    int m_offset;
public:
    B(int offset) : m_offset(offset) {
        m_callbackFunc = boost::bind(&B::offset,this,_1);
    }
    int offset(int val) const { return m_offset + val; }
}; // end class B 

int main() {
    A* pA = new A;
    A* pB = new B(42);
    std::cout << "simulateVirtual(10) called on a 'real' A instance=" 
    << pA->simulateVirtual(10) << "\n";
    std::cout << "simulateVirtual(10) called via A* on a B instance="
    << pB->simulateVirtual(10) << "\n";
    delete pB; // in real life I would use shared_ptr<>
    delete pA;
    return 0;
} // end main

#包括
#包括
#包括
甲级{
受保护的：
typedef boost:：函数CallbackFunc；
//A知道它可以用特定的签名来调用某物
//但是调用的内容可以被派生类重写。
CallbackFunc m_CallbackFunc；
公众：
()
{
m_callbackFunc=boost:：bind（&A:：same，this，_1）；
} 
int same（int val）const{return val；}
int模拟虚拟（int val）常量{return m_callbackFunc（val）；}
}//A班结束
B类：公共A{
国际货币单位偏移量；
公众：
B（内部偏移）：m_偏移（偏移）{
m_callbackFunc=boost:：bind（&B:：offset，this，_1）；
}
int offset（int val）const{return m_offset+val；}
}；//结束B类
int main（）{
A*pA=新的A；
A*pB=新的B（42）；
std:：cout Thank..我想到了这一点，这是可行的，但是如果我不想使用静态的，那么这是可能的吗？这不是小事，因为类是相关的。对于不相关的类（其中一个的定义不依赖于另一个的定义，您可以使用直接调用）。您可以做的是传递原始指针，并将它们转换到实现类a的单独文件中的B:：函数指针中。这很难看，我不会这么做（我根本不会做您试图做的事情，它的设计很糟糕）嗯…是的，关于糟糕的设计你是对的，事实上我只是想学习STL，当我学习mem_fun的时候，我认为这种事情可能会从中发生，显然不是。可能会有帮助