malloc calloc realloc free

**lia20** · 24/05/2007, 21h06

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
#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)
		return NULL;
	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;
		return NULL;
	}
 
	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) {
		return malloc(size);
	}
	if(size == 0) {
		free(ptr);
		return NULL;
	}
	if(size == tmp->size) {
		return ptr;
	} else {
		void *new = NULL;
		free(ptr);
		new = malloc(size);
		if(new != ptr)
			new = memcpy(new,ptr,tmp->size);
		return new;
	}
 
 
   return NULL;
}
 
void *calloc(size_t nmemb, size_t size) {
	void *new = malloc(nmemb*size);
	if(new)
		memset(new,0,nmemb*size);
   return new;
}

**souviron34** · 24/05/2007, 21h22

Première remarque :

tu fais les tests à l'envers....

quand tu fais :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
	if(NULL == ptr)

tu compares si NULL est égal à ptr...

La logique veux que tu compares si ptr est égal à NULL..

Donc :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
	if(ptr == NULL)

et c'est pareil pour beaucoup de tes tests...

[EDIT]

Ensuite, pourquoi fais-tu :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
	if(size == 0)
		return (void *)1;

dans malloc ???

Ce serait pas return NULL ???

[/EDIT]

**muad'dib** · 24/05/2007, 22h13

Envoyé par souviron34

Première remarque :

tu fais les tests à l'envers....

quand tu fais :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
	if(NULL == ptr)

tu compares si NULL est égal à ptr...

La logique veux que tu compares si ptr est égal à NULL..

En réalité cette façon d'écrire (bien qu'illogique, il est vrai, pour nous habitués de l'affectation de droite à gauche) est plus efficace que le traditionnel NULL sur la droite car elle évite les erreurs typiques oú l'on oublie un signe = pendant la comparaison

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
	if(ptr = NULL)

compile

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
	if(NULL = ptr)

ne compile pas !

gl · 24/05/2007, 22h49

Envoyé par souviron34

tu fais les tests à l'envers....

quand tu fais :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
	if(NULL == ptr)

tu compares si NULL est égal à ptr...

C'est tout a fait correct et equivalent a

Envoyé par souviron34

La logique veux que tu compares si ptr est égal à NULL..

Donc :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
	if(ptr == NULL)

Et c'est une pratique assez repandue pour les raisons fournies par muad'dib.

Meme si avec des compilateurs recents et correctement regles elle presente peu d'interet, puisque ces compilateurs emettront probablement un warning en cas d'affectation dans un test.

**souviron34** · 24/05/2007, 22h52

peut-être , mais non seulement c'est illogique, mais c'est en plus incohérent avec le reste du code....

Exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
...
	if(size == 0)
...
	if(fsp_alt->size > (((units + 1) * SIZEMBLOCK) + SIZEMBLOCK)) {
...
	if(fsp_alt == fsp)
...
	if(tmp->next != KENNUNG)
...
	if(ptr == (void *)1 || ptr == NULL)
...
	if(size == tmp->size)
...
		if(new != ptr)
...

mais

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
..
	if(NULL == ptr)
..
	if(-1 == (int)newmem)
..
	if(NULL == newmem)
..
	if(NULL == ptr || ptr == (void *)1)
..

Donc déjà point de vue lisibilité, c'est pas fort. Cohérence non plus..

Tu ne dis pas : "si je tombe, je trébuche" ....

**Emmanuel Delahaye** · 26/05/2007, 10h22

Envoyé par souviron34

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
..
	if(NULL == ptr)
..
	if(-1 == (int)newmem)
..
	if(NULL == newmem)
..
	if(NULL == ptr || ptr == (void *)1)
..

Donc déjà point de vue lisibilité, c'est pas fort. Cohérence non plus..

Bah, l'opérateur d'égalité est commutatif, alors on fait ce qu'on veut...

Tout ce qu'on peut dire, c'est que c'est un peu inhabituel comme codage et que c'est un moyen de codage défensif pour les débutants... Nous autres, vieux routiers, on sait faire la différence entre = et ==...

Personnellement, je n'aime pas non plus cette façon de coder, bien qu'elle soit tout à fait correcte.

gl · 26/05/2007, 11h16

Envoyé par souviron34

Tu ne dis pas : "si je tombe, je trébuche" ....

Certes non, mais la tu as une simple implication, pas une equivalence comme avec l'operateur d'egalite ==.

Personellement, je partage en partie ton avis sur cette ecriture, je l'apprecie assez peu et ne la pratique pas.

Mais c'est tout a fait correct, logique (en math aussi l'operateur d'egalite est commutatif) et permet, lorsque le compilateur ne fournit pas d'avertissement en cas d'utilisation 'une affectation dans un test, d'eviter les erreurs de frappe stupides

**lia20** · 26/05/2007, 15h22

j'ai compris par rapport a ma facon d'ecrire mais l'egalité ne change rien! Revenons en a mon problem.Est ce que quelqu'un a deja essayer derepresenter ces fonctions et voir comment cela marche?Ces multiples test sont lapour gerer les erreurs.Mon pointeur fsp->next pointe sur lui meme je ne sais a quel niveau.
j'aimerai voir le fonctionnenet d'un malloc pour comprendre mon erreur.j'ai vu des projets semblable mais pas de solution.

malloc calloc realloc free

C

Discussions similaires

Partager

Partager