C++ C++；boost ptr_向量的成员模板

我正在尝试使用boost:：ptr_vector编写一个容器类。在ptr_向量中，我希望包含不同的类。我试图用静态模板来实现这一点，但到目前为止我还不能做到。例如，容器类是

class model {
private:
  boost::ptr_vector<elem_type> elements;
public:
  void insert_element(elem_type *a) {
element_list.push_back(a);
  }
};

是否可以只在成员上使用模板

 class model {
private:
 template <typename T> boost::ptr_vector<T> elements;
public:
  void insert_element(T *a) {
element_list.push_back(a);
  }
}; //wrong

类模型{
私人：
模板boost：：ptr_向量元素；
公众：
无效插入元素（T*a）{
元素列表。推回（a）；
}
}; //错误的

所以我可以在我想要插入的特定类上调用insert_元素？请注意，我不想使用虚拟成员。

---

谢谢

向量包含每个元素与其他元素具有相同类型的元素。如果要创建不同类元素的向量，可以使用类型为

boost:：any

的元素向量，其中每个元素的类型与其他元素相同。如果要创建不同类元素的向量，可以使用类型为

boost:：any

的元素向量尝试使用以下向量：

#包括
#包括
#包括
#包括
结构Foo
{
Foo（intv=0）：a（v）{
INTA；
};
结构条
{
Bar（intv=0）：b（v）{}
int b；
};
结构打印访问者：public boost:：static\u访问者
{
void运算符（）（常量Foo&Foo）常量
{
std:：cout尝试使用以下向量：

#包括
#包括
#包括
#包括
结构Foo
{
Foo（intv=0）：a（v）{
INTA；
};
结构条
{
Bar（intv=0）：b（v）{}
int b；
};
结构打印访问者：public boost:：static\u访问者
{
void运算符（）（常量Foo&Foo）常量
{
STD::CUT当使用Booo:：任何时候，我必须手动地从Booost中输入所有的元素：：pTrIVAL向量，什么是不可取的。@伊凡：据我所知，在C++中，没有一种方法可以使一个异质集合（即“包”）返回一个特定的、非多态类型的元素（没有用户指定类型）。。您可以选择返回对元素基类的引用（多态性），使用变量类型（boost:：any或boost:：variant）在模板参数指定返回类型的情况下，使用模板成员函数。这是C++的一大缺点，因为它符合我的模拟的所有其他要求-速度、编码容易、维护方便。我将使用您提供的代码使用变量和访问者进行测试，并使用函子访问。但是如果这显示出问题，也许更容易使用相同的方法，使用Fortran？速度是非常重要的因素，只有精度更重要。当使用Booo:：任何时候，我必须手动地从Boost中返回所有元素：：ptryValthar，什么是不可取的。@伊凡：据我所知，在C++中，没有一种方法可以用于杂种。ous集合（即“bag”）返回特定的非多态类型的元素（用户不指定类型）。您可以选择返回对元素基类的引用（多态），使用变量类型（boost:：any或boost:：variant）在模板参数指定返回类型的情况下，使用模板成员函数。这是C++的一大缺点，因为它符合我的模拟的所有其他要求-速度、编码容易、维护方便。我将使用您提供的代码使用变量和访问者进行测试，并使用函子访问。但如果这显示出问题，那么使用相同的方法和Fortran可能更容易？速度是一个非常重要的因素，只有精度更重要。复制集合中的元素是否昂贵？从集合中检索元素时，您如何知道每个位置存储的元素类型？是否有限制可以存储在您的集合中的t个类型？或者可以存储任何内容吗？嗨，Emile，谢谢您的回答。这个想法是开发一个通用容器。我会事先知道应该存储的类型，但我需要更改代码，以便在开发完新元素后立即将其扩展。代码的这一特定部分将被执行需要很多，所以虚拟继承速度太慢。访问元素时，我需要类似于静态强制转换的东西。我只会在向量上插入一次，但在执行过程中会连续读取整个列表几次。复制集合中的元素是否昂贵？从集合中检索元素时，您如何知道每个位置存储的是什么类型的元素？在您的集合中可以存储的类型有限吗？或者可以存储任何东西吗？嗨，Emile，谢谢您的回答。想法是开发一个通用容器。我会事先知道应该存储的类型，但我需要更改代码以扩展到新的元素很快它们就被开发出来了。代码的这一特定部分将被大量执行，因此虚拟继承的速度太慢了。在访问元素时，我需要类似于静态转换的东西。我只会在向量上插入一次，但在执行过程中会依次读取整个列表几次。
model <elem_type_1> model_thing;
model_thing.insert_element(new elem_type_1)

model_thing.insert_element(new elem_type_2)//error, of course

 class model {
private:
 template <typename T> boost::ptr_vector<T> elements;
public:
  void insert_element(T *a) {
element_list.push_back(a);
  }
}; //wrong

#include <iostream>
#include <vector>
#include <boost/variant.hpp>
#include <boost/foreach.hpp>

struct Foo
{
    Foo(int v=0) : a(v) {}
    int a;
};

struct Bar
{
    Bar(int v=0) : b(v) {}
    int b;
};

struct print_visitor : public boost::static_visitor<>
{
    void operator()(const Foo& foo) const
    {
        std::cout << "Foo " << foo.a << "\n";
    }

    void operator()(const Bar& bar) const
    {
        std::cout << "Bar " << bar.b << "\n";
    }
};

int main()
{
    typedef boost::variant<Foo, Bar> Variant;
    std::vector<Variant> bag;
    bag.push_back(Foo(123));
    bag.push_back(Bar(456));

    BOOST_FOREACH(const Variant& element, bag)
    {
        boost::apply_visitor(print_visitor(), element);
    }
}