realloc: invertita serie puntatore?

Question

Ho scritto un piuttosto semplice (ish) implementazione dello stack che vorrebbe crescere automaticamente il buffer di matrice interna, se necessario.

Per questo, userei naturalmente realloc - Funziona, invece, tutti gli elementi dell'array ordinate inverso dopo la chiamata realloc ().

Il codice in questione:

• Intestazione: include / PD / stack.h
• Fonte: src / pila / stack.c

In questo esempio si attiverà detto comportamento:

#include "pd/strlib.h"
#include "pd/stack.h"
#include "pd/memory.h"
#include <stdlib.h>
#include <stdio.h>

int main()
{
    int index = 0;
    char* buffer;
    pd_stack_t* stc = pd_stack_new();
    pd_stack_push(stc, "blue");
    pd_stack_push(stc, "green");
    pd_stack_push(stc, "red");
    pd_stack_push(stc, "yellow");
    pd_stack_push(stc, "pink");
    pd_stack_push(stc, "olive");
    pd_stack_push(stc, "beige");
    pd_stack_push(stc, "gold");
    pd_stack_push(stc, "grey");
    pd_stack_push(stc, "lime");
    pd_stack_push(stc, "khaki");
    while((index++) != 500)
    {
        pd_stack_push(stc, "__random_value__");
    }
    buffer = (char*)malloc(pd_stack_size(stc));
    pd_stack_dump_tomem(stc, buffer, 1);
    fprintf(stdout, "%s", buffer);
    return 0;
}

Sono davvero all'oscuro di questo. Aiuto per favore!

Answer 1

appare come pd_stack_dump_tomem inizia il suo indice a stack size e decrementa a 0, aggiungendo gli elementi in ordine inverso.

Modifica per iniziare a 0 e iterare per stack size

(Sembra realloc non è correlato)

Answer 2

avete alcuni problemi fondamentali con il codice pila, quindi non credo che il realloc() è il vostro problema. Ecco alcune delle cose che si dovrebbero esaminare ed indirizzo:

• l'elemento in cima allo stack (quando non è vuota) viene puntato da (gct->stackcount - 1), dal momento che in pd_stack_push() di memorizzare un nuovo elemento nel gct->ptr_stack[gct->stackcount] poi stackcount incremento. Tuttavia, quando si sta accedendo il primo elemento, si utilizza l'offset errato, gct->ptr_stack[gct->stackcount] invece di gct->ptr_stack[gct->stackcount - 1]. In particolare, nel pd_stack_pop(), si libera l'elemento che potrebbe danneggiare il cumulo dal momento che non ci sia un puntatore valido in quella posizione dello stack.

• in pd_stack_push() vi invito realloc() ogni volta che un nuovo elemento viene spinto al catasta. Questo non sarà necessariamente corrotto nulla o causa di un difetto, ma è inutile - soprattutto perché si chiedere sempre la stessa allocazione dimensioni. In altre parole, le chiamate realloc() dovrebbero essere PON ad eccezione del primo.

• pd_stack_pop_index() non ha nemmeno senso a meno che non sempre e solo pop la prima voce (in cui dovrebbe essere utilizzata caso pd_stack_pop()). È gratis qualcosa di potenzialmente al centro della pila, quindi diminuire il stackcount, in sostanza, rendendo la prima voce (che non è necessariamente quello che hai liberato) inaccessibile. L'elemento al centro della pila che è stato liberato verrà ora accedere / liberata nuovamente quando è spuntato (supponendo che pd_stack_pop() è fisso).