你能把数组的子部分传递给函数吗？C++

Question

编辑:威利斯指出的没有回溯

任务是首先将一个3-dim数组传递给一个函数，该函数调用另一个传递相同数组的数组，但调用该数组的2个维度，然后只传递一个维度，以计算最小和最大值。

#include <iostream>
#include <fstream>
#include <random>
#include <cmath>

using namespace std;

double Mean, StdDev;
const int n1(2), n2(200), n3(50);

default_random_engine generator(random_device{}());
normal_distribution<double> NormalD(Mean, StdDev);
uniform_real_distribution<double> UniD(Mean-5*StdDev, Mean+5*StdDev);

void fill(double v[][n2][n3]) {
  int i=0;
  while(i==0){
    for(int j=0; j<n2; j++){
      for(int k=0; k<n3; k++){
        double Random_Number = NormalD(generator);
        v[i][j][k] = Random_Number;
      }
    }
    i++;
  }
  if(i==1){
    for(int j=0; j<n2; j++){
      for(int k=0; k<n3; k++){
        double Random_Number = UniD(generator);
        v[i][j][k] = Random_Number;
      }
    }
  }
}

void cnt_hist(double v[n3],double min_v,double max_v,double hist[20]) {
  for(int i=0; i<n3; i++){
    if(v[i]>max_v)max_v=v[i];
    if(v[i]<min_v)min_v=v[i];
  }
  double higherEnd = Mean+5*StdDev;
  double lowerEnd = Mean-5*StdDev; 
  double step = (fabs(higherEnd-lowerEnd))/20;
  double g0 = lowerEnd;
  for(int i=0; i<20; i++){
    double g1 = g0 + step;
    for(int j=0;j<n3; j++){
      if(v[j]>=g0 && v[j]<g1){
        hist[i]++;
      }
    }
    g0 = g1;
  }
  for(int i=0; i<20; i++){
    hist[i]/=100;
  }
}

void cnt_hist(double v[][n3], double min_v, double max_v, double hist[20]) {
  for (int i=0; i<n2; i++) {
    cnt_hist(v[i], min_v, max_v, hist);
  }
}

void cnt_hist(double v[][n2][n3], double min_v[n1], double max_v[n1], double hist[][20]) {
  for (int i=0; i<n1; i++) {
    cnt_hist(v[i], min_v[i], max_v[i], hist[i]);
  }
}

void print_hist(double min_v[n1], double max_v[n1], double hist[][20]){
  for(int i=0; i<n1; i++){
    cout << "Minimum: " << min_v[i] << endl;
    cout << "Maximum: " << max_v[i] << endl;
    int k = -10;
    for(int j=0; j<20; j++){
      double s = 0;
      cout << k << " - " << k+1 << " :";
      while(s<hist[i][j]){
        cout << "*";
        s++;
      }
      cout << endl;
      k++;
    }
  }
}

int main(int c, char* s[]){
  Mean = stod(s[1]);
  StdDev = stod(s[2]);
  double v[n1][n2][n3];
  double min[n1], max[n1], hist[n1][20];
  fill(v);
  cnt_hist(v,min,max,hist);
  print_hist(min,max,hist);
  return 0;
}

最后，它应该在两个直方图中显示分布，如下所示

./a.out 0 2
Minimum: -7.51451
Maximum: 7.09445
-10 - -9 :
-9 - -8 :
-8 - -7 :
-7 - -6 :
-6 - -5 :
-5 - -4 : *
-4 - -3 : ****
-3 - -2 : *********
-2 - -1 : **************
-1 - 0 : *******************
0 - 1 : ******************
1 - 2 : ***************
2 - 3 : *********
3 - 4 : ****
4 - 5 : *
5 - 6 :
6 - 7 :
7 - 8 :
8 - 9 :
9 - 10 :
Minimum: -9.9992
Maximum: 9.99874
-10 - -9 : ****
-9 - -8 : *****
-8 - -7 : *****
-7 - -6 : *****
-6 - -5 : ****
-5 - -4 : *****
-4 - -3 : *****
-3 - -2 : *****
-2 - -1 : ****
-1 - 0 : *****
0 - 1 : ****
1 - 2 : ****
2 - 3 : ****
3 - 4 : ****
4 - 5 : *****
5 - 6 : ****
6 - 7 : ****
7 - 8 : *****
8 - 9 : *****
9 - 10 : ****

我怀疑数组是否确实被正确传递。谢谢你的建议。

Answer 1

使用数组(必须传递大小，因为类型在函数调用时从数组衰减到指针)。

// requires C++14
template <class T>
void process(T *arr, int size, double &min, double &max) {
    if constexpr (std::is_array<T>::value)
        for (int i = 0; i < size; ++i)
            process(arr[i], sizeof(*arr)/sizeof(**arr), min, max);
    else
        for (int i = 0; i < size; ++i) {
            max = std::max(max, arr[i]);
            min = std::min(min, arr[i]);
        }
}

Answer 2

您的程序的一个可能问题是，在此过程中，您将从通过引用传递min_v和max_v转移到通过值传递它们。

考虑第一个出现在代码中的cnt_hist，该代码如下所示：

void cnt_hist(double v[n3],double min_v,double max_v,double hist[20])

在函数中，您可以同时更新min_v和max_v。但是这些值只是局部的双倍，一旦函数退出，更新就会丢失。

您应该以引用的方式传递它们：

void cnt_hist(double v[n3],double &min_v,double &max_v,double hist[20])

声明为数组的参数很好，因为数组总是作为指针传递。

您对i函数中的变量fill的处理是.不寻常。while和if都将执行一次；拥有变量i有什么意义呢？

我还应该指出，这个程序中没有递归函数调用。虽然有三个叫做cnt_hist的函数，但它们是不同的函数。递归发生在函数直接或间接调用自身时，而不是使用相同名称的另一个函数时。如果您的任务是使用递归函数生成这个直方图，那么您还没有在这里完成它。