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

Question

我有一个模板类可以（或必须）专门的参数。 我想把我的所有参数放在一个容器中。 如何做到这一点，如果我的参数与不同类型instanciated？

在类容器，我会希望有不同类型（int，双...）或等同的东西的载体<参数* >这似乎是不可能的。

如果Parameter类是从基类派生的，那么The Container可以声明vect为向量< Base * >。但在这种情况下，我们无法在Container :: foo中做任何具体的操作。

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

感谢您的意见。

    #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

正确的解决办法是写的基础类不够好接口，这样你可以做你需要做的一切：

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; 
}; 

虽然这可能不是你想要的，它仍然允许传递值从下一个参数。一旦你想要实际的值，你需要知道编译时的类型。该类型的开关大小可能有助于使其运行。