Question

我的代码的目标是创建一个循环的字符串向量，并以可变大小进行dinamically分配。代码没有完成，但我不得不停止因为我的函数aumentar（增加）不起作用，它应该采用向量，加倍其内存大小并重新组织向量，使其开始位于0位置。只是为了澄清某种东西，结构丝中的i和f是向量的开始和结束。由于它是循环的，我需要这些索引来读取它。正如您所看到的，我在代码中放了一些printfs来向您展示正在发生的事情。基本上，虽然我将向量发送到函数aumentar，但Q.i和Q.f始终保持为0和1，因此程序总是说向量已满。我怀疑我没有正确改变Q.我试图做的是在函数unshift中将指针new指定给Q，尝试改变原始的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)中进行比较，这是假的。

我的矢量大小加倍的功能似乎不起作用

1 个答案: