多次调用函数中的c ++大向量

Question

我有一个函数可以为其内部工作创建一个大向量。假设我们还需要多次调用此函数。处理向量内存 creation/destruction 的最佳方法是什么（因素是性能、代码质量……）

方法一：

void f(int n) {
    vector<int> v(n);
 }

 int main() {
     for (int i = 0; i < 1000000; ++i) f(10000000);
 }

方法二：

void f(int n) {
    static vector<int> v;
    v.reserve(99999999); // say this is the maximum possible size

    v.resize(n);
}

 int main() {
     for (int i = 0; i < 1000000; ++i) f(10000000);
 }

方法二肯定比方法一快，但是长得丑。什么是最好的方法

Answer 1

将函数转换为 class 和 operator()。

class f_class {

   std::vector<int> v;

public:

   f_class()
   {
        v.reserve(99999999);
   }

   void operator()(int n)
   {
        v.resize(n);
        // Whatever the original f() did
   }
};

int main() {

     f_class f;

     for (int i = 0; i < 1000000; ++i) f(i);
}

Answer 2

根据您的示例，您的向量大小相同，那么为什么不只创建一个向量呢？

  using namespace std;
    void f(vector<int>& v) {
        // Do something with vector
    }
    int main() {

        int n = 10000000;
        vector<int> v(n);

        for (int i = 0; i < 1000000; ++i)
            f(v);
    }

Answer 3

v.reserve() //deals with capacity.
v.resize(n) //deals with size.

在方法2中，static vector遇到的只是改变大小，但是保留的space大于大小，因此容量没有变化，当你在循环中迭代它只是增加了一个。因此，大小每次都会增加一。容量没有变化。通常如果在一个空的int向量上调用resize，该调整大小范围内的向量元素将被初始化为0。

在方法 1 中，创建大小为 n 的向量，但使用最接近的 n<2^k 整数值作为容量（例如，如果 n=100，则容量为 128，当 n= 200 个，容量 256 个，依此类推）。此外，当您调用方法一时，每次函数超出范围时您都在创建和销毁。请注意，向量是空的，因为它没有任何值。

在方法 2 中，向量是静态的并保持不变。

您可能想阅读：

Reserve

Capacity

另外，如果你有向量保留内存，假设你可能不会被内存量所困扰，内存的预分配，不断插入对于每个操作，摊销分析都会有一个 Big-O(1)。

多次调用函数中的c ++大向量

c++ big vector in function called multiple times

c++

performance

software-quality

function

vector