C++ 是否可以拥有一个包含不同类型参数的专用模板对象的容器？

Question

我有一个可以（或必须）专门化的模板化类参数。 我想把我所有的参数放在一个容器中。 如果我的参数被实例化为不同的类型怎么办？

在 Container 类中，我希望拥有一个来自不同类型（int、double、...）的向量 或类似的东西，这似乎是不可能的。

如果 Parameter 类派生自基类，则 Container 可以将 vect 声明为 vector。但是在这种情况下，我们不能在 Container::foo 中做任何特定的事情。

以下是我的源示例。我的参数之一是与 ostream 不兼容的 QString。

感谢您的 cmets。

    #include <QString>
    #include <vector>
    #include <iostream>
    #include <string>
    #include <sstream>
    using namespace std;

    #define P(a) cout << #a << ":" << a << endl

    /*
    class Base {

    };
    */

    template<typename T> class Parameter /*: public Base */ {
    private:
        T val;
    public:
        void setVal(const T &val) {
            this->val = val;
        }
        const T &getVal() {
            return val;
        }
        string getFoo() {
            stringstream s;
            s << val;
            return s.str();
        }
    };

    template<>
    string Parameter<QString>::getFoo() {
        stringstream s;
        s << val.toStdString();
        return s.str();
    }

    class Container {
    public:
        void push_back(Parameter *base) {
            vect.push_back(base);
        }
        void foo() {
            /* do something with the parameters */
        }
    private:
        vector<Parameter*> vect;
    };

    int main() {
        Parameter<int> pi;
        Parameter<QString> ps;

        pi.setVal(10);
        ps.setVal("QString");

        P(pi.getVal());
        P(ps.getVal().toStdString());

        P(pi.getFoo());
        P(ps.getFoo());

        Container container;
        container.push_back(&pi);
        container.push_back(&ps);
    }

非常感谢你们。我会听从你的建议并使用 boost::any。 这是更新版本：

    #include <boost/any.hpp>
    #include <QString>
    #include <vector>
    #include <iostream>
    #include <string>
    #include <sstream>
    using namespace std;

    #define P(a) cout << #a << ":" << a << endl

    template<typename T> class Parameter {
    private:
        T val;
    public:
        void setVal(const T &val) {
            this->val = val;
        }
        const T &getVal() {
            return val;
        }
        string getFoo() {
            stringstream s;
            s << val;
            return s.str();
        }
    };

    template<>
    string Parameter<QString>::getFoo() {
        stringstream s;
        s << val.toStdString();
        return s.str();
    }

    class Container {
    public:
        void push_back(boost::any base) {
            vect.push_back(base);
        }
        void foo() {
            cout << "do something with the parameters\n";
            for (vector<boost::any>::iterator i = vect.begin(); i != vect.end(); ++i) {
                boost::any a = (*i);
                if (a.type() == typeid(Parameter<int>*)) {
                    Parameter<int> *ai = boost::any_cast<Parameter<int> *>(a);
                    cout << ai->getFoo() << endl;
                } else if (a.type() == typeid(Parameter<QString>*)) {
                    Parameter<QString> *aq = boost::any_cast<Parameter<QString> *>(a);
                    cout << aq->getFoo() << endl;
                } else {
                    cout << "unknown type:" << a.type().name() << endl;
                }
            }
        }
    private:
        vector<boost::any> vect;
    };

    int main() {
        Parameter<int> pi;
        Parameter<QString> ps;

        pi.setVal(10);
        ps.setVal("QString");

        P(pi.getVal());
        P(ps.getVal().toStdString());

        P(pi.getFoo());
        P(ps.getFoo());

        Container container;
        container.push_back(&pi);
        container.push_back(&ps);
        container.foo();
    }

Answer 1

您可以使用Boost.Any，它可以保存任何类型的数据。然后，您将使用 boost::any_cast<> 将对象转换回正确的类型。

除此之外，您必须采用基类方法，但正如您所提到的，可能很难让 Container::foo 做任何有用的事情。

解决此问题的一种方法是让所有 foo 函数将字符串作为参数，然后该函数的每个特定实现都会解析该字符串并将其转换为正确的类型。

编辑： Boost.Any 示例：

#include <iostream>
#include <boost/any.hpp>

int main()
{
    boost::any param = 89;

    // This will fail because `param` is currently holding an int
    // not a char
    char ch = boost::any_cast<char>(param);

    // This works
    int i = boost::any_cast<int>(param);

    // You can always change the value and type of what
    // `param` is holding
    param = "example";
}

Answer 2

容器内的所有东西都必须是同一类型。我做了一些类似于你的方法的事情，我创建了一个具有一些有用的通用接口的基类，并且派生类是模板化的。解决方案的唯一其他方法是定义一个基类函数以返回一个值来指示类型，然后向下转换基类。

Answer 3

正确的解决方案是为 Base 类编写足够好的接口，这样你就可以做你需要做的一切：

class Base {
public:
  virtual void *GetVal() const=0;
  virtual void SetVal(void *ptr)=0;
  virtual std::string Type() const=0;
  virtual std::string GetAsString() const=0;
};

虽然这可能不是您想要的，但它仍然允许将值从一个参数传递到下一个参数。一旦你想要实际值，你就需要知道编译时的类型。该类型的 Switch-case 可能有助于使其运行时。