C Valgrind:大小为8的读/写无效

我是一个初学C的学生，试图写一个目录树。没问题，但Valgrind不同意。我读过关于类似问题的帖子，但似乎无法理解

我会非常感谢你的回答，不仅是一个片段，让它工作，而且还解释了我做错了什么，这样我就不会有同样的问题在未来。关于代码总体上不好的原因的反馈也不会被忽视：）

这些是Valgrind的错误（乘以处理的项目数量）：

她的代码（除去堆栈代码）：

#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#定义最大路径长度500
#定义最大项目长度5000
#定义最大项目数量1000
typedef-struct-dirent；
typedef结构文件{
字符*名称；
时间；
}档案;；
类型定义结构项{
int文件；
文件[sizeof（char*）*MAX\u ITEM\u CNT]；
int-dircnt；
char*dirs[sizeof（char*）*MAX_ITEM_CNT]；
}项目；
typedef stack_node_s*stack_s；
void stack_init（stack_s*stack）{
*stack=NULL；
}
/*将项推送到参数堆栈指向的堆栈。如果成功，则返回0，
*-1否则。
*/
int stack_push（void*p，stack_s*stack）{
stack_node_s*newitem=malloc（sizeof（stack_node_s））；
如果（！newitem）返回-1；
newitem->value=p；
新建项->下一步=*堆栈；
*stack=newitem；
返回0；
}
/*从参数堆栈指向的堆栈中弹出项。返回指向的指针
*如果成功，则从堆栈中删除元素；如果出现错误或错误，则为null
*堆栈是空的。
*/
void*stack\u pop（stack\u s*stack）{
如果（！*堆栈）返回NULL；
stack_node_s*freethis=*stack；
void*returnp=freethis->value；
*堆栈=（*堆栈）->下一步；
免费的（免费的）；
返回returnp；
}
int isDir（字符*目录名）{
结构统计stbuf；
统计数据（目录名和stbuf）；
返回S_ISDIR（stbuf.st_模式）；
}
时间（char*dirname）{
结构统计stbuf；
统计数据（目录名和stbuf）；
返回stbuf.st_mtime；
}
void checkDir（字符*路径、堆栈**堆栈、项目*列表）{
DIR*流；
字符完整路径[最大路径长度]；
如果（！（流=opendir（路径）））{
返回；
}
结构方向*dir；
而（（dir=readdir（stream）））{
strcpy（完整路径，路径）；
strcat（完整路径“/”；
if（strcmp（dir->d_name，“.”）和strcmp（dir->d_name，“…”））{
char*savedpath=（char*）malloc（sizeof（char）*最大项目长度）；
strcat（完整路径，dir->d_名称）；
strcpy（保存路径、完整路径）；
if（isDir（savedpath））{
列表->目录[（列表->目录）+]=保存路径；
堆栈推送（保存路径、堆栈）；
}
否则{
file_n*new=（file_n*）malloc（sizeof（file_n*））；
列表->文件[（列表->文件）]=新建；
（list->files[（list->filecnt）]）->name=savedpath；
（list->files[（list->filecnt）]）->mtime=mtime（savedpath）；
（列表->文件管理）+；
}
}
}
closedir（stream）；
字符*弹出；
而（popped=（char*）stack_pop（stack））{
checkDir（弹出、堆栈、列表）；
}
}
int qsortcbdir（常数无效*a，常数无效*b）{
常量字符**ia=（常量字符**）a；
常量字符**ib=（常量字符**）b；
返回strcmp（*ia，*ib）；
}
int qsortcbfile（常量无效*a，常量无效*b）{
常量文件**ia=（常量文件**）a；
常量文件**ib=（常量文件**）b；
int timea=（int）（**ia）.mtime；
inttimeb=（int）（**ib）.mtime；
if（timea==timeb）
返回strcmp（（**ia.name，（**ib.name）；
返回timea-timeb；
}
int main（int argc，char*argv[]）{
如果（argc！=2）{
printf（“参数数量不正确，正在退出。\n”）；
返回-1；
}
堆栈的堆栈；
堆栈初始化（&stack）；
项目列表=（项目*）malloc（项目大小）；
list->dircnt=（list->filecnt=0）；
memset（list->dirs，0，sizeof（char*）*MAX\u ITEM\u CNT）；
memset（list->files，0，sizeof（char*）*MAX\u ITEM\u CNT）；
checkDir（argv[1]，&堆栈，列表）；
qsort（list->dirs，list->dircnt，sizeof（char*），&qsortcdir）；
对于（int i=0；idircnt；i++）{
printf（“%s\n”，list->dirs[i]）；
自由（列表->目录[i]）；
}
printf（“--\n”）；
qsort（list->files，list->filecnt，sizeof（file_n*），&qsortcbfile）；
对于（int i=0；ifilecnt；i++）{
printf（“路径：%s，时间：%s”，（列表->文件[i]）->名称，ctime（&（（列表->文件[i]）->时间））；
自由（（列表->文件[i]）->名称）；
免费（列表->文件[i]）；
}
免费（名单）；
返回退出成功；
}

您只为指向

文件的指针分配了足够的空间。\n

：

file_n *new = (file_n*) malloc(sizeof(file_n*));

正确的方法是这样做（不需要演员阵容）：

---

或者，

file\n*new=malloc（sizeof*new）
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <dirent.h>

#define MAX_PATH_LENGTH 500
#define MAX_ITEM_LENGTH 5000
#define MAX_ITEM_CNT 1000

typedef struct dirent dirent;
typedef struct file_s {
  char *name;
  time_t mtime;
} file_n;
typedef struct itemss {
  int filecnt;
  file_n *files[sizeof(char*)*MAX_ITEM_CNT];
  int dircnt;
  char *dirs[sizeof(char*)*MAX_ITEM_CNT];              
} items;
typedef stack_node_s* stack_s;

void stack_init(stack_s *stack){
    *stack = NULL;
}

/* Pushes item to a stack pointed by parameter stack. Returns 0 if succesful,
 * -1 otherwise.
 */
int stack_push(void *p, stack_s *stack){
    stack_node_s *newitem = malloc(sizeof(stack_node_s));
    if (!newitem) return -1;
    newitem->value = p;
    newitem->next = *stack;
    *stack = newitem;
    return 0;
}

/* Pops item from a stack pointed by parameter stack. Returns pointer to
 * element removed from stack if succesful, null if there is an error or
 * the stack is empty.
 */
void *stack_pop(stack_s *stack){
    if(!*stack) return NULL;
    stack_node_s *freethis = *stack; 
    void *returnp = freethis->value;
    *stack = (*stack)->next;
    free(freethis);
    return returnp;
}

int isDir(char *dirname){
  struct stat stbuf;
  stat(dirname, &stbuf);
  return S_ISDIR(stbuf.st_mode);
}

time_t mtime(char *dirname){
  struct stat stbuf;
  stat(dirname, &stbuf);
  return stbuf.st_mtime;
}

void checkDir(char* path, stack_s **stack, items *list ){
  DIR *stream;
  char fullpath[MAX_PATH_LENGTH];

  if(!(stream = opendir(path))){
    return;
  }
  struct dirent *dir;
  while((dir = readdir(stream))){
    strcpy(fullpath, path);
    strcat(fullpath, "/");
    if(strcmp(dir->d_name, ".") && strcmp(dir->d_name, "..")){
      char *savedpath = (char*) malloc(sizeof(char)*MAX_ITEM_LENGTH);
      strcat(fullpath, dir->d_name);
      strcpy(savedpath,fullpath);
      if(isDir(savedpath)){
    list->dirs[(list->dircnt)++] = savedpath;
    stack_push(savedpath,stack);
      }
      else{
    file_n *new = (file_n*) malloc(sizeof(file_n*));
    list->files[(list->filecnt)] = new;
    (list->files[(list->filecnt)])->name = savedpath;
    (list->files[(list->filecnt)])->mtime = mtime(savedpath);
    (list->filecnt)++;
      }
    }
  }
  closedir(stream);
  char *popped;
  while(popped = (char*)stack_pop(stack)){ 
    checkDir(popped,stack,list);
  }
}

int qsortcbdir(const void* a, const void* b){
    const char **ia = (const char **)a;
    const char **ib = (const char **)b;
    return strcmp(*ia, *ib);
}

int qsortcbfile(const void* a, const void* b){
    const file_n **ia = (const file_n **)a;
    const file_n **ib = (const file_n **)b;
    int timea = (int) (**ia).mtime;
    int timeb = (int) (**ib).mtime;
    if(timea == timeb)
      return strcmp((**ia).name, (**ib).name);
    return timea - timeb;
}

int main(int argc, char* argv[]){
  if(argc != 2){
    printf("Incorrect number of arguments, exiting.\n");
    return -1;
  }
  stack_s stack;
  stack_init(&stack);
  items *list = (items*)malloc(sizeof(items));
  list->dircnt = (list->filecnt = 0);
  memset(list->dirs, 0, sizeof(char*)*MAX_ITEM_CNT);
  memset(list->files, 0, sizeof(char*)*MAX_ITEM_CNT);
  checkDir(argv[1], &stack, list);

  qsort(list->dirs,list->dircnt,sizeof(char*), &qsortcbdir);
  for(int i=0;i < list->dircnt;i++){
    printf("%s\n", list->dirs[i]);
    free(list->dirs[i]);
  }
  printf("---\n");

  qsort(list->files,list->filecnt,sizeof(file_n*), &qsortcbfile);
  for(int i=0;i < list->filecnt;i++){
    printf("path: %s, mtime: %s", (list->files[i])->name, ctime(&((list->files[i])->mtime)));
    free((list->files[i])->name);
    free(list->files[i]);
  }
  free(list);

  return EXIT_SUCCESS;
}

file_n *new = (file_n*) malloc(sizeof(file_n*));

file_n *new = malloc(sizeof(file_n));