1

我正在尝试学习如何在 C++ 中做事，而我正在努力解决的问题之一是如何有效地实现动态分配的多维数组。

例如，假设我有一个现有功能：

void myfunc(int *lambda, int *D, int *tau, int r[*tau][*D])
{
  int i, j, k, newj, leftovers;

  r[0][0] = *lambda;
  j = 0; // j indexes the columns; start with zero
  for(i = 1; i < *tau; i++){ // i indexes the rows
    leftovers = *lambda;
    for(k = 0; k < j; k++){
      r[i][k] = r[i - 1][k]; // copy prior to j
      leftovers = leftovers - r[i][k];
    }
    r[i][j] = r[i - 1][j] - 1; // decrement
    r[i][j+1] = leftovers - r[i][j]; // initialize to the right of j

    if(j == *D - 2){ // second to last column
      for(k = 0; k <= j; k++){ if(r[i][k] != 0){ newj = k; } }
      j = newj; // can't think of a better way to do this
    }else{
      j++; // increment j
    }
  } // next row please

}

根据我的阅读，似乎一个常见的建议是为此目的使用 std::vector 。有人愿意就如何使用等效的 std::vector 实现上面的 r 矩阵提供一些建议或代码片段吗？

我原以为这是一个相当普遍的情况，但有趣的是，谷歌为“C99 转换为 C++”的点击次数不到 50 次。

谢谢！
本

4

3 回答 3

2

我认为这将是最直接的转换：

void myfunc(int *lambda, std::vector<std::vector<int> > &r)
{
  int i, j, k, newj, leftovers;
  int tau = r.size();

  r[0][0] = *lambda;
  j = 0; // j indexes the columns; start with zero
  for(i = 1; i < tau; i++){ // i indexes the rows
    int D = r[i].size();
    leftovers = *lambda;
    for(k = 0; k < j; k++){
      r[i][k] = r[i - 1][k]; // copy prior to j
      leftovers = leftovers - r[i][k];
    }
    r[i][j] = r[i - 1][j] - 1; // decrement
    r[i][j+1] = leftovers - r[i][j]; // initialize to the right of j

    if(j == D - 2){ // second to last column
      for(k = 0; k <= j; k++){ if(r[i][k] != 0){ newj = k; } }
      j = newj; // can't think of a better way to do this
    }else{
      j++; // increment j
    }
  } // next row please
}
于 2013-05-19T04:31:45.477 回答
0

你有很多选择。

快速变化：

void myfunc(const int& lambda, const size_t& D, const size_t& tau, int* const* const r) {
  ...

使用 a vector（在编译时不会强制匹配大小）：

void myfunc(const int& lambda, std::vector<std::vector<int>>& r) {
    const size_t tau(r.size()); // no need to pass
    const size_t D(r.front().size()); // no need to pass
    ...

或std::array用于静态尺寸：

enum { tau = 5, D = 5 };
void myfunc(const int& lambda, std::array<std::array<int,D>,tau>& r) {
  ...

或者使用固定尺寸的模板参数：

template < size_t tau, size_t D >
void myfunc(const int& lambda, std::array<std::array<int,D>,tau>& r) {
  ...

要不就：

template < size_t tau, size_t D >
void myfunc(const int& lambda, int r[D][tau]) {
  ...

请注意，您还可以在 C++ 中根据需要组合静态和动态大小的数组。

最后，Multi Arrays 可以帮助您： http: //www.boost.org/doc/libs/1_53_0/libs/multi_array/doc/user.html

于 2013-05-19T06:35:58.260 回答
-1

我会将所有 r[x][y] 更改为 R(x,y) 并使用

int * r;
#define R(x,y) r[ (x) * (*D) + (y) ]

或者也许将 *D 更改为 *tau，我永远无法保持直截了当。

于 2013-05-19T03:13:00.207 回答