c - 尝试在 C 中读取迷宫文本文件时出现 malloc 错误

Question

我试图让我的代码从内容涉及的文本文件中读取: (文本文件名为 maze1.txt)

5 5
%%%%%
S % %
% % %
%   E
%%%%%

但是，每当我尝试运行该程序时，我都会收到段错误，我认为这与我使用 malloc 的方式有关。我知道我已经使用第一个数字来设置数组的边界，但我不确定如何做到这一点。

provided is my code:

#include <stdio.h>
#include <stdlib.h>
#include "maze.h"
maze_t * createMaze(char * fileName)
{
    typedef struct Maze{
    int cols, rows;
    char **charRow;
    }MAZE;
    struct Maze maze;
    FILE *pf;
    int i,j,k;
    pf = fopen(fileName,"r");
    k = fscanf(pf, "%i %*c %i", &maze.cols, &maze.rows);
    char cMaze[maze.cols][maze.rows];
    int new;
    int *newMaze = (int *)malloc( maze.rows * maze.cols * sizeof(int));
    for(i = 0; maze.rows; i++){
        for(j = 0; j < maze.cols; j++){
            cMaze[i][j] = fgetc(pf);
            putchar( cMaze[i][j] ); 

        }       
    }
    printf("%d", cMaze[maze.cols][maze.rows]);
    printf("\n");
    maze.charRow = newMaze;
    fclose(pf);


    return newMaze;
}

这是我的主要内容:

#include <stdio.h>
#include "maze.h"


int main(int argc, char **argv)
{
    if (argc < 2)
    {
        printf("You need a valid input maze file.\n");
        return -1;
    }

    printf("Creating maze with file %s\n", argv[1]);
    maze_t * maze = createMaze(argv[1]);

    printf("\nUnsolved maze:\n");
    printMaze(maze);

    if(solveMazeManhattanDFS(maze, maze->startColumn, maze->startRow))
    {
        printf("\nSolved maze:\n");
        printMaze(maze);
        if(checkMaze(maze))
        {
            printf("Solution to maze is valid\n");
        }
        else
        {
            printf("Incorrect solution to maze\n");
        }
    }
    else
    {
        printf("\nMaze is unsolvable\n");
    }

    printf("\nDestroying maze\n");

    destroyMaze(maze);

    return 0;
}

struct maze_t 的定义是

typedef struct {
    int width;
    int height;
    int startColumn;
    int startRow;
    int endColumn;
    int endRow;
    char ** cells;
} maze_t;

Answer 1

你无法知道是否 createMaze成功或失败是因为您无法验证文件是否确实打开以供读取。当您保存返回fscanf时，您无法以任何方式验证实际发生了 2 次转换。

使用fscanf对于第一行来说很好，但要明白 '\n'留在 stdin在你下次阅读之前你必须考虑到这一点。 (您的下一个读取是 fgetc ——它会很乐意将 '\n' 作为文件中的下一个值并将其分配给 cMaze[0][0] 。

二维数组不等于 char ** 。如果您打算存储构成迷宫的线并通过 char **charRow; 引用它们，那么你需要分配maze.rows指向 char 的指针的数量，然后需要为每一行分配存储空间，并将该存储 block 的起始地址分配给每个 maze.charRow[x] 。 (对于面向行的输入，fgets是读取每一行的更好选择)

您分配给 newMaze ，但不分配任何值。

我不是为您修复现有代码，而是提供一个示例来正确验证您需要采取的每个步骤，将每一行存储在 maze.line[x] 中(您重命名为 charRow )，使用存储的值输出迷宫，然后在退出之前释放所有分配的内存(每行+指针)。每个单独的验证都在下面的注释中进行了描述，例如

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

#ifndef BUF_SIZ
#define BUF_SIZ 8192
#endif

typedef struct {
    int cols, rows;
    char **line;
} maze_t;

void *xcalloc (size_t nmemb, size_t sz);

int main (int argc, char **argv) {

    char buf[BUF_SIZ] = "";
    int n = 0;
    maze_t maze;
    FILE *fp = argc > 1 ? fopen (argv[1], "r") : stdin;

    if (!fp) {  /* validate file open for reading */
        fprintf (stderr, "error: file open failed '%s'.\n", argv[1]);
        return 1;
    }

    /* read maze.rows & maze.cols */
    if (fscanf (fp, "%d %d", &maze.rows, &maze.cols) != 2) {
        fprintf (stderr, "error: failed to read rows & cols.\n");
        return 1;
    }
    fgets (buf, BUF_SIZ, fp);   /* read discard any additional chars */

    /* allocate/validate maze.rows pointers */
    maze.line = xcalloc (maze.rows, sizeof *maze.line);

    /* read each remaining line up to maze.rows lines */
    while (n < maze.rows && fgets (buf, BUF_SIZ, fp)) {
        size_t len = strlen (buf);      /* get buf length */
        if (len && buf[len-1] == '\n')  /* validate last char is '\n' */
            buf[--len] = 0;             /* overwrite with nul-character */
        else {      /* line too long, handle error */
            fprintf (stderr, "error: line exceeds BUF_SIZ.\n");
            return 1;
        }
        if (len != (size_t)maze.cols) { /* validate maze.cols chars read */
            fprintf (stderr, "error: line exceeds maze.cols.\n");
            return 1;
        }

        /* allocate/validate maze.cols +1 chars */
        maze.line[n] = xcalloc (len + 1, sizeof *maze.line[n]);
        strcpy (maze.line[n++], buf);   /* copy buf to maze.line[n] */
    }

    if (fp != stdin) fclose (fp);   /* close file if not stdin */

    if (n != maze.rows) {   /* validate maze.rows lines read */
        fprintf (stderr, "error: less than maze.rows lines read.\n");
        return 1;
    }

    for (int i = 0; i < n; i++) {
        printf ("%s\n", maze.line[i]);  /* output each line */
        free (maze.line[i]);            /* free line */
    }
    free (maze.line);                   /* free pointers */

    return 0;
}

/** xcalloc allocates memory using calloc and validates the return.
 *  xcalloc allocates memory and reports an error if the value is
 *  null, returning a memory address only if the value is nonzero
 *  freeing the caller of validating within the body of code.
 */
void *xcalloc (size_t nmemb, size_t sz)
{
    register void *memptr = calloc (nmemb, sz);
    if (memptr == 0) {
        perror ("xcalloc() error: virtual memory exhausted.");
        exit (EXIT_FAILURE);
    }

    return memptr;
}

希望这将为您在代码中需要纠正的每个步骤提供一个有效示例。 (注意: xcalloc 函数只是为了方便起见，避免在代码正文中重复验证)

示例使用/输出

$ ./bin/maze <dat/maze.txt
%%%%%
S % %
% % %
%   E
%%%%%

内存使用/错误检查

在您编写的动态分配内存的任何代码中，对于分配的任何内存块，您都有 2 个责任:(1) 始终保留指向起始地址的指针内存块，因此，(2) 当不再需要它时可以释放。

对于 Linux valgrind是正常的选择。每个平台都有类似的内存检查器。它们使用起来都很简单，只需通过它运行您的程序即可。

$ valgrind ./bin/maze <dat/maze.txt
==18822== Memcheck, a memory error detector
==18822== Copyright (C) 2002-2015, and GNU GPL'd, by Julian Seward et al.
==18822== Using Valgrind-3.11.0 and LibVEX; rerun with -h for copyright info
==18822== Command: ./bin/maze
==18822==
%%%%%
S % %
% % %
%   E
%%%%%
==18822==
==18822== HEAP SUMMARY:
==18822==     in use at exit: 0 bytes in 0 blocks
==18822==   total heap usage: 6 allocs, 6 frees, 70 bytes allocated
==18822==
==18822== All heap blocks were freed -- no leaks are possible
==18822==
==18822== For counts of detected and suppressed errors, rerun with: -v
==18822== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)

始终确认您已释放分配的所有内存并且不存在内存错误。

仔细检查，努力将验证合并到您的代码中，如果您还有任何其他问题，请告诉我。