使用C ++将不同类的对象存储在向量中


storing objects of a different class in a vector in C++

我有一个类user，它将另一个类foo的对象存储在一个向量中。我试图找出创建foo类对象的最佳方法，并将它们存储在类用户的向量中。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
class Foo {
    public:
        Foo();
        Foo(std::string str);
        std::string name;
        Foo* GiveMeFoo(std::string arg);
};
Foo::Foo() {}
Foo::Foo(std::string args):name(args) {}
Foo* Foo::GiveMeFoo(std::string arg) {  return new Foo(arg) };

class User {
    public:
        vector &lt Foo *> v;
        vector &lt Foo> v2;
        vector &lt Foo*> v3;
        void start();
};

void User::start()
{
    const int SIZE = 3;
    string a[SIZE] = {"one","two","three"};
    for (int i = 0; i &lt SIZE; i++ ){

        //method1
        Foo *f = new Foo();
        f->name = a[i];
        v.push_back(f);

        //method2
        Foo f2;
        f2.name = a[j];
        v2.push_back(f2);

        //method3
        Foo f3;
        v3.push_back(f3.GiveMeFoo(a[k]));
    }
}

问题1：在方法1、2和3之间，是否有一种做事情的首选方法？有没有更好的方法在本地创建远程类的对象并将它们存储在向量中？

问题2：所有存储在类用户向量中的对象是否都是持久的(例如，即使foo对象消失了，一旦我将这些对象推到用户向量上，那么这些foo对象的副本将持久地存储在向量中，对吗？

除非有其他考虑，方法2是首选的。

vectors(和其他stl容器)存储参数的副本以将_向后推()。

这意味着对于方法1，您要在堆上分配一个foo，然后在向量中存储指向它的指针。如果用户对象被破坏，那么foo对象将泄漏，除非您采取步骤删除它们(如在用户析构函数中删除它们)。

对于方法2，您已经在堆栈上分配了一个foo。然后将此对象复制到向量中。当start()退出时，原始foo将被销毁，但副本仍保留在向量中。如果用户对象被破坏，那么向量和foo也是如此。

对于方法3，您已经在堆栈上分配了一个foo。然后对它调用givemefoo()，该函数在堆上分配另一个foo，然后返回指向它的指针。然后将此指针复制到向量中。当start()退出时，原始foo将被销毁，但堆分配的对象将继续存在。如果用户对象被销毁，那么向量也会被销毁，但如果不在用户的析构函数中手动销毁，则分配给堆的foo会存活并泄漏。

如果需要存储指向对象的指针而不是副本，那么最好使用std:：tr1:：shared_ptr(如果编译器支持)来管理foo对象的生存期。

在它帮助某人的情况下，如C++ 11，STD::vector(连同一些其他STL容器)现在有能力将实例"放置"到集合中。这样做的好处是避免了可能的额外复制对象或副本。

对于上面的示例，可以使用类似这样的代码：

1
v.emplace_back(a[i]);

更多信息：std：：vector：：emplace_back