我的使向量大小加倍的函数似乎不起作用

Question

我的代码的目标是创建一个循环的字符串向量，并以可变大小动态分配。代码还没有完成，但我不得不停下来，因为我的函数 aumentar (increase) 不起作用，它应该获取向量，将其内存大小加倍并重新组织向量，使其开始位于位置 0。只是为了澄清某些东西，结构 fila 中的 i 和 f 是向量的开始和结束。由于它是循环的，我需要这些索引来阅读它。如您所见，我在代码中放置了一些 printfs 来向您展示正在发生的事情。基本上，虽然我将向量发送到函数 aumentar，但 Q.i 和 Q.f 始终保持为 0 和 1，因此程序总是说向量已满。我怀疑我没有正确改变 Q。我试图做的是在函数 unshift 中将指针 new 分配给 Q，试图改变原来的 fila Q。所以，基本上，我在函数理论方面遇到了问题。不要介意未释放的向量。我打算稍后再做。这是一个示例输入：

unshift bla bla bla bla aaa ccc

unshift aaaa bbbb ccccc

退出

这里是代码：

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

typedef char string[20];
typedef struct fila {
    int i, f; //inicio e fim
    char **v; //vetor de strings 
    int mem; //espacos de memoria alocados para o vetor principal(char *)
    int n;
} fila;

fila* aumentar (fila* Q) { 
    fila* new = malloc(sizeof(fila));
    new->v = malloc(sizeof(char *) * Q->mem * 2);
    int n;
    for (n = 0; n < Q->mem - 1; n++) {
        new->v[n] = malloc(sizeof(char) *  strlen(Q->v[(Q->i + n) % Q->mem]));
        strcpy(new->v[n], Q->v[(Q->i + n) % Q->mem]);
    }
    new->i = 0;
    new->f = Q->mem - 1;
    new->mem = Q->mem * 2;
    return new;
}

void unshift (fila* Q) {
    char buffer[500];
    gets(buffer);
    if(Q->n == 0) {
        printf("O vetor esta vazio\n");
        Q->v[0] = malloc(sizeof(char) * (strlen(buffer)+ 1));
        strcpy(Q->v[0], buffer);
        Q->n++;
        return;
    }
    printf(" qi: %d qf:  %d  \n", Q->i, Q->f);
    if ((Q->f + 1) % Q->mem == Q->i) {
        printf("O vetor esta cheio\n");
        Q = aumentar(Q);
        printf("Eu voltei do aumentar\n");
    }
    int pos = Q->i - 1; //inserir no inicio e testar caso especial em que i = 0;
    if (pos < 0) {
        pos = pos + Q->mem;
    }
    Q->i = pos; //atualizando o valor do inicio para o novo primeiro elemento
    Q->v[pos] = malloc(sizeof(char) * (strlen(buffer)+ 1));
    strcpy(Q->v[pos], buffer);
    Q->n++;
}



//void print_first (char **v) {
//  int i;
//  for (i = 0; i < 20; i++) {
//      printf("%c", v[0][i]);
//  }   
//}

int main(int argc, char *argv[]) {
    fila Q;
    Q.v = malloc(2 * sizeof(char *)); //aloca os dois primeiros espacos de memoria do vetor principal
    Q.f = 1; //fim aponta pra posicao 1 por enquanto
    Q.i = 0; //inicio aponta pra posicao 0 por enquanto
    Q.mem = 2;
    Q.n = 0;
    char comando[20]; //comando do usuario
    while(1) {
        scanf(" %s", comando); 
        if (strcmp("unshift", comando) == 0) {
            unshift(&Q);
            //faca as operacoes de unshift
        }
        else if (strcmp("shift", comando) == 0) {
            //faca as operacoes de shift
        }
        else if (strcmp("print-first", comando) == 0) {
            //print_first(v);
        }
        else if (strcmp("push", comando) == 0) {
            //faca as operacoes de push
        }
        else if (strcmp("pop", comando) == 0) {
            //faca as operacoes de pop
        }
        else if (strcmp("print-last", comando) == 0) {
            //faca as operacoes de print-last
        }
        else if (strcmp("is-empty", comando) == 0) {
            //faca as operacoes de is-empty
        }
        else if (strcmp("exit", comando) == 0) {
            //destruir(v);
            return 0;
        }
    }
}

Answer 1

在这里为 v[0] 指针分配空间，然后为它分配另一个指针：

   Q->v[0] = malloc(sizeof(char) * (strlen(buffer)));
            Q->v[0] = buffer;

在这里，同样的事情：

Q->v[pos] = malloc(sizeof(char) * (strlen(buffer)));
    Q->v[pos] = buffer;

你宁愿从缓冲区 strcpy 到 v[0]。

Q->v[pos] = malloc(strlen(buffer) + 1);
strcpy(v[0],buffer);

缓冲区是本地数组，它创建在堆栈上，并且具有自动存储期限，这意味着它的生命周期从当前函数的开始延伸到结束，并且您将指向它的指针分配给您在另一个函数中继续使用的变量。

还有： 在unshift 中，您增加Q->n，在aumentar 之后再次增加0。所以基本上n 从函数到函数在0 和1 之间振荡。

编辑： 我数了一些数字，在第一次迭代后你有 Q.i=3，Q.n=1，Q.f=1，Q.mem=4，然后你在第二次迭代中比较 ((Q->f + 1) % Q->mem == Q->i)，这是错误的。