Comportement étrange realloc

Question

Je développe une structure de tableau juste pour le plaisir. Cette structure, généralisée par un paramètre de modèle, pré alloue un certain nombre d'éléments au démarrage, puis, si les éléments « occupé » sont plus que ceux disponibles, une fonction réallouer la mémoire tampon interne. Le test du code est:

#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;
}

Comme vous pouvez le voir, je prealloc 100 pointeurs entiers au début, puis je les réallouer avec 10 autres pointeurs à la fois. Dans la fonction principale, j'effectue une boucle pour vérifier l'intégrité des éléments et, si un élément de tableau n'est pas comme je le pense, j'imprime sa valeur et ... vous savez quoi? J'ai le message suivant:

!!! 11! = 135121

En fait, le point à l'indice 11, qui devrait être '11', est 135121 !!!! : S

Pouvez-vous me dire si mon code est incorrect?

Merci

NOTE Je sais parfaitement que le mélange C et C ++ cette façon est laid , et je sais aussi que cette structure bousiller si elle est utilisée, par exemple:

darray_t<std::string>

Ceci est juste un test pour les pointeurs int.

Answer 1

realloc ne se développe pas automatiquement le morceau de mémoire - vous devrez le faire. Faites par exemple:.

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

(et vous devez gérer realloc NULL retour)

Answer 2

La taille du bloc est incorrect:

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

Le bloc entier est aussi grand que l'incrément. Essayez

da->busy + sizeof(T) * DARRAY_REALLOC_ITEMS_STEP