没有使用函数指针参数的隐式转换？

Question

我遇到过这种奇怪的情况。 我希望指针隐式转换：

struct BaseClass
{};

struct DerivedClass : BaseClass
{};

void baseClassArgFunc(BaseClass* arg) {}            // Function taking BaseClass argument
void derivedClassArgFunc(DerivedClass* arg) {}      // Function taking DerivedClass argument

int main()
{
    void (*pBaseFuncArg) (BaseClass*);      // Pointer to function taking BaseClass argument
    void (*pDerivedFuncArg) (DerivedClass*);    // Pointer to function taking DerivedClass argument

    pBaseFuncArg = baseClassArgFunc;            // Assign pointer, works fine
    pDerivedFuncArg = derivedClassArgFunc;      // Assign pointer, works fine

    pBaseFuncArg = derivedClassArgFunc;         // A value of type void (*) (DerivedClass *arg) cannot be 
                                                // assigned to an entity of type void (*) (BaseClass *)

    pDerivedFuncArg = baseClassArgFunc;         // A value of type void (*) (BaseClass *arg) cannot be 
                                                // assigned to an entity of type void (*) (DerivedClass *)

    return 0;
}

我期望将void（*）（DerivedClass *）分配给void baseClassArgFunc（BaseClass * arg）是安全的。 我糊涂了。 我猜没有函数指针参数的隐式转换吗？

Answer 1

更改类以暴露问题：

struct BaseClass
{
};

struct DerivedClass : BaseClass
{
    int a;
};

然后

pBaseFuncArg = derivedClassArgFunc;

对于以下情况是不安全的：

 void derivedClassArgFunc(DerivedClass* arg) { arg->a = 42; }


 int main()
 {
     void (*pBaseFuncArg) (BaseClass*) = derivedClassArgFunc;
     BaseClass base;

     //derivedClassArgFunc(&base); // Doesn't compile as expected
     pBaseFuncArg(&base);          // Would be UB, base->i won't exist
 }