Question

编辑：没有Willis指出的递归

任务是首先将一个3维数组传递给一个函数，该函数调用另一个传递给同一数组但传递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;
}

最终它应该像这样在2个直方图中显示分布

./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

程序的一个可能问题是，一路走来，您从引用传递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的功能，但它们是不同的功能。当一个函数直接或间接调用自身而不是另一个具有相同名称的函数时，就会发生递归。如果您的任务是使用递归函数生成此直方图，则此处尚未完成。

Answer 2

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

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

您可以将数组的子部分传递给函数吗？ C ++

2 个答案: