标准差/均值的C程序 #包括 #包括 #包括 #包括 #定义最大值100 无效计算（浮点**，整数，浮点*，浮点*）； int main（int argc，char*argv[]） { 浮点*数组[MAX]； 浮动*平均值； 浮动*SD； int数组_大小，i； 数组_size=argc； 对于（i=0；i

该代码用于确定用户输入的多个浮动的平均值和标准偏差。当我试图编译它时，我总是遇到一个分段错误。我试着释放malloc，但是它给代码带来了更多的问题，所以我还是保持原样——尽管这可能是内存分配的问题

---

谢谢您

您错误地分配和访问了

数组

。应该是这样的：

#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#include<string.h>

#define MAX 100

void calc(float**, int, float*, float*);

int main( int argc, char* argv[] )
{
  float *array[MAX];
  float *MEAN;
    float *SD;
    int array_size, i;

    array_size = argc;

    for( i = 0; i < argc ; ++i )
        {
      *array = (float *) malloc( argc*(sizeof(float)));
           *array[i] = atof(argv[i]);
        }

    calc(array, array_size, MEAN, SD);
    return 0;
}

void calc(float* arr[] , int arr_size, float* mean, float* stdev)
{
  int sum, i;

    for ( i = 0; i < arr_size ; ++i )
        {
            sum += *arr[i];
        }

    *mean = sum / arr_size;

    printf("%.2f", *mean);

       for ( i = 0; i < arr_size ; ++i )
        {
      sum += pow((*arr[i]-*mean), 2);
        }

    *stdev = sqrt((sum/arr_size));

    printf("%.2f", *stdev);

}

（i=0；i { 数组=malloc（argc*sizeof（*数组））； 数组[i]=atof（argv[i]）； }

---

同样在

calc（）

函数中，将

*arr[i]

更改为

arr[i]

。

这绝对是错误的：

for( i = 0; i < argc ; ++i )
{
    array = malloc( argc * sizeof(*array));
    array[i] = atof(argv[i]);
}

声明数组后，将分配一个浮点数组。这是没有道理的。然后，您将错误地取消对值的引用。此外，在代码中，您试图将程序名（

argv[0]

）转换为int类型

这可能是您想要做的：

*array = (float *) malloc( argc*(sizeof(float)));

float*array=NULL；
数组=malloc（（argc-1）*（sizeof（float））；
对于（i=1；i有几个问题：


float*array[MAX]；
是指向浮点数组的指针。您应该
使用浮点数数组或指针
malloc
，您可以使用如下指针：
float*array；
不要为每个浮点调用malloc，而是为整个数组调用一次
如果将
MEAN
和
SD
定义为指针，则必须使用
malloc
。最好将它们声明为仅浮动并使用
他们的地址（通过
&MEAN
和
&SD
）
sum
变量应该是一个
float
，并且应该初始化它
到
0
。在计算
stdev
之前，还应将其设置为
0
请记住，
argv[0]
包含程序名，因此
你应该忽略它
另外，请记住，使用
malloc
当你完成它的时候

代码的修改版本：

float * array = NULL;  

array = malloc( (argc-1)*(sizeof(float))); 

for (i=1; i<argc; ++i)
    array[i]=atof(argv[i]); 

#包括
#包括
#包括
#包括
无效计算（浮点*、整数、浮点*、浮点*）；
int main（int argc，char*argv[]）{
浮点*数组；
浮动平均值；
浮动SD；
int数组_大小，i；
数组_size=argc-1；
数组=（float*）malloc（数组大小*sizeof（float））；
对于（i=0；i
您有几个问题


检查您是否至少有一个参数
您将数组声明为浮点指针数组，可以使用
array[]
或
*array
您的阵列只需分配一次
在循环之前分配一次
样本数*sizeof（float）
数组
将读取的值存储到
数组[ndx]
位置（atof可以）
argv从程序名开始，将从
argv[n+1]
MEAN和SD需要空间，您声明了指针、更改为值和传递地址（&）

这是修改后的main（）

在运行时

cc stddev.c -lm -o stddev

此外，您还需要释放malloc'ed（array）的内存。这是一个好习惯，但对于这个小程序来说并不需要。
如果您在尝试编译时遇到分段错误，则编译器已损坏。为什么有
float*array[MAX]；
？float array[MAX]有什么问题

？数组是浮点指针数组吗？你需要使用更少的指针变量和更多的变量地址。声明

float SD；

，例如，和

calc（数组，数组大小，&MEAN，&SD）；

@Oswald我见过gdb和valgrind segfault，但如果有人用gcc来segfault，我会印象深刻。

float*Array[MAX]；

不是“指向浮点数组的指针”。指向浮点数组的指针是

float（*array）[MAX]；

并且它被很好地分配为

malloc（sizeof（float[MAX]））

…在类型声明中使用VLA。因此cl.exe不能这样做。clang或gcc可以。

int main( int argc, char* argv[] )
{
    //float array[MAX];
    float *array;
    float MEAN;
    float SD;
    int array_size, ndx;

    if(!(argc>0)) { printf("please give 1 or more arguments\n"); exit(1); }

    array_size = argc-1; //don't count the program name
    array = (float*) malloc(array_size*(sizeof(float)));
    for( ndx = 1; ndx<argc ; ++ndx )
    {
        array[ndx-1] = atof(argv[ndx]);
        printf("[%d] %f\n",ndx-1,array[ndx-1]);
    }

    calc(array, array_size, &MEAN, &SD);
    free(array); array=NULL; //always clean up after yourself
    return 0;
}

void calc(float arr[] , int arr_size, float* _mean, float* _stdev)
{
    double sum, mean, stddev;
    int i;

    sum=0.0;
    for ( i = 0; i < arr_size ; ++i )
    {
        sum += arr[i];
        //printf("[%d] %f\n",i,arr[i]);
    }
    printf("sum %f\n",sum);
    *_mean = mean = sum / arr_size;
    printf("mean %f\n",mean);
    printf("%.2f\n", *_mean);

    sum=0.0;
    for ( i = 0; i < arr_size ; ++i )
    {
        sum += pow((arr[i]-mean), 2);
        //printf("[%d] %f\n",i,arr[i]);
    }
    printf("sum^2 %f\n",sum);
    *_stdev = stddev = sqrt((sum/arr_size));
    printf("stddev %f\n",stddev);
    printf("%.2f\n", *_stdev);
}

cc stddev.c -lm -o stddev

$ ./stddev 1 2 3 4 5
[0] 1.000000
[1] 2.000000
[2] 3.000000
[3] 4.000000
[4] 5.000000
sum 15.000000
mean 3.000000
3.00
sum^2 10.000000
stddev 1.414214
1.41