Question

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

方法1：

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

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

方法2：

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);
 }

方法2肯定比方法1快，但它看起来很难看。什么是最好的方法

Answer 1

将该功能变为带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中，静态向量正在经历的只是改变大小，但是，保留空间大于大小，因此容量没有变化，当你在循环中迭代它时只增加一个。因此，每次只增加一个尺寸。容量没有变化。通常如果在int的空向量上调用resize，则调整大小范围内的向量元素将初始化为0.

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

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

你可能想要阅读：

Reserve

Capacity

此外，如果您有矢量保留存储器，并且假设您可能没有被存储器数量所困扰，则预分配存储器，通过摊销分析进行常量插入将具有Big-O（1），用于每个操作。

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

3 个答案: