尝试在 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;
}

结构maze_t的定义是

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

Answer 1

我认为你的问题是这一行：

k = fscanf(pf, "%i %*c %i", &maze.cols, &maze.rows);

随着输入

5 5

您将不会 maze.rows 初始化。 %*c 将 "eat"（抑制）第二个 5。

试试这个来调试你的代码：

k = 0;
maze.cols = 0;
maze.rows = 0;
k = fscanf(pf, "%i %*c %i", &maze.cols, &maze.rows);
printf("%d %d %d\n", k, maze.cols, maze.rows);

并检查打印的值。我得到值：

1 5 0

所以 maze.rows 没有被 fscanf

分配

之后试试这个：

k = fscanf(pf, "%i %i", &maze.cols, &maze.rows);

Answer 2

您需要像下面这样正确阅读行号和列号。

k = fscanf(pf, "%d %d", &maze.cols, &maze.rows);

另外，你的for语句有一些错误。一定是这样的。

for (i = 0; i <= maze.rows; i++) {
    for (j = 0; j <= maze.cols; j++) {
        cMaze[i][j] = fgetc(pf);
        putchar(cMaze[i][j]);
    }
}

编辑：尝试我为您的 createMaze 编写的代码。有不懂的可以再问。

struct 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, "%d %d", &maze.cols, &maze.rows);
    int *newMaze = (int *)malloc(maze.rows * maze.cols * sizeof(int));
    for (i = 0; i <= maze.rows; i++) {
        for (j = 0; j <= maze.cols; j++) {
            newMaze[i+j] = fgetc(pf);
            putchar(newMaze[i+j]);
        }
    }
    printf("\n");
    fclose(pf);

    return newMaze;
}

Answer 3

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

第一行可以使用 fscanf，但请注意 '\n' 留在了 stdin 中，您必须在下次阅读之前考虑到这一点。（您的下一个读取是 fgetc——它会很乐意将 '\n' 作为文件中的下一个值并将其分配给 cMaze[0][0]。

二维数组不等同于char **。如果您计划存储构成迷宫的线并通过 char **charRow; 引用它们，那么您需要分配 maze.rows 个指向 char 的指针，然后您需要为每条线分配存储并分配该存储块的起始地址到每个 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 函数只是为了上面的方便，避免在代码主体中重复验证）

例子Use/Output

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

内存Use/Error检查

在您编写的任何动态分配内存的代码中，您对分配的任何内存块负有 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)

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

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

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

malloc error when trying to read a maze text file in C

c

malloc

maze

file

segmentation-fault