comportamento strano realloc

Question

Sto sviluppando una struttura a matrice solo per divertimento. Tale struttura, generalizzata da un parametro di template, pre alloca un numero di pezzi, all'avvio, quindi, se gli articoli "occupato" sono più di quelle disponibili, una funzione realloc buffer interno. Il codice di test è:

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

template <typename T> struct darray_t {
    size_t items;
    size_t busy;
    T     *data;
};

#define DARRAY_REALLOC_ITEMS_STEP 10

#define da_size(da) (da)->busy

template <typename T>
void da_init( darray_t<T> *da, size_t prealloc ){
    da->items = prealloc;
    da->busy  = 0;
    da->data  = (T *)malloc( sizeof(T) * prealloc );
}

template <typename T> T *da_next( darray_t<T> *da ){
    if( da->busy >= da->items ){
        da->data   = (T *)realloc( da->data, sizeof(T) * DARRAY_REALLOC_ITEMS_STEP );
        da->items += DARRAY_REALLOC_ITEMS_STEP;
    }
    return &da->data[ da->busy++ ];
}

int main(){
    darray_t<int> vi;
    int *n;

    da_init( &vi, 100 );

    for( int i = 0; i < 101; ++i ){
        n = da_next(&vi);
        *n = i;
    }

    for( int i = 0; i < da_size(&vi); ++i ){
        if( vi.data[i] != i ){
            printf( "!!! %d != %d\n", i, vi.data[i] );
        }
    }

    return 0;
}

Come si può vedere, i prealloc 100 puntatori interi all'inizio e poi ho realloc loro con più di 10 puntatori al momento. Nella funzione principale, eseguo un ciclo for per controllare gli elementi integrità e, se un elemento di matrice non è come mi aspetto, a stampare il suo valore e ... sai una cosa? Ho il seguente messaggio:

!!! 11! = 135121

In effetti, elemento di indice 11, che dovrebbe essere '11', è 135.121 !!!! : S

Puoi dirmi se il mio codice non è corretto?

Grazie

Nota So perfettamente che la miscelazione C e C ++ in questo modo è brutta , e so anche che questa struttura sarebbe rovinare se usato, per esempio:

darray_t<std::string>

Questa è solo un test per int puntatori.

Answer 1

realloc non cresce automaticamente il pezzo di memoria - dovrete farlo. Do per esempio:.

da->data=(T*)realloc(da->data, sizeof(T)*(da->items+DARRAY_REALLOC_ITEMS_STEP));

(e si dovrebbe gestire realloc ritorno NULL)

Answer 2

La dimensione del blocco non è corretto:

da->data   = (T *)realloc( da->data, sizeof(T) * DARRAY_REALLOC_ITEMS_STEP );

L'intero blocco è grande come l'incremento. Prova

da->busy + sizeof(T) * DARRAY_REALLOC_ITEMS_STEP