C 结构的动态数组

我对一段相当大的代码有问题。了解我自己，这是一种愚蠢的错误，或者更可能的是，缺乏对指针的理解。我真的需要一些帮助，所以如果有人能看到它，我会非常感激！我现在要解释一下

这是我编程课上的一个程序。老师在txt文件中给了我们一个数字（N）和一个字母（X），并希望我们创建一个包含三个字段（int、char和float）的结构，然后是四个函数：

函数#1将数字N作为参数，并为指向N个结构的指针数组动态分配内存。然后它为结构中的字段赋值-int和char被设置为随机值，float字段被设置为结构的编号。函数返回数组的地址

函数#2将所创建数组的大小（其中指针的数量）和指向该数组的指针作为参数，并删除该数组，从而释放内存

函数#3将所创建数组的大小和指向该数组的指针作为参数，然后使用冒泡排序根据int字段对结构进行排序

函数#4搜索结构并计算字母（X）在结构的字符字段中重复的次数

下面是带有注释和错误的代码。拜托，有人能解释一下我做错了什么吗？老实说，我几乎没时间了，但我愿意熬夜来理解和解决这个问题

 #include <stdio.h>
 #include <stdlib.h>
 #include <conio.h>
 #include <time.h>

 struct Foo {
 int fieldint;
 char fieldchar;
 float fieldfloat;
 };

 Foo *initialize(int N);
 int sort(int N, Foo *tablica);
 int count(int N, Foo *tablica, char*X);
 int deleting(int N, Foo **tablica);

 int main () {

      //this reads the number N and the letter to find from the .txt file:
      FILE *file = fopen("inlab01.txt", "r");
      int number;
      char letter[1];
      if (file == NULL) {
           printf("Error opening file");
           exit(-1);
      } 
      while (fscanf(file, "%d%s", &number, letter) != EOF);
      fclose(file);

      //creating the array
      //again, it's supposed to be an array of pointers to N structures:
      Foo *arr[number]; 
      *arr = initialize(number);

      //sorting:
      sort(number, *arr); //the program crashes at this function

      //counting how many times the given letter appears:
      //count(number, *arr, letter);

      //we're supposed to print the first 20 of the structures
      //this loop prints one structure and then the program crashes
      for(int i=0;i<20;i++) {
          printf("Structure %d:\nfield int:%d\nfield char:%c\nfield float:\f\n\n", i+1, arr[i]->fieldint, arr[i]->fieldchar, arr[i]->fieldfloat);
      }

      //deleting:
      deleting(number, arr);

      getch();
      return 0;
}

Foo *initialize(int N) { 
     Foo **array;
     array = (Foo **)malloc(sizeof(Foo) * N);
     srand( time( NULL ) );    

     for(int i=0; i<N; i++) {
          array[i] = (Foo*)malloc(sizeof(Foo));           
          array[i] -> fieldint = rand();  //random number
          array[i] -> fieldchar = ( char )( rand() % 24 ) + 65; //random letter
          array[i] -> fieldfloat=i;     
     }

     return *array; 
}

 int sort(int N, Foo *array) {  
     int temp;
     for (int i=0;i<N;i++){
         for (int j=N-1;j>=j;j--) {
             if(array[j].fieldint < array[j-1].fieldint) {
                 temp = array[j-1].fieldint;
                 array[j-1].fieldint = array[j].fieldint;
                 array[j].fieldint = temp;
             }
         }
     }
     return 0;
 }

 int count(int N, Foo *array, char*X){ 
     int counter = 0;
     for(int i=0;i<N;i++) {
         if (array[i].fieldchar == 'X') {
             counter = counter+1;
         }
     }
     return counter;
 }

 int deleting(int N, Foo **array) {
     for (int i=0;i<N;i++) {
         free(array[i]);
     }  
     free(array);
     return 0;
 }

#包括
#包括
#包括
#包括
结构Foo{
int-fieldint；
char字段char；
浮动字段浮动；
};
Foo*初始化（int N）；
整数排序（整数N，Foo*tablica）；
整数计数（整数N，Foo*tablica，char*X）；
int删除（int N，Foo**tablica）；
int main（）{
//这将从.txt文件中读取要查找的数字N和字母：
FILE*FILE=fopen（“inlab01.txt”，“r”）；
整数；
字符字母[1]；
if（file==NULL）{
printf（“打开文件时出错”）；
出口（-1）；
} 
while（fscanf（文件，“%d%s”&数字，字母）！=EOF）；
fclose（文件）；
//创建数组
//同样，它应该是指向N个结构的指针数组：
Foo*arr[数字]；
*arr=初始化（数字）；
//分类：
sort（number，*arr）；//程序在此函数处崩溃
//计算给定字母出现的次数：
//计数（数字，*arr，字母）；
//我们应该打印前20个结构
//这个循环打印一个结构，然后程序崩溃
for（int i=0；ifieldint，arr[i]>fieldchar，arr[i]>fieldfloat）；
}
//删除：
删除（编号，arr）；
getch（）；
返回0；
}
Foo*初始化（int N）{
Foo**数组；
数组=（Foo**）malloc（sizeof（Foo）*N）；
srand（时间（空））；
for（int i=0；i fieldint=rand（）；//随机数
数组[i]->fieldchar=（char）（rand（）%24）+65；//随机字母
数组[i]->fieldfloat=i；
}
返回*数组；
}
int排序（intn，Foo*数组）{
内部温度；
对于（int i=0；i=j；j--）{
if（数组[j].fieldint<数组[j-1].fieldint）{
temp=数组[j-1].fieldint；
数组[j-1].fieldint=array[j].fieldint；
数组[j].fieldint=temp；
}
}
}
返回0；
}
整数计数（整数N，Foo*数组，char*X）{
int计数器=0；
对于（int i=0；i
你在C++中编译这个代码。你想使用C编译器，你必须把代码改为：

struct Foo **array;

您可以在任何地方使用
struct Foo
，而不需要该强制转换。或者使用
typedef

其次，
Foo**array
用于分配二维数组。分配二维数组的方式是错误的。此外，您只需要一个一维数组
Foo arr[number]

for (int j=N-1;j>=j;j--)

注意：排序函数中出现错误
（j>=j）
始终为真。请修复排序函数，避免分配二维数组，这样就完成了

int sort(int N, struct Foo *array)
{
    int temp, i, j;
    for (i = 0; i< N; i++) {
        for (j = i + 1; j < N; j++) {
            if (array[i].fieldint > array[j].fieldint) {
                temp = array[i].fieldint;
                array[i].fieldint = array[j].fieldint;
                array[j].fieldint = temp;
            }
        }
    }
    return 0;
}

int main()
{
    srand((unsigned)time(NULL));
    int number = 3;
    struct Foo arr[number];
    int i;
    for (i = 0; i < number; i++) {
        arr[i].fieldint = rand(); //random number
        arr[i].fieldchar = 'A' + (char)(rand() % 26); //random letter
        arr[i].fieldfloat = (float)i;
    }

    sort(number, arr);
    for (i = 0; i < number; i++)
        printf("Structure %d:\nfield int:%d\nfield char:%c\nfield float:%f\n\n",
            i + 1, arr[i].fieldint, arr[i].fieldchar, arr[i].fieldfloat);
    getch();
    return 0;
}

int排序（int N，结构Foo*数组）
{
内部温度，i，j；
对于（i=0；iarray[j].fieldint）{
temp=array[i].fieldint；
数组[i].fieldint=array[j].fieldint；
数组[j].fieldint=temp；
}
}
}
返回0；
}
int main（）
{
srand（（无符号）时间（NULL））；
整数=3；
结构Foo arr[编号]；
int i；
对于（i=0；i

太长了，读不下去了，你可以选择一个最小的、完整的、可验证的例子来展示你所面临的错误。你现在的问题是TL；DR材料，大多数人都不会打扰你。代码未编译，例如
*arr=initialize
错误，
arr[i]-> Fieldt是错误的，你应该修复这些。顺便说一下，你好像在C++中编译C代码，也许你在使用*.CPP扩展。@ BarmakShemirani为什么出错了？我试着做*ARR=初始化，以便能够在其他函数中使用创建的数组。我应该如何做呢？谢谢你这么多的回答，尽管很糟糕。很长的代码！谢谢！我改为.c扩展名，现在正在使用“struct Foo”。如果我改为arr=initialize，我会收到一个错误，上面写着“分配中的不兼容类型”
int sort(int N, struct Foo *array)
{
    int temp, i, j;
    for (i = 0; i< N; i++) {
        for (j = i + 1; j < N; j++) {
            if (array[i].fieldint > array[j].fieldint) {
                temp = array[i].fieldint;
                array[i].fieldint = array[j].fieldint;
                array[j].fieldint = temp;
            }
        }
    }
    return 0;
}

int main()
{
    srand((unsigned)time(NULL));
    int number = 3;
    struct Foo arr[number];
    int i;
    for (i = 0; i < number; i++) {
        arr[i].fieldint = rand(); //random number
        arr[i].fieldchar = 'A' + (char)(rand() % 26); //random letter
        arr[i].fieldfloat = (float)i;
    }

    sort(number, arr);
    for (i = 0; i < number; i++)
        printf("Structure %d:\nfield int:%d\nfield char:%c\nfield float:%f\n\n",
            i + 1, arr[i].fieldint, arr[i].fieldchar, arr[i].fieldfloat);
    getch();
    return 0;
}