malloc,calloc,realloc,free

Bonjour je dois ecrire les fonction malloc calloc realloc et free pour qu'ils agissent exactement comme ceux de la bibliothe (stdlib).le maximun de memoire a allouer est 1MB et je dois gerer toutes les erreurs d'allocation.jai ecris une partie mais jai des pb avec la fonction malloc.Si quelqu'un l'a deja fais j'aimerai bien voir les codes pour comparer et me debloquer.Sinon j'aimerai bien de l'aide.
 

Code :

				

						

								

										#include "halde.h" 
								
						
						

								

										#include <unistd.h>
								
						
						

								

										#include <errno.h>
								
						
						

								

										#include <string.h>
								
						
						

								

										#include <stdio.h>
								
						
						

								

										#include <stdlib.h>
								
						
						

								
 
						
						

								

										#define KENNUNG ((void*)0x00beef00)
								
						
						

								

										#define SIZEMBLOCK (sizeof(mblock))
								
						
						

								

										#define MB (1024*1024)
								
						
						

								
 
						
						

								

										/* Speicherverwaltung */
								
						
						

								

										typedef
										struct mblock {
						
						

								
    size_t size;
						
						

								
    struct mblock *next;
						
						

								

										} mblock;
						
						

								
 
						
						

								

										/* globale Variablen */
								
						
						

								

										static
										char *newmem = NULL;
						
						

								

										static mblock *fsp = NULL;
						
						

								
 
						
						

								

										int bloecke = 0;
						
						

								
 
						
						

								

										static mblock *getMblock(void *ptr){
						
						

								
    if(NULL == ptr)
						
						

								
        returnNULL;
						
						

								
    return(mblock *)((char *)ptr - SIZEMBLOCK);
						
						

								

										}
								
						
						

								
 
						
						

								

										static
										void init(){
						
						

								
    newmem = (char *)sbrk(MB);
						
						

								
    if(-1 == (int)newmem){
						
						

								
        perror("sbrk");
						
						

								
        exit(EXIT_FAILURE);
						
						

								
    }else{
						
						

								
        fsp = (mblock *)newmem;
						
						

								
        fsp->size = MB-SIZEMBLOCK;
						
						

								
        fsp->next = NULL;
						
						

								
    }
						
						

								

										}
								
						
						

								
 
						
						

								

										void *malloc(size_t size){
						
						

								
    mblock *fsp_alt = fsp;
						
						

								
    mblock *fsp_neu = fsp;
						
						

								
    mblock *fsp_merken = fsp;
						
						

								
    int units = 0;
						
						

								
    int lauf = 0;
						
						

								
    
						
						

								
    if(NULL == newmem){
						
						

								
        init();
						
						

								
    }
						
						

								
 
						
						

								
    if(size == 0)
						
						

								
        return(void *)1;
						
						

								
    
						
						

								
    while(fsp_alt && fsp_alt->size < size){
						
						

								
        /* Speicher finden */
						
						

								
        fsp_merken = fsp_alt;
						
						

								
        fsp_alt = fsp_alt->next;
						
						

								
        lauf++;
						
						

								
    }
						
						

								
    
						
						

								
    if(!fsp_alt){
						
						

								
        errno = ENOMEM;
						
						

								
        returnNULL;
						
						

								
    }
						
						

								
 
						
						

								
    units = ((size-1) / SIZEMBLOCK) + 1;
						
						

								
    if(fsp_alt->size > (((units + 1) * SIZEMBLOCK) + SIZEMBLOCK)){
						
						

								
        fsp_neu = fsp_alt + 1 + units;
						
						

								
        fsp_neu->size = fsp_alt->size - (units + 1) * SIZEMBLOCK;
						
						

								
        fsp_neu->next = fsp_alt->next;
						
						

								
    }else{
						
						

								
        fsp_neu = fsp_alt->next;
						
						

								
    }
						
						

								
    fsp_alt->next = KENNUNG;
						
						

								
    bloecke++;
						
						

								
    
						
						

								
    if(fsp_alt == fsp)
						
						

								
        fsp = fsp_neu;
						
						

								
    else{
						
						

								
        fsp_merken->next = fsp_neu;
						
						

								
    }
						
						

								
 
						
						

								
    return((void *)(fsp_alt + 1));
						
						

								

										}
								
						
						

								
 
						
						

								

										void
										free
										(
										void* ptr){
						
						

								
    mblock *tmp = NULL;
						
						

								
    if(NULL == ptr || ptr == (void *)1)
						
						

								
        return;
						
						

								
    tmp = getMblock(ptr);
						
						

								
    if(tmp->next != KENNUNG){
						
						

								
        abort();
						
						

								
    }else{
						
						

								
        tmp->next = fsp;
						
						

								
        fsp = tmp;
						
						

								
    }
						
						

								

										}
								
						
						

								
 
						
						

								

										void *realloc(void *ptr,size_t size){
						
						

								
    mblock *tmp = getMblock(ptr);
						
						

								
    if(ptr == (void *)1 || ptr == NULL){
						
						

								
        returnmalloc(size);
						
						

								
    }
						
						

								
    if(size == 0){
						
						

								
        free(ptr);
						
						

								
        returnNULL;
						
						

								
    }
						
						

								
    if(size == tmp->size){
						
						

								
        return ptr;
						
						

								
    }else{
						
						

								
        void *new = NULL;
						
						

								
        free(ptr);
						
						

								
        new = malloc(size);
						
						

								
        if(new != ptr)
						
						

								
            new = memcpy(new,ptr,tmp->size);
						
						

								
        returnnew;
						
						

								
    }
						
						

								
    
						
						

								
    
						
						

								
   returnNULL;
						
						

								

										}
								
						
						

								
 
						
						

								

										void *calloc(size_t nmemb, size_t size){
						
						

								
    void *new = malloc(nmemb*size);
						
						

								
    if(new)
						
						

								
        memset(new,0,nmemb*size);
						
						

								
   returnnew;
						
						

								

										}
								
						
				
		

salut perso j'ai rien compris à ton code comment alloues-tu la mémoire ?? ce qui me vient à l'idée ça serait de commencer par un tableau global char mem[1024*1024]; ensuite tu alloues des blocs à l'intérieur de cette memoire en faisant comme les compilateurs C: la première case du tableau indique la taille de la mémoire qui suit

"je dois ecrire les fonction malloc..."
Faudra donc appeler les fonctions d'allocation du système hote.
Compilant pour Windows, malloc() finit chez HeapAlloc(), sous Linux aucune idée.

ciao...
BruNews, MVP VC++

c'est vraiment difficile de comprendre avec cet affichage pourtant jai utilisé la balise de code.en fait je cree un espace en utilisant la fonction sbrk(). En fait quant je verifie abec le dbg je me retrouve avec une bouble infinie au niveau de malloc ou free je sais pas trop.je n'arrive pas a reperer l'erreur-