2

我知道有一些关于此的条目，我浏览了它们，并不能完全到达我想去的地方。

我正在构建函数，它可以读取目录的内容并将常规文件传递给另一个函数以构建存档。

我正在尝试制作一个名为 items 的 argv[] 项目，我可以将其传递给我的函数，问题是我需要用文件名填充它。而不是静态声明它（我在很多示例中看​​到）我想根据文件数使用 malloc 。

这是快速的函数头：

void quick(int argc, char *argv[])

这是附加功能：

void append(char* argv[]){
    struct dirent *dp;
    int count, i = 3;
    char *files;
    char items [*files][255];
    DIR *dirp = opendir(".");
    if(dirp == NULL){
        fail('f');
    }

    printf("ar: adding files in current directory to archive: %s", argv[2]);

    while((dp = readdir(dirp)) != NULL){
        if(dp->d_type == DT_REG){
            count++;
        }
    }

    rewinddir(dirp);
    files = malloc(count*sizeof(char));

    //copy argv[2] archive name, into files, so we can pass to quick
    strcpy(items[2], argv[2]);

    while((dp = readdir(dirp)) != NULL){
        errno = 0;
        dp = readdir(dirp);

        //leave is dir is empty
        if(dp == NULL)
            break;

        // Skip . and ..
        if (strcmp(dp->d_name, ".") == 0 || strcmp(dp->d_name, "..") == 0)
            continue;

        //if file is not the archive and a regular file add to list
        if(strcmp(dp->d_name, argv[2]) != 0 && dp->d_type == DT_REG){
            strcpy(items[i], dp->d_name);
            i++;
        }
    }
    closedir(dirp);

    quick(i, items);
}

我在项目 arg 上遇到错误，因为指针类型不兼容，我猜我没有正确执行 malloc（可能还有我的数组），因为我仍然没有掌握这些奥秘。

4

4 回答 4

3

您的声明char items [*files][255]不正确。

基本上，你想files成为一个数组数组；因此它需要是指针到指针（即char**）类型。然后您需要分配该数组中的每个数组来保存实际的字符串，如下所示：

char** files;
files = malloc(count * sizeof(char*));      // allocate the array to hold the pointer
for (size_t i = 0; i < count; i += 1)
    files[i] = malloc(255 * sizeof(char));  // allocate each array to hold the strings

完成后适当释放内存：

for (size_t i = 0; i < count; i += 1)
    free(files[i]);
free(files);
于 2013-02-02T23:13:57.053 回答
1

以下是如何增长“字符串”的“数组”：

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

int AddString(char*** strings, size_t* count, const char* newStr)
{
  char* copy;
  char** p;

  if (strings == NULL ||
      newStr == NULL ||
      (copy = malloc(strlen(newStr) + 1)) == NULL)
    return 0;

  strcpy(copy, newStr);

  if ((p = realloc(*strings, (*count + 1) * sizeof(char*))) == NULL)
  {
    free(copy);
    return 0;
  }

  *strings = p;

  (*strings)[(*count)++] = copy;

  return 1;
}

void PrintStrings(char** strings, size_t count)
{
  printf("BEGIN\n");
  if (strings != NULL)
    while (count--)
      printf("  %s\n", *strings++);
  printf("END\n");
}

int main(void)
{
  char** strings = NULL;
  size_t count = 0;
  PrintStrings(strings, count);
  AddString(&strings, &count, "Hello World!");
  PrintStrings(strings, count);
  AddString(&strings, &count, "123");
  AddString(&strings, &count, "ABCDEF");
  PrintStrings(strings, count);
  return 0;
}

输出（ideone）：

BEGIN
END
BEGIN
  Hello World!
END
BEGIN
  Hello World!
  123
  ABCDEF
END
于 2013-02-02T23:24:24.337 回答
0

看这里：

char *files;
char items [*files][255];

你最好在初始化malloc之后使用。files

据我了解，这应该是例如

char items [count][255];

诠释 C99 风格。

顺便说一句，count使用未初始化。在开始时将其设置为零。

于 2013-02-02T23:01:08.383 回答
0

静态知道列的长度，您还可以分配

char (*items )[255];
// obtain row count
items = malloc(rowCount * sizeof(*items));

内存指向的指针char[255]。这样，您将获得一个连续的内存块，这可能会提供更好的局部性，并且您只需要free一个指针。

如果行数不太大，使用变长数组，

rowCount = whatever;
char items[rowCount][255];

但是，如果支持 C99 或更高版本，则可能是最佳选择。

于 2013-02-02T23:31:06.437 回答