定义生成元素向量C ++的函数时正确的方法是什么

Question

我必须在 C++ 中定义一个函数来生成类 Foo 的向量并返回它。

我可以用不同的方式定义它，它们都是相当的：

C风格参数传递：

void generateFooVector(vector<Foo> * result)
{
    for (int i = 0; i < 100; i++)
    {
        Foo f = Foo();
        result->push_back(f);
    }
}
int main()
{

    vector<Foo> result;
    generateFooVector(&result);
}

参考传递传递：

void generateFooVector(vector<Foo> & result)
{
    for (int i = 0; i < 100; i++)
    {
        Foo f = Foo();
        result->push_back(f);
    }
}
int main()
{
    vector<Foo> result;
    generateFooVector(result);
}

实例化向量并返回指针：

vector<Foo> * generateFooVector()
{
    vector<Foo> * result = new vector<Foo>();
    for (int i = 0; i < 100; i++)
    {
        Foo f = Foo();
        result->push_back(f);
    }
    return result;
}
int main()
{
    vector<Foo> * result = generateFooVector();
}

C 风格的传递和实例化 Foo 类：

void generateFooVector(vector<Foo *> * result)
{
    for (int i = 0; i < 100; i++)
    {
        Foo * f = new Foo();
        result->push_back(f);
    }
}
int main()
{
    vector<Foo *> result;
    generateFooVector(&result);
}

引用传递 + Foo 实例：

void generateFooVector(vector<Foo *> & result)
{
    for (int i = 0; i < 100; i++)
    {
        Foo * f = new Foo();
        result->push_back(f);
    }
}
int main()
{

    vector<Foo *> result;
    generateFooVector(result);
}

Vector 实例 + Foo 实例：

vector<Foo*> * generateFooVector()
{
    vector<Foo*> * result = new vector<Foo*>();
    for (int i = 0; i < 100; i++)
    {
        Foo * f = new Foo();
        result->push_back(f);
    }
    return result;
}
int main()
{

    vector<Foo *> * result = generateFooVector();
}

按值传递：

vector<Foo> generateFooVector()
{
    vector<Foo> result;
    for (int i = 0; i < 100; i++)
    {
        Foo f = Foo();
        result->push_back(f);
    }
    return result;
}
int main()
{

    vector<Foo > result = generateFooVector();
}

也许还有很多其他的解决方案。

所有当前的方式在范围内如何分配内存都有不同的含义。

也许我缺乏理论，但我真的很困惑如何确定每个用例的更好选择，以及为什么一个比另一个更好。你能帮帮我吗？

Answer 1

我确实看到了两个主要的不同实现 - vector<Foo*> 和 vector<Foo>。其他都是参数传递的变种。

如您所知，vector 在添加时复制元素，在删除vector 时调用元素析构函数。因此，在vector<Foo*> 的情况下，您要避免复制对象，如果对象非常大，这些对象可能会增加。 但是你有责任删除记忆。所以最好存储带有自动删除功能的智能指针，比如vector<shared_ptr<Foo>> 或vector<unique_ptr<Foo>>（这里需要移动逻辑）。指针的类型取决于您的应用程序逻辑。

顺便说一句，

 Foo* pFoo = new Foo;  // also default constructor call

（你知道the difference 和new Foo() 吗？）

 vector<Foo> v(n);  // init vector with n Foo objects calling default ctor 

Answer 2

该函数已在标准库中定义，称为std::vector<Foo> 的构造函数。您可以将其称为（C++11 风格）

auto v = std::vector<Foo>(n); // create n default constructed Foo() objects

或以 C++98 风格（在 C++11 中也有效）为

std::vector<Foo> v(n); 

我不会尝试包装这个。

• 首先，您不想在其中隐藏像 100 这样的幻数，而不是在参数列表（模板或运行时）中隐藏。
• 不包装构造函数的另一个原因是为了避免读者混淆。如果我遇到generateVector 函数，第一个问题是：“与普通的构造函数调用相比，这个函数是否做了其他/额外的事情？”

Answer 3

我认为这在很大程度上取决于实际使用情况——最关键的是 foo 有多重？ 如果 foo 是轻量级对象和类似 POD 的类型，那么我会使用

Vector<Foo> generateFoo();

否则可能是这样的：

Vector<Foo*> generateFoo();

可能更有用。

标准类型是高效的，并且最喜欢被复制，因此它们对 vector* 解决方案的优势不大。 一般来说，返回（或使用）需要稍后删除的原始指针可能是不明智的——在这种架构中很容易产生泄漏。所以也许看看你的 foo 对象的各种智能指针选项。

Answer 4

我可能会采用上面采用的参考传递方法。

通常在 C 和 C++ 中，您不希望返回需要稍后释放的对象，因为这可能会导致泄漏。

Answer 5

做事

vector<Foo> generateFooVector()
{
    return vector<Foo>(100);
}

它叫modern c++。