C++ - 希望虚拟仅作为重定向

Question

假设我有一个模板：

template <class N, class I>
void add(N* element, std::list<N*> & container, I (N::*f)() const,
        std::string successmsg, std::string exceptmsg) {
//...
}

我想调用它来获取指向派生类的基类指针的列表。

add(newAirplane, airplanes, &Airplane::getRegistration,
        "Added!", "Error: Existent!");

Airplane 继承自AirplaneType。

当然，它无法编译，N 首先定义为 AirplaneType，然后定义为 Airplane。

我添加了一个虚拟 getRegistration @AirplaneType 但当然，编译器会给出 vtable 错误。

解决这个问题的正确方法是什么？ AirplaneType 没有 registration 属性，我对它拥有一个不感兴趣。我还想避免 virtual getRegistration() const {return "";}

有什么好的实践建议吗？

编辑：

感谢您的回答，但仍然不起作用。我想我已经找到了剩下的问题，但没有找到它的解决方案：

void Airline::addAirplane(AirplaneType* airplane) {
add(newAirplane, airplanes, &Airplane::getRegistration,
        "Added!", "Error: Existent!");

}

收到的指针类型是AirplaneType，而不是Airplane。

airplanes 是 AirplaneType 指针的列表。

Answer 1

由于 C++ 不处理逆变类型，因此您需要为公共基础添加额外的模板参数。也就是说，std::list 是与 std::list 完全不同的类型，并且不能从指向派生最多的指针到派生最少的指针列表。因此，实际上您的 add 函数需要变为：

template <class N, class I, class B>
void add(N* element, std::list<B*> & container, I (N::*f)() const,
        std::string successmsg, std::string exceptmsg)

Answer 2

您需要另一个模板参数，因为您关心两个不同的类 - 指针的类型（以及您要使用它调用的成员函数）和容器的类型：

#include <list>

struct AirplaneType {
};

struct Airplane : AirplaneType {
    int check() const { return 3; }
};

template <typename T, typename U, typename I>
void add(T* element, std::list<U*> & container, I (T::*f)() const) {
    container.push_back(element);
    I i = (element->*f)();
}

int main() {
    std::list<AirplaneType*> ls;
    Airplane a;
    add(&a, ls, &Airplane::check);
}

在本例中，我的 add 函数并没有真正使用 container 是一个 list 的事实，因此更明智的版本可能是：

template <typename T, typename U, typename I>
void add(T* element, U & container, I (T::*f)() const) {
    container.push_back(element);
    I i = (element->*f)();
}

然后，您可以进一步抽象：

template <typename T, typename U, typename AUF>
void add(T element, U & container, AUF func) {
    container.push_back(element);
    typename AUF::result_type i = func(element);
}

。 ..但这对于调用者来说稍微不太方便：

#include <functional>

add(&a, ls, std::mem_fun(&Airplane::check));

有什么好的实践建议吗？

不要创建原始指针的容器。

编辑：要使其与虚拟函数一起使用，我的每个选项：

#include <list>
#include <functional>
#include <iostream>

struct AirplaneType {
    virtual int check() const { return 0; }
};

struct Airplane : AirplaneType {
    int check() const { std::cout << "check\n"; return 3; }
};

template <typename T, typename U, typename I>
void add(U* element, std::list<T*> & container, I (U::*f)() const) {
    container.push_back(element);
    I i = (element->*f)();
}

template <typename T, typename U, typename AUF>
void add2(T element, U & container, AUF func) {
    container.push_back(element);
    typename AUF::result_type i = func(element);
}

int main() {
    std::list<AirplaneType*> ls;
    Airplane a;
    add(static_cast<AirplaneType*>(&a), ls, &AirplaneType::check);
    add2(&a, ls, std::mem_fun(&AirplaneType::check));
}

输出是：

check
check

即使函数指针指向 AirplaneType::check，而不是 <，也显示覆盖被正确调用。代码>飞机::检查。