重新分配char**'的内存；c中的s

我试图用c语言编写一个编译器，但已经有一段时间了，我在为char**类型的对象分配内存时遇到了问题。守则：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>

#define FATAL 1
#define NONFATAL 0

#define GENERIC 0
#define INVALID_ARG_COUNT 1
#define BAD_FILE_HANDLE 2
#define INVALID_FILE_TYPE 3
#define ACCESS_DENIED 4
#define SUCH_LOOPS_WOW 5
#define NAME_TOO_LONG 6
#define OOM 7

typedef struct {
    char *msg;
    int fatal;
} error_t;

static error_t table[] = {
/*000*/    {"something went wrong that does not have error handling", FATAL},
/*001*/    {"invalid number of arguments", FATAL},
/*002*/    {"file could not be opened", FATAL},
/*003*/    {"file is not a lightning (.lgt) source file", FATAL},
/*004*/    {"access to source file is denied", FATAL},
/*005*/    {"too many symbolic links between target and source", FATAL},
/*006*/    {"file to be passed has too long of a name", FATAL},
/*007*/    {"not enough memory to compile source file", FATAL}
};

void lgt_error(int code) {
    fprintf(stderr, "error: %s\n", table[code].msg);

    if(table[code].fatal) {
        exit(EXIT_FAILURE);
    }
}

char *processedFiles[] = {0};
int size = 0;

void add(char filename[]) {
    processedFiles = realloc(processedFiles, ++size);
    *processedFiles++ = malloc(strlen(filename));
    *processedFiles = filename;
}

int alreadyProcessed(char *filename) {
    char **iterator = &processedFiles[0];

    for(int counter = 0; counter <= size; iterator++, counter++) {
        if(filename == *iterator) {
            return 1;
        }
    }

    return 0;
}

int match(FILE *file, char *directive) {
    char *sequence = malloc(strlen(directive) + 1);

    for(int counter = 0; counter < strlen(directive); counter++) {
        *sequence++ = fgetc(file);
    }

    return strcmp(sequence, directive);
}

char *grabFile(FILE *file) {
    char current = 0;
    char *filename = malloc(1);

    while((current = fgetc(file)) != EOF && (!isspace(current) || current != ';')) {
        sprintf(filename, "%s%c", filename, current);
    }
}

void lgt_process(char *filename, char *translationUnit) {
    add(filename);

    struct stat buf; /* *sigh* have fun porting this to windows dumbass */

    if(stat(filename, &buf) != 0) {
        switch(errno) {
            case EACCES: {
                lgt_error(ACCESS_DENIED);
            }

            case EBADF:
            case ENOENT:
            case ENOTDIR:
            case EOVERFLOW: {
                lgt_error(BAD_FILE_HANDLE);
            }

            case EFAULT: {
                lgt_error(GENERIC);
            }

            case ELOOP: {
                lgt_error(SUCH_LOOPS_WOW);
            }

            case ENAMETOOLONG: {
                lgt_error(NAME_TOO_LONG);
            }

            case ENOMEM: {
                lgt_error(OOM);
            }
        }
    }

    translationUnit = (char*) realloc(translationUnit, strlen(translationUnit) + (size_t) buf.st_size);

    FILE *file = fopen(filename, "r");

    if(!file) {
        lgt_error(BAD_FILE_HANDLE);
    }

    char next = 0;

    while((next = fgetc(file)) != EOF) {
        ungetc(next, file);

        if(next == 'i') {
            if(match(file, "import") == 0) {
                char *nextFile = grabFile(file);

                if(alreadyProcessed(nextFile) == 0) {
                    lgt_process(nextFile, translationUnit);
                }
            }
        }
    }

    fclose(file);
}

int main(int argc, char **argv, char **env) {
    if(argc == 1) {
        lgt_error(INVALID_ARG_COUNT);
    }

    ++argv;

    if(strcmp(".lgt", strrchr(*argv, '.')) != 0) {
        lgt_error(INVALID_FILE_TYPE);
    }

    char *source = malloc(1);

    lgt_process(*argv, source);

    free(source);
}

应该如下所示

char **processedFiles = NULL;
int size = 0;

void add(char *filename) {
    processedFiles = realloc(processedFiles, (size+1)*sizeof(char*));
    processedFiles[size] = malloc(strlen(filename)+1);
    strcpy(processedFiles[size++], filename);
}

---

也许这会有帮助，一个简单的字符串向量

#define STRINGVECTOR_CHUNK_ALLOCATION_SIZE 50

typedef struct{
    char** vector;
    unsigned int size;
    unsigned int allocated_size;
} stringvector;

typedef  int (*stringvector_comparer)(char* l, char* r);

void stringvector_create(stringvector* v)
{
    v->vector = malloc(sizeof(char*)*STRINGVECTOR_CHUNK_ALLOCATION_SIZE);
    v->allocated_size = STRINGVECTOR_CHUNK_ALLOCATION_SIZE;
    v->size=0;
}

char* stringvector_at(stringvector* v, int index)
{
    return (v->vector[index]);
}

void stringvector_add(stringvector* v, char* s)
{
    if(v->size+1 >= v->allocated_size)
    {
        v->allocated_size+=STRINGVECTOR_CHUNK_ALLOCATION_SIZE;
        v->vector = realloc(v->vector, sizeof(char*)*(v->allocated_size));
    }   
    v->vector[v->size] = strdup(s); 
    v->size++;
}

void stringvector_destroy(stringvector* v)
{
    int i;
    for(i=0; i<v->size; i++)
    {
        free(v->vector[i]);
    }
    free(v->vector);
}

int stringvector_contains(stringvector* v, char* s, stringvector_comparer comparer)
{
    int i;
    for(i=0; i<v->size; i++)
    {
        if(comparer(v->vector[i], s) == 0) return 1;
    }
    return 0;
}

---

那么您就不需要add函数了，只需使用stringvector\u add。

既然您说您喜欢RAII，那么我将推荐一种更好的代码设计，它借鉴了一些OO原则：

typedef struct 
{
    char const **data;  // or non-const if you intend to modify in-place
    size_t size;
} StringList;

void add(StringList *list, char const *filename)
{
    void *new = realloc(list->data, (list->size + 1) * sizeof *list->data);
    if ( !new )
        exit(EXIT_FAILURE);  // and/or free list->data, other error handling

    list->data = new;
    list->data[list->size++] = strdup(filename);
}

示例用法：

StringList processed_files = { 0 };

add(&processed_files, "foobar.baz");

---

如果您打算在任何严肃的代码中使用这个，我会考虑改进分配策略（即，添加一个代码< sisixt容量；<代码> > <代码> StrugList，并以较大的块分配；这样您就不必为每一个新条目调用<代码> ReLoLC/<代码>。需要彻底检修。该函数中没有一行在某种程度上是正确的。另外，

处理的文件应该是
char**
，而不是
char*[]
。你明白我想用add（）做什么吗？如果是的话，你能提出一个建议吗？他说的话^^^我想你可能不理解指针和数组？另外，
processedFile
看起来像是一个打字错误。@KeithNicholas可能不会。RAII真的让我摆脱了指针和静态大小数组的习惯，就像@KeithNicholas写的那样？@DTSCode是的，看起来我们是机器人h同时回答了好的。谢谢！我想我会选择这样的答案。我只是想确保我正确理解了你的答案。你可能想使用Matt输入的错误检查，我省略了所有错误检查、边界检查等。另外，为了一个好的检查，我也会进行块分配。所需要的是另一个在名为allocated_size的typedef中计数，当您添加的内容将超过它时，再分配50个左右的条目。
  int i;
    stringvector v;
    stringvector_create(&v);
    stringvector_add(&v, "test");
    stringvector_add(&v, "this");
    stringvector_add(&v, "code");

    for(i=0; i< v.size; i++)
    {
        printf("%s\r\n", stringvector_at(&v, i));
    }

    printf("contains 'this': %d\r\n", stringvector_contains(&v, "this", strcmp));
    printf("contains 'This': %d\r\n", stringvector_contains(&v, "This", strcmp));
    printf("contains 'This': %d\r\n", stringvector_contains(&v, "This", stricmp));
    stringvector_destroy(&v);

stringvector processedFiles;
stringvector_create(&processedFiles);

typedef struct 
{
    char const **data;  // or non-const if you intend to modify in-place
    size_t size;
} StringList;

void add(StringList *list, char const *filename)
{
    void *new = realloc(list->data, (list->size + 1) * sizeof *list->data);
    if ( !new )
        exit(EXIT_FAILURE);  // and/or free list->data, other error handling

    list->data = new;
    list->data[list->size++] = strdup(filename);
}

StringList processed_files = { 0 };

add(&processed_files, "foobar.baz");