当维度大小不明确时，将多维数组传递给函数

Question

我的班级中有一个函数应该得到一个多维数组。问题是这些维度的值是在类中计算的，使用另一个函数并存储在一些公共变量中。因此类中的所有其他函数都可以读取存储在这些变量中的值。 函数的定义是这样的：

double calcSS(double tfpairexp[][max_ctrl_no][max_rep_no])

其中max_ctrl_no 和max_rep_no 是那些public 变量。 我这样调用函数：

calcSS(tfpairexp);

但是编译器对函数的定义给出了错误。如果我输入一些常数而不是那些变量，则没有错误。但是我不知道程序开始时的维度。 我该怎么办？

更新

void tripleofgenes(int begind,int endind) {             
            for (int tf1=0; tf1<tfact; ++tf1)
            {   
                    for (int tf2=tf1+1; tf2<tfact; ++tf2)
                    { 
                        double tfpairexp[cchips][max_ctrl_no][max_rep_no];
                        double w,d;
                        int ctrl_no;int c, ctr;
                        for (int j = 0; j < cchips ; j += c)
                        {
                            c = chips[j].crepls;
                            int ctrl_no=0;
                            for (int *p = chips[j].ctrl ; p && (ctr=*p)>=0; ++p,ctrl_no++) {
                                for (int k = 0; k < c; ++k)
                                {
                                    double tf1exp=chips[k+j].vals[tf1].val-((chips[k+j].useextra) ? chips[ctr].extra[tf1] : chips[ctr].mean[tf1].val);
                                    double tf2exp=chips[k+j].vals[tf2].val-((chips[k+j].useextra) ? chips[ctr].extra[tf2] : chips[ctr].mean[tf2].val);
                                    tfpairexp[j][ctrl_no][k]=interactionFunc(tf1exp,tf2exp,1);
                                }
                            }
                        }
                        for (int tg=begind; tg<=endind; ++tg) 
                            if (tf1!=tg){

                        calcSS(tfpairexp);

                        }


                    }
            }
        fclose(f);
    }

    double calcSS(double ***tfpairexp)
    {
    for (int row = 0; row <= 1 ; row++)
                for (int col = 0; col <= 1 ; col++) {
                    int cond=0;
                    for (int j = 0; j < cchips; j += c) {
                        c = chips[j].crepls; // the number of replicants
                        int ctrl_no=0;
                        for (int *p = chips[j].ctrl; p && (ctr=*p)>=0; ++p,ctrl_no++) {
    a = tfpairexp[j][ctrl_no][k];}
    }
    }
    }
    }

Answer 1

您在此处使用的数组类型（C 风格）并非真正设计用于动态大小，尽管您可以使用new 以这种方式分配它们。函数调用的一种解决方案是使用double *** 和三个size_t 参数作为维度传递给函数，但这仍然需要您在调用者中声明数组，其维度与您所需要的一样大。否则您将损坏进程内存并可能崩溃。

更好的解决方案是使用vector，它从一开始就设计用于处理具有运行时确定大小的数组。您可以声明一个多维向量并直接使用它，也可以选择一个单维向量并在访问时进行一些数学运算，将坐标的三元组转换为向量的索引。

无论哪种方式，您都需要矢量标头，这是我推荐的设置方式：

#include <vector> // in your includes

using std::vector; // at global scope immediately after all #includes

一些代码示例。我将根据另一个答案使用cchips 作为第三维的大小。多维解决方案如下所示：

// at global scope
typedef vector< vector<double> > vec2double;
typedef vector< vector<vec2double> > vec3double;

// in the caller of your calcSS after you know how big to make the array {
    vec3double tfairexp(cchips, vec2double(max_ctrl_no, vector<double>(max_rep_no)));
    // now fill up tfairexp
    calcSS(tfairexp);
// }

// important: pass a reference here, or you will copy the whole array at call time!
void calcSS(vec3double &tfairexp) {
    // you can use cchips etc here but don't have to:
    for (size_t i = 0; i < tfairexp.size(); i++) {
        for (size_t j = 0; j < tfairexp[0].size(); j++) {
            for (size_t k = 0; k < tfairexp[0][0].size(); k++) {
                // access tfairexp[i][j][k] here
            }
        }
    }
}

该解决方案实际上将执行1+j+j*k 动态数组分配。您可以改为编写一个“拥有”向量并执行维度转换的包装类，并让您当前正在编写的类使用它。我正在做出一些风格上的牺牲，以继续使用您的“用于尺寸大小的公共类成员变量”方法。然而，这更接近于模拟编译器如何转换 C 风格的多维数组，并且每次运行只分配一次内存：

// as a member of your class -- returns a live reference that can be assigned to!
double &vec3_get(vector<double> &array, const size_t i, const size_t j, const size_t k) {
    return array[i*max_ctrl_no*max_rep_no + j*max_rep_no +k];
}

// in caller of calcSS {
    vector<double> tfairexp(cchips*max_ctrl_no*max_rep_no);
    // fill in by doing vec3_get(tfairexp, i, j, k) = val;
    calcSS(tfairexp)
// }

// again, pass a reference to the vector!
void calcSS(vector<double> &tfairexp) {
    for (size_t i = 0; i < cchips; i++) {
        for (size_t j = 0; j < max_ctrl_no; j++) {
            for (size_t k = 0; k < max_rep_no; k++) {
                // access vec3_get(tfairexp, i, j, k) here
            }
        }
    }
}

Answer 2

double calcSS(double tfpairexp[][max_ctrl_no][max_rep_no])

一种解决方案是将函数签名更改为，

double calcSS(double ***tfpairexp, int M, int N, int P);

其中M、N 和P 是阵列的尺寸！

或者你可以传递你的类本身的实例。毕竟，您已经在课堂上公开了维度。如果这个函数是类的成员函数，那么你甚至不需要传递任何东西；您可以像这样从函数本身访问它们：

double calcSS(double ***tfpairexp)
{

      for(int i = 0 ; i < cchips ; i++ )
      {
           for(int j = 0 ; j < max_ctrl_no ; j++ )
          {
                for(int k = 0 ; k < max_rep_no ; k++ )
                {
                       //access elements as tfpairexp[i][j][k]
                }
          }
      }

}

---

如果它解决了你的问题，你可以看到这个答案：using a function template