结构和char **

Question

我最近在C编程中是全新的，我开始更多地研究指针，我遇到了代码问题。

所以我尝试将一个字符串传递给一个结构中的char** ，但我总是遇到错误。 在此先感谢这里是一些代码

这是我使用的结构。

typedef struct Queue {
int capacity;
int front;
int rear;
int size;
char **car_id;
};

这就是我试图加入的内容。 如果你能看到我尝试strcpy但失败了。 即使我把＆或*。

    printf("Printing the contect of the TXT file\n");
int countS=-1,countQ=-1;
char line[10];
FILE *fp;
fp = fopen("car.txt","r");
if (fp == NULL) {
    printf("Error: File doesn't exist exiting the programm!");
    exit(1);
}
while(!feof(fp)){
      fgets(line,10,fp);
      printf("%s",line);

       if(line[(strlen(line))-2]=='Q'){
        countQ++;
        line[strlen(line)-2] = 0;
        strcpy(car_id,line);
        strcpy(QBoat->car_id[countQ],car_id);
        QBoat->rear=countQ;
        QBoat->front=0;
        QBoat->size=countQ;
       }else if(line[(strlen(line))-2]=='S'){
        countS++;
        line[strlen(line)-2] = 0;
        SBoat->top = countS;
        //strcpy(SBoat->car_id[countS],line);
       }

}
fclose(fp);

Answer 1

使用结构很容易搞乱内存分配和释放。 因此，最好始终为每个结构编写new和destroy函数。

/* To avoid confusion, it's best to declare structs as type definitions
   and name them Something_t. Capital letter to avoid conflict with
   built in types, _t to note that it is a type, and to avoid conflict
   with other names. */
typedef struct {
    /* Using size_t means less type casting */
    size_t capacity;
    int front;
    int rear;
    int size;
    char **items;
} Queue_t;

Queue_t *Queue_new( const size_t capacity ) {
    /* Use calloc because we have to zero everything anyway */
    Queue_t *queue = calloc( 1, sizeof(Queue_t) );

    /* Allocate enough space to store a list of whatever
       queue->items is a list of */
    queue->capacity = capacity;
    queue->items = malloc( capacity * sizeof(*(queue->items)) );

    return queue;
}

void Queue_destroy( Queue_t *queue ) {
    /* Since items were copied into the list, it's the queue's responsibility
       to free them */
    for( int i = queue->front; i < queue->rear; i++ ) {
        free( queue->items[i] );
    }

    /* Now free the list of items */
    free( queue->items );

    /* And finally the struct itself */
    free( queue );
}

现在已经分配了结构及其项目列表，您必须确保不添加太多项目。 添加到队列的代码永远不会检查它是否超出了队列的容量。 因此，最好编写一个函数来添加能够正确检查容量的项目。

void Queue_add( Queue_t *queue, const char *item ) {
    if( queue->size >= (int)queue->capacity ) {
        fprintf(stderr, "Queue capacity of %zu exceeded!\n", queue->capacity);
        exit(1);
    }

    /* You used strcpy in your example, so I'm following that.
       You could also not copy and store the original pointer. */
    queue->items[ queue->rear ] = strdup( item );

    /* I don't know if this is right */
    queue->rear++;
    queue->size++;
}

排队逻辑可能是错误的，我对队列不好，但你明白了。 您甚至可以稍后扩展队列以自动调整自身大小。

现在，您可以单独测试这些工作。 一旦确定它们有效，您可以尝试从文件中读取并使用队列功能。

int main() {
    char filename[] = "car.txt";
    FILE *fp = fopen(filename,"r");
    if (fp == NULL) {
        fprintf(stderr, "Couldn't read '%s': %s\n", filename, strerror(errno));
        exit(1);
    }

    /* Just picked a number out of thin air */
    Queue_t *qboats = Queue_new(256);
    Queue_t *sboats = Queue_new(256);

    char line[10];
    while( fgets( line, 10, fp) != NULL ) {
        size_t len = strlen(line);

        /* Choose the right queue to use */
        Queue_t *queue;
        switch ( line[len-2] ) {
            case 'S':
                queue = sboats;
                break;
            case 'Q':
                queue = qboats;
                break;
            default:
                fprintf( stderr, "Can't understand line '%s'\n", line );
                continue;
                break;
        }

        /* Chop off the identifier */
        line[len - 2] = '\0';

        /* Add to the queue */
        Queue_add( queue, line );
    }

    /* Do something with the queues. This should probably be Queue_print(). */
    for( int i = qboats->front; i < qboats->rear; i++ ) {
        printf("qboat: %s\n", qboats->items[i]);
    }

    for( int i = sboats->front; i < sboats->rear; i++ ) {
        printf("sboat: %s\n", sboats->items[i]);
    }

    /* Now clean them up */
    Queue_destroy( sboats );
    Queue_destroy( qboats );
}

现在大部分工作都在确定要使用的队列。