从函数发回向量 如何正确地将下面的java代码翻译成C++？ Vector v; v = getLargeVector(); ... Vector getLargeVector() { Vector v2 = new Vector(); // fill v2 return v2; }

所以这里的

v

是一个参考。该函数创建一个新的向量对象并返回对该对象的引用。又好又干净

但是，让我们看看下面的C++镜像翻译：

vector<int> v;
v = getLargeVector();
...
vector<int> getLargeVector() {
    vector<int> v2;
    // fill v2
    return v2;
}

但我觉得这不是一个优雅的解决方案

所以我的问题是：最好的做法是什么（通过避免不必要的复制操作）？如果可能，我希望避免使用普通指针。到目前为止，我从未使用过智能指针，我不知道它们在这里是否有帮助。

void getLargeVector（vector&vec）{
void getLargeVector(vector<int>& vec) { 
    // fill the vector
} 

//填充向量
} 

---

就目前而言，这是一个更好的方法。对于c++0x，第一种方法的问题是使用移动操作而不是复制操作。

为什么要避免使用普通指针？是因为您不想担心内存管理，还是因为您不熟悉指针语法

---

如果您不想担心内存管理，那么智能指针是最好的方法。如果您对指针语法不满意，请使用引用。

您有最好的解决方案。通过引用是处理这种情况的方法。

< P>大多数C++编译器实现，这意味着您可以有效地从一个函数返回类，而不必复制所有对象的开销。 我还建议你写：

vector<int> v(getLargeVector());

向量v（getLargeVector（））；

---

因此，您可以复制构造对象，而不是默认构造，然后将运算符分配给它。

听起来您可以用类来完成此操作。。。但这可能是不必要的

#include <vector>
using std::vector;

class MySpecialArray
{
    vector<int> v;
public:
    MySpecialArray()
    {
        //fill v
    }
    vector<int> const * getLargeVector()
    {
        return &v;
    }
};

#包括
使用std：：vector；
类MySpecialArray
{
向量v；
公众：
MySpecialArray（）
{
//填充v
}
向量常量*getLargeVector（）
{
返回&v；
}
};

可以依靠RVO来简化代码的编写，但依赖RVO也会让您感到痛苦。RVO是依赖于编译器的特性，但更重要的是，支持RVO的编译器可以根据代码本身禁用RVO。例如，如果您要编写：

MyBigObject Gimme(bool condition)
{
  if( condition )
    return MyBigObject( oneSetOfValues );
  else
    return MyBigObject( anotherSetOfValues );
}

…那么即使是支持RVO的编译器也无法在此进行优化。在许多其他条件下，编译器将无法进行优化，因此根据我的估计，任何设计上依赖RVO的代码的性能或功能都是如此

如果您接受一个函数应该有一个作业的想法（我只是这么做），那么当您意识到您的代码在设计级别被破坏时，您关于如何返回填充向量的难题就会变得简单得多。你的函数实际上做了两件事：实例化向量，然后填充它。然而，即使撇开所有这些学究不谈，一个比依赖RVO更通用、更可靠的解决方案仍然存在。只需编写一个填充任意向量的函数。例如：

#include <cstdlib>
#include <vector>
#include <algorithm>
#include <iostream>

using namespace std;

template<typename Iter> Iter PopulateVector(Iter it, size_t howMany)
{
    for( size_t n = 0; n < howMany; ++n )
    {
        *(it++) = n;
    }

    return it;
}

int main()
{
    vector<int> ints;
    PopulateVector(back_inserter(ints), 42);
    cout << "The vector has " << ints.size() << " elements" << endl << "and they are..." << endl;
    copy(ints.begin(), ints.end(), ostream_iterator<int>(cout, " "));
    cout << endl << endl;

    static const size_t numOtherInts = 42;
    int otherInts[numOtherInts] = {0};
    PopulateVector(&otherInts[0], numOtherInts);
    cout << "The other vector has " << numOtherInts  << " elements" << endl << "and they are..." << endl;
    copy(&otherInts[0], &otherInts[numOtherInts], ostream_iterator<int>(cout, " "));

    return 0;
}

#包括
#包括
#包括
#包括
使用名称空间std；
模板Iter PopulateVector（Iter it，大小\数量）
{
对于（大小n=0；n<多少；++n）
{
*（it++）=n；
}
归还它；
}
int main（）
{
矢量整数；
PopulateVector（背部插入器（ints），42）；
多亏了NRVO，对于大多数现代编译器来说，这通常不是一个问题……请看：我担心可能的内存泄漏，因为我应该到处传递该向量。我肯定应该熟悉智能指针。std:：vector v=getLargeVector（）；我想这也可以做同样的工作，而且更清晰。
#include <cstdlib>
#include <vector>
#include <algorithm>
#include <iostream>

using namespace std;

template<typename Iter> Iter PopulateVector(Iter it, size_t howMany)
{
    for( size_t n = 0; n < howMany; ++n )
    {
        *(it++) = n;
    }

    return it;
}

int main()
{
    vector<int> ints;
    PopulateVector(back_inserter(ints), 42);
    cout << "The vector has " << ints.size() << " elements" << endl << "and they are..." << endl;
    copy(ints.begin(), ints.end(), ostream_iterator<int>(cout, " "));
    cout << endl << endl;

    static const size_t numOtherInts = 42;
    int otherInts[numOtherInts] = {0};
    PopulateVector(&otherInts[0], numOtherInts);
    cout << "The other vector has " << numOtherInts  << " elements" << endl << "and they are..." << endl;
    copy(&otherInts[0], &otherInts[numOtherInts], ostream_iterator<int>(cout, " "));

    return 0;
}