Question

我一直在阅读，并且在许多地方，推荐使用矢量数据，但我仍然没有完全理解，我不确定他们是否可以处理我的项目。

我正在进行CFD计算，我必须进行如下计算，

for(int i = 1 ; i < M ; i++) {
    for(int j = 1 ; j < N ; j++) {
        for(int k = 0 ; k < 4 ; k++) {
            dU_dX_plus=(U[i+1][j+1][k]+dU_dT[i+1][j+1][k]*dt/2+U[i+1][j][k]+dU_dT[i+1][j][k]*dt/2-2*U_p[i][j][k])/dx;
            dU_dX_min=-(U[i][j+1][k]+dU_dT[i][j+1][k]*dt/2+U[i][j][k]+dU_dT[i][j][k]*dt/2-2*U_p[i][j][k])/dx;
            dU_dX[i][j][k]=Wfunct(dU_dX_plus, dU_dX_min);

            dU_dY_plus=(U[i+1][j+1][k]+dU_dT[i+1][j+1][k]*dt/2+U[i][j+1][k]+dU_dT[i][j+1][k]*dt/2-2*U_p[i][j][k])/dy;
            dU_dY_min=-(U[i][j][k]+dU_dT[i][j][k]*dt/2+U[i+1][j][k]+dU_dT[i+1][j][k]*dt/2-2*U_p[i][j][k])/dy;
            dU_dY[i][j][k]=Wfunct(dU_dY_plus, dU_dY_min);
        }
    }
}

我可以用矢量实现吗？如果是这样，我该怎么办？是值得的还是我应该继续使用数组？

谢谢，

Answer 1

vector的优点是，内存直接在堆上分配。这意味着您还可以使用相当大的数组。这对于3D阵列尤为重要。请记住：大小为100x100x100的浮点数组需要4MB内存 - 大多数情况下堆栈太多。

通过使用vector而不是固定大小的数组，您还可以实现具有动态大小的数组，即在运行时不固定。

你可以这样做：

struct Array3D {

    int N, M, K; // size of array

    std::vector<float> U; // storage

    Array3D(unsigned n, unsigned m, unsigned k)
    : N(n), M(m), K(k), U(n*m*k) {}

    float index(unsigned i, unsigned j, unsigned k) const {
        return (i*M + j)*K + k;
    }

    float operator()(unsigned i, unsigned j, unsigned k) const {
        return U[index(i,j,k)];
    }

    float& operator()(unsigned i, unsigned j, unsigned k) {
        return U[index(i,j,k)];
    }
};

Array3D U(6,7,8);
U(1,2,3) = U(2,3,4) + U(2,3,2);

我个人认为U(i+1,j+1,k)比U[i+1][j+1][k]更具可读性和可写性。

您也可以使用boost::multi_array。

Answer 2

std::vector只不过是堆分配数组和数组大小的包装器。您可以使用可以使用堆分配的数组执行的向量执行大多数操作。

std::vector通常推荐使用原始c ++数组，原因有两个：

因为std::vector是类型安全的。原始数组忘记它们是数组并且很容易忘记它们的大小，这可能导致无效的内存访问。
因为std::vector管理堆分配数组的生命周期，而不是要求您手动使用new[]和delete[]，这很容易出错。

std::vector的一个缺点是它不像多维数组那样方便使用。

double U[M][N][4];
U[i][j][k];

您可以将多维数组展平为单个维度：

std::vector<double> U(M * N * 4);
U[N*4*i + 4*j + k]

另一种选择是编写自己的类型安全的资源管理类，它充当多维数组。

class _2d_array {
  std::vector<double> arr;
public:
  const int rows, columns;
  _2d_array(int rows, int columns) : arr(rows * columns), rows(rows), columns(columns) {}

  struct row_proxy {
    _2d_array &arr;
    int row;
    double &operator[] (int column) { return arr.arr[arr.columns*row + column]; }
  };

  row_proxy operator[] (int row) { return row_proxy{*this, row}; }
};

_2d_array U(M, N);
U[i][j] = 10.23;

Answer 3

... vectors已被推荐超过arrays，但我仍然没有完全理解，我不确定他们是否可以参与我的项目。

arrays是C ++ 11的一项功能。它们的大小也是固定的。

vectors随时可用。它们很动态，可以改变尺寸。

使用最适合您情况的方法。如果你需要C ++ 03，那么你必须使用vector。如果需要增长数组，请使用vector。

如何使用Vectors执行数组计算？

3 个答案: