Question

我知道有几个参赛作品，我看了看他们并没有完全达到我想要的地方。

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

我正在尝试创建一个名为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（可能是我的数组）因为我还没有掌握那些神秘的东西。

Answer 1

您对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);

Answer 2

以下是如何发展“字符串”的“数组”：

#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

Answer 3

看这里：

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

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

据我了解，这应该是例如

char items [count][255];

int C99 style。

BTW，count使用未初始化。在开始时将其设置为零。

Answer 4

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

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

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

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

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

但是，如果支持C99或更高版本，

可能是最佳选择。

创建argv []以将args发送到另一个函数

4 个答案: