c++ - 创建具有多个继承输入类型的泛型类

Question

我想创建一个父类，它定义了一个可以在继承中重写的通用虚函数，并且在每个 child 中，我想更改输入类型。我尝试创建一个模板函数，但我发现如果您尝试将其设为虚拟，模板函数将无法编译。我有一个想法，在父类中对变量进行模板化，这样就不必在这个变量上使用继承，然后在子类中，使用特定版本的变量在覆盖函数中做一些事情。

class a {
    virtual void doSomething() {
        //nothing in parent
    }

    template<typename T>
    T input;

    template<typename T>
    void SetInput(T i) {
        this->input = i;
    }
};

class b : a {
    virtual void doSomething() override {
        float test = this->input;
    }
};

class c : a {
    virtual void doSomething() override {
        char test = this->input;
    }
};

class d : a {
    virtual void doSomething() override {
        int test = this->input;
    }
};

void main(){
    std::vector<a> allNodes(3);
    b t1;
    t1.SetInput<float>(41.5f);
    c t2;
    t2.SetInput<char>('b');
    d t3;
    t3.SetInput<int>(3);
    allNodes[0] = t1;
    allNodes[1] = t2;
    allNodes[2] = t3;

    for (a node : allNodes) {
        node.doSomething();
    }
}

但从现在开始，这个想法不再编译，因为它告诉我需要在父亲中定义，在 SetInput()函数，模板的类型我会设置它。
如果你有什么想法请告诉我。谢谢

Answer 1

这是一个让很多人感到困惑的典型问题，可以通过以下步骤非常简单地完成:

在不知道对象类型的情况下制作一个包含你要调用的常用函数的接口(interface)，我将其命名为Doable

创建从接口(interface)Doable派生的模板类, 我把它命名为 MyType ，其中包含模板化数据成员和操作 get() & set() .重要提示:也覆盖了 Doable 中的纯虚函数

特化模板功能dosomething()对于您想在程序中使用的所有数据类型。

== 宾果游戏 ==

#include <iostream>
#include <string>
#include <vector>

class Doable {
public:
    virtual ~Doable() = default;
    virtual void dosomething() = 0;
};

template <typename T>
class MyType : public Doable {
public:
    T data_;
    void set(const T& d) {
        data_ = d;
    }
    T get() const {
        return data_;
    }
    void dosomething() override { }
};


template<>
void MyType<int>::dosomething() {
    std::cout << "int: " << data_ << std::endl;
}

template<>
void MyType<char>::dosomething() {
    std::cout << "char: " << data_ << std::endl;
}

template<>
void MyType<float>::dosomething() {
    std::cout << "float:" << data_ << std::endl;
}

int main(){
    std::vector<std::unique_ptr<Doable>> a;
    std::unique_ptr<MyType<float>> b1(new MyType<float>);
    b1->set(41.5f);
    a.push_back(std::move(b1));

    std::unique_ptr<MyType<char>> b2(new MyType<char>);
    b2->set('b');
    a.push_back(std::move(b2));

    std::unique_ptr<MyType<int>> b3(new MyType<int>);
    b3->set(3);
    a.push_back(std::move(b3));

    for (auto& ptr : a){
        ptr->dosomething();
    }
}

输出是:

float:41.5
char: b
int: 3