C编程:创建和编写二维数组文件作为函数

Question

我有一个很长的程序，我试图缩短它。我经常编写2d文件数组，但是我在整个程序中重复这个过程几十次，所以我试图将其作为函数来编写，以减少我的错误，并使代码更短，更易于阅读。

我正在修改一个例子，我从函数C中分配内存2d数组，但这样做是用FILE数组代替。

我已经可以在main中轻松地分配2D文件数组，但是，我想再一次将其作为函数来执行:

#include <stdio.h>
#include <stdlib.h>
void allocate_mem(FILE**** arr, const int n, const int m) {
    arr = malloc(n*m*sizeof(FILE));
    for(int i=0; i<n; i++) {
        arr[i] = malloc(m*sizeof(FILE));
        for (unsigned int j = 0; j < m; j++) {
            char filename[64];
            sprintf(filename,"tmp_%d_%d.txt",i,j);
            *arr[i][j] = fopen(filename,"w");
            fprintf(*arr[i][j],"blah %d %dn",i,j);
        }
    }
}
void deallocate_mem(FILE**** arr, const int n, const int m){
    for (int i = 0; i < n; i++) {
        for (unsigned int j = 0; j < m; j++) {
            fclose(*arr[i][j]);
        }
        free((*arr)[i]);
    }
    free(*arr); 
}
int main() {
    FILE ***array;
    allocate_mem(&array,5,3);
    deallocate_mem(&array,5,3);
    return 0;
}

我已经尝试了几乎所有可能的方法(至少对我来说)，但我总是在valgrind上犯这样的错误:

==16192== HEAP SUMMARY:
==16192==     in use at exit: 4,440 bytes in 3 blocks
==16192==   total heap usage: 3 allocs, 0 frees, 4,440 bytes allocated
==16192== 
==16192== Searching for pointers to 3 not-freed blocks
==16192== Checked 70,808 bytes
==16192== 
==16192== 552 bytes in 1 blocks are still reachable in loss record 1 of 3
==16192==    at 0x4C2BBA0: malloc (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==16192==    by 0x4EA711C: __fopen_internal (iofopen.c:69)
==16192==    by 0x40080C: allocate_mem (create_file_array.c:11)
==16192==    by 0x400951: main (create_file_array.c:29)
==16192== 
==16192== 648 bytes in 1 blocks are still reachable in loss record 2 of 3
==16192==    at 0x4C2BBA0: malloc (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==16192==    by 0x4007AC: allocate_mem (create_file_array.c:7)
==16192==    by 0x400951: main (create_file_array.c:29)
==16192== 
==16192== 3,240 bytes in 1 blocks are still reachable in loss record 3 of 3
==16192==    at 0x4C2BBA0: malloc (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==16192==    by 0x400761: allocate_mem (create_file_array.c:5)
==16192==    by 0x400951: main (create_file_array.c:29)
==16192== 
==16192== LEAK SUMMARY:
==16192==    definitely lost: 0 bytes in 0 blocks
==16192==    indirectly lost: 0 bytes in 0 blocks
==16192==      possibly lost: 0 bytes in 0 blocks
==16192==    still reachable: 4,440 bytes in 3 blocks
==16192==         suppressed: 0 bytes in 0 blocks
==16192== 
==16192== ERROR SUMMARY: 2 errors from 2 contexts (suppressed: 0 from 0)
==16192== 
==16192== 1 errors in context 1 of 2:
==16192== Invalid write of size 8
==16192==    at 0x40080D: allocate_mem (create_file_array.c:11)
==16192==    by 0x400951: main (create_file_array.c:29)
==16192==  Address 0x0 is not stack'd, malloc'd or (recently) free'd
==16192== 
==16192== 
==16192== 1 errors in context 2 of 2:
==16192== Use of uninitialised value of size 8
==16192==    at 0x40080D: allocate_mem (create_file_array.c:11)
==16192==    by 0x400951: main (create_file_array.c:29)
==16192==  Uninitialised value was created by a heap allocation
==16192==    at 0x4C2BBA0: malloc (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==16192==    by 0x4007AC: allocate_mem (create_file_array.c:7)
==16192==    by 0x400951: main (create_file_array.c:29)
==16192== 
==16192== ERROR SUMMARY: 2 errors from 2 contexts (suppressed: 0 from 0)
create_file_array.c

我怎么能得到allocate_mem和deallocate_mem的工作?

Answer 1

你应该忘记你曾经听说过三星或四星。与宾馆相比，C语言编程使用的是一种相反的系统:星级越多，代码质量越差。

你甚至不需要一个指针到指针到…你想要一个2D数组

话虽如此，请注意，这并不是那么微不足道，因为您想要拥有数组的类型是FILE*。大多数想成为资深程序员的人都会失败，并建议使用多个for循环和多个malloc调用来对可怜的无害堆发起全面攻击。

可以从main()开始。为了节省您的理智，您可能希望您的main看起来像这样:

int main (void) 
{
  file_arr_t* array;    // pointer to a 2D array
  array = allocate_mem(5,3);
  deallocate_mem(array);
  return 0;
}

在这种情况下，allocate_mem函数需要返回一个指向已分配数组的指针。声明数组指针的C语法非常糟糕，因此您需要创建一个类型定义来保存您的理智。对指针进行类型定义也是不好的做法，所以最好是对你想要指向的数组类型进行类型定义:

typedef FILE* file_arr_t[3][5];   // type is an array of 3x5 FILE*

其中file_arr_t*将是一个指向3x5 FILE指针数组的指针。唷。

那么你可以把你的函数写成:

file_arr_t* allocate_mem (size_t x, size_t y)
{
  file_arr_t* array = malloc(sizeof(FILE*[x][y]));
  (*array)[i][j] = ... // do things with the pointer to array
  return array;
}
void deallocate_mem(file_arr_t* array)
{
  free(array);
}

---

编辑

如果你真的需要维度在运行时是完全动态的，我担心你会遇到这样或那样的语法问题，因为你不能使用类型定义。你最终会得到这样一些不可读的东西:

// turning messy, avoid writing code like this.
void allocate_mem (size_t x, size_t y, FILE* (**arr_ptr)[x][y])
{
  *arr_ptr = malloc(sizeof(FILE*[x][y]));
  (**arr_ptr)[i][j] = something;
}
int main (void)
{
  FILE* (*array)[5][3];
  allocate_mem(5, 3, &array);
}

在这种情况下，我建议用void*代替:

void* allocate_mem (size_t x, size_t y)
{
  // omit inner-most dimension on purpose to get clearer access syntax later
  FILE* (*array)[y] = malloc(sizeof(FILE*[x][y]));
  // now this pointer can be used with intuitive syntax:
  array[i][j] = something;
  ...
  return array;
}
int main (void)
{
  FILE* (*array)[5][3];
  array = allocate_mem(5, 3);
}

Answer 2

第一个问题…

void allocate_mem(FILE**** arr, const int n, const int m) {
    arr = malloc(n*m*sizeof(FILE));      // probably not what you want!
    for(int i=0; i<n; i++) {
       arr[i] = malloc(m*sizeof(FILE));  //overwrites initial value of arr when i==0!

当i == 0时，arr = malloc(n*m*sizeof(FILE));返回的初始指针被覆盖，并且您泄漏(失去可见性)该内存。这个问题必须解决。

我最初的想法是……哇!你正在使用(FILE**** arr)一个指向指针的指针指向指针的指针。你真的需要简化这个