Ubuntu-fr

benlaug

Problème de réallocation de la mémoire

Bonjour à tous, je calle sur un problème de mémoire et je voudrais bien de l'aide si ça ne vous dérange pas

Voici la démarche : J'ai un tableau alloué dynamiquement dont les cellules contiennent une structure (qui contient juste un pointeur void*) pour faire une pile générique. Lorsque j'ajoute un item je met donc l'adresse de cette item dans le pointeur void* d'une cellule de ma pile.

Le but est d'augmenter la taille de la pile à chaque puissance de 2 (Si jai 4 élements et que je veux en rajouter un 5ème, je réalloue 8 élements à  la pile. Je veux rajouter un 9ème élement, je passe de 8 à 16 éléments pour ma pile,...).

Le problème est lors de la deuxième réallocation. La première passe impeccablement bien (donc passage de 2 éléments à 4 éléments lors de l'ajout d'un 3ème élement), la deuxième (passage de 4 à 8) me retourne l'erreur :

*** glibc detected *** realloc(): invalid next size: 0x0804b008 ***
Abandon

J'ai d'ailleurs mis dans les commentaires de mon prog.c à partir d'où ça foire.

Ce que je voudrais (si possible), est corriger l'erreur seulement dans mon fichier stack.c

Voici mes trois fichiers :

stack.h

#ifndef _STACK_H_
#define _STACK_H_

#include <stddef.h>		/* size_t */


typedef struct Stack_t Stack;	/* opaque stack data structure */

Stack* newStack(void);
int push(Stack* stack, void* item);

#endif /* _STACK_H_ */

stack.c

#include <stdio.h>
#include <stdlib.h>
#include "stack.h"

struct Stack_t {
  void* data;  // Pointer to the (first) cell(s)
};

const size_t STACK_SIZE = 2;
const short int FACTOR = 2;
size_t actualSize;

Stack* newStack(void) {
  Stack* stack = (Stack*)malloc(STACK_SIZE * sizeof(*stack));

  if (!stack)
    return NULL;

  actualSize = STACK_SIZE;

  return stack;
}

unsigned long int actualPosition = 0;

int push(Stack* stack, void* item) {
  if (item == NULL || stack == NULL)
    return 1;

  if (actualPosition == actualSize) {
    actualSize *= FACTOR;
    stack = realloc(stack, actualSize * sizeof(Stack*));

    if (!stack)
      return 1;
  }

  stack[actualPosition].data = item;

  actualPosition++;

  return 0;
}

prog.c

#include "stack.h"
#include <stdlib.h>

void test(Stack* stack, double number);

int main() {
  Stack* stack = newStack();

  test(stack, 1);
  test(stack, 2);
  test(stack, 3); // Realloc() OK
  test(stack, 4);
  test(stack, 5); // Bad realloc()
  test(stack, 6);
  test(stack, 7);
  test(stack, 8);

  return 0;
}

void test(Stack* stack, double number) {
  double* item = (double*)malloc(sizeof(*item));
  *item = number;
  push(stack, item);
  item = NULL;
}

Merci d'avance,

Benjamin

Dernière modification par benlaug (Le 25/03/2007, à 16:48)

benlaug

Re : Problème de réallocation de la mémoire

Un p'tit up SVP:(

EDIT :Je CROIS avoir compris d'où vient le problème grâce à GDB mais je ne sais pas comment le résoudre.

stack à comme adresse : 0x804a008.

après réallocation dans le fichier stack.c, stack à comme adresse : 0x804a048.

seulement après cette réallocation, le fichier prog.c renvoie toujours l'adresse 0x804a008.

Est-ce le problème ? Si oui, comment le résoudre ?

Dernière modification par benlaug (Le 25/03/2007, à 17:53)

benlaug

Re : Problème de réallocation de la mémoire

C'est bon j'ai trouvé, merci quand même