指向函数和派生类的指针

Question

我对 g++ 以及模板如何与函数指针交互有疑问。考虑以下模板声明。

template <class T,class B> class TestTemplate {

  private:
    T* context;

  public:
    TestTemplate(T* usingClass);

    B* testfcnOK(B* arg);
    B* testfcnBAD(B* (T::*fcn)(void));
};

template <class T,class B> TestTemplate<T,B>::TestTemplate(T* usingClass) {
  context = usingClass;
}

template <class T,class B> B* TestTemplate<T,B>::testfcnOK(B* arg) {
    return arg;
}

template <class T,class B> B* TestTemplate<T,B>::testfcnBAD(B* (T::*fcn)(void)) {
    return (context->*fcn)();
}

将 T 视为一个类，其中包含返回类型 B 的对象的各种函数。上面要重点关注的方法是 testfcnBAD()，因为它会导致问题。这是使用此模板的代码。

class Base { };
class Derived : public Base { };

class Tester {

  public:
   TestTemplate<Tester,Base> *templateClass;

   Base* returnBase() { return new Base(); }
   Base* returnDerivedOK() { return new Derived(); }
   Derived* returnDerivedBAD() { return new Derived(); }

   void runTest()
     {
       templateClass = new TestTemplate<Tester,Base>(this);

       // These work.
       Base* baseResult = templateClass->testfcnOK(new Base());
       baseResult = templateClass->testfcnOK(new Derived());
       baseResult = templateClass->testfcnBAD(&Tester::returnBase);
       Derived* derivedResult = (Derived*) templateClass->testfcnBAD(&Tester::returnDerivedOK);

       // This does not work.
       derivedResult = (Derived*) templateClass->testfcnBAD(&Tester::returnDerivedBAD);
     }
};

当给出 runTest() 的最后一行时，g++ (4.5.2) 被阻塞。问题似乎是 testfcnBAD() 传递了一个指向返回 Derived 实例的函数的指针，而 TestTemplate 声明 testfcnBAD() 接受一个指向返回 Base 对象的函数的指针。看起来这段代码应该没问题，因为 Derived 对象是一个 Base 对象，但 Derived 是 Base 的子类这一事实可能会在某个地方丢失。

我在这里遗漏了什么吗？有解决方法吗？

Answer 1

我不是 C++ 标准方面的专家，但据我所知，协变返回类型仅在重写函数时适用。不能将协变返回类型与函数指针一起使用。我会提出类似的建议：

template <class T,class B> class TestTemplate {

  private:
    T* context;

  public:
    TestTemplate(T* usingClass);

    B* testfcnOK(B* arg);
    template<typename D> B* testfcnBAD(D* (T::*fcn)(void));
};

Answer 2

根据您的代码，如果您可以将 Derived *(Derived:: *)() 转换为 Base *(Base:: *)()，则会违反类型安全性：

Derived *(Derived:: *derived_method)()= &Derived::returnDerivedBAD;
Base *(Base:: *base_method)()= derived_method;
Base b;
(b.*base_method)(); // would compile, but invalid at runtime! Oops!

所以你无法安全地“解决它”。即使您更改返回类型以匹配，它仍然会违反类型安全。