Discussion :

[ypcman]

Bonjour.
Je sais que malloc est utilisé pour une 1° allocation mémoire et realloc pour modifier la taille initialement allouée mais je constate que je peux aussi utiliser realloc pour la 1° allocation mémoire :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
#include <stdio.h>
#include <stdlib.h>
int main() {
	int *ptr1 = (int*) malloc(sizeof(int));
	int *ptr2 = NULL;
	ptr2 = (int*) realloc(ptr2, sizeof(int));
	ptr1[0]=1;
	ptr2[0]=2;
	printf("%d %d\n",ptr1[0],ptr2[0]);
	return 0;
}

je me trompe ? il ne faut pas le faire ?
Ça me semble pourtant bien pratique, par exemple pour éviter de devoir différencier le cas initial (malloc) des cas suivants (realloc)dans une allocation conditionnelle :

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
#include <stdio.h>
#include <stdlib.h>
int main() {
	int *ptr2 = NULL;
	int i = 0;
	while (i < 10) { // par exemple
		ptr2 = (int*) realloc(ptr2, (i+1) * sizeof(int));
		ptr2[i] = i; // par exemple
		i+=1;
	}
	for (i = 0;i<10;i++){
	printf("%d\n", ptr2[i]);
	}
	return 0;
}
}

Merci d'avance pour vos lumières

[foetus]

realloc, la documentation en anglais sur cplusplus.com

In case that ptr is a null pointer, the function behaves like malloc, assigning a new block of size bytes and returning a pointer to its beginning.

[Sve@r]

Bonjour

mais je constate que je peux aussi utiliser realloc pour la 1° allocation mémoire :
je me trompe ? il ne faut pas le faire ?
Ça me semble pourtant bien pratique, par exemple pour éviter de devoir différencier le cas initial (malloc) des cas suivants (realloc)dans une allocation conditionnelle :

Tu as en effet tout à fait le droit d'utiliser realloc() pour ta première allocation en lui passant en effet un pointeur initialisé à NULL. C'est prévu pour et tout à fait autorisé.

Ce qu'il ne faut pas faire, en revanche, c'est utiliser directement le pointeur déjà alloué dans le realloc(). Parce que si le realloc() plante, tu perds le pointeur précédent (celui qui contenait la mémoire allouée) et tu te retrouves en état de fuite mémoire (mémoire allouée non restituable).
Tu dois utiliser un second pointeur, puis si la rellocation a réussi, transférer le second pointeur dans le premier.
Et vis à vis de ton exemple, il est bien conçu mais une reallocation à chaque boucle c'est lourd. Il est préférable d'allouer "n" puis quand "i" dépasse "n" alors là tu réalloue "n de plus".

Et on ne caste pas le malloc/realloc. Ces fonctions renvoient un void* qui est un pointeur universel donc il peut aller partout, le cast est implicite. Et s'il y a une erreur de compilation parce qu'il ne renvoie pas un void* alors c'est que tu as oublié l'include adéquat (ce que tu ne verras pas avec un cast). Le cast nous vient d'un temps que les moins de 20 ans ne peuvent pas connaitre dans lequel le void* n'existait pas et où on utilisait "char*" pour signifier "tout pointeur". Là il fallait alors caster. Le void* est arrivé justement pour supprimer cette merdenécessité.

Code c :

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
#include <stdio.h>
#include <stdlib.h>
#define SZ_ALLOC		(10)
int main() {
	unsigned long *tab = NULL;
	size_t i = 0;
	size_t sz=0;
	while (i < 100) { // par exemple
		if (i == sz) {
			sz+=SZ_ALLOC;
			unsigned long *tmp=realloc(tab, sz * sizeof(*tmp));
			if (tmp == NULL) {
				// Gérer le souci (et généralement on quitte)
				free(tab);
				return 1;
			}
			tab=tmp;
		}
		tab[i] = i; // par exemple
		printf("%lu (i=%lu, sz=%lu)\n", tab[i], i, sz);
		i++;
	}
	free(tab);
	return 0;
}

Ensuite tu affines SZ_ALLOC suivant la puissance du host sur lequel tu fais tourner ce code.

[ypcman]

Merci pour ces précieux conseils !

[edgarjacobs]

Bonjour

Et s'il y a une erreur de compilation parce qu'il ne renvoie pas un void* alors c'est que tu as oublié l'include adéquat

Ou que la compilation s'effectue en C++.

[djm44]

Bonjour

Tu as en effet tout à fait le droit d'utiliser realloc() pour ta première allocation en lui passant en effet un pointeur initialisé à NULL. C'est prévu pour et tout à fait autorisé.

Ce qu'il ne faut pas faire, en revanche, c'est utiliser directement le pointeur déjà alloué dans le realloc(). Parce que si le realloc() plante, tu perds le pointeur précédent (celui qui contenait la mémoire allouée) et tu te retrouves en état de fuite mémoire (mémoire allouée non restituable).
Tu dois utiliser un second pointeur, puis si la rellocation a réussi, transférer le second pointeur dans le premier.
Et vis à vis de ton exemple, il est bien conçu mais une reallocation à chaque boucle c'est lourd. Il est préférable d'allouer "n" puis quand "i" dépasse "n" alors là tu réalloue "n de plus".

Et on ne caste pas le malloc/realloc. Ces fonctions renvoient un void* qui est un pointeur universel donc il peut aller partout, le cast est implicite. Et s'il y a une erreur de compilation parce qu'il ne renvoie pas un void* alors c'est que tu as oublié l'include adéquat (ce que tu ne verras pas avec un cast). Le cast nous vient d'un temps que les moins de 20 ans ne peuvent pas connaitre dans lequel le void* n'existait pas et où on utilisait "char*" pour signifier "tout pointeur". Là il fallait alors caster. Le void* est arrivé justement pour supprimer cette merdenécessité.

Code c :

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
#include <stdio.h>
#include <stdlib.h>
#define SZ_ALLOC		(10)
int main() {
	unsigned long *tab = NULL;
	size_t i = 0;
	size_t sz=0;
	while (i < 100) { // par exemple
		if (i == sz) {
			sz+=SZ_ALLOC;
			unsigned long *tmp=realloc(tab, sz * sizeof(*tmp));
			if (tmp == NULL) {
				// Gérer le souci (et généralement on quitte)
				free(tab);
				return 1;
			}
			tab=tmp;
		}
		tab[i] = i; // par exemple
		printf("%lu (i=%lu, sz=%lu)\n", tab[i], i, sz);
		i++;
	}
	free(tab);
	return 0;
}

Ensuite tu affines SZ_ALLOC suivant la puissance du host sur lequel tu fais tourner ce code.

realloc est une fonction très efficace qui évite de passer par une mémoire tampon . En C++ ce serait plus lent. On peut aussi écrire sz <<= 1 .

[Sve@r]

On peut aussi écrire sz <<= 1 .

Doubler la taille à chaque fois. Pas mal

[djm44]

Effectivement doubler à chaque fois pour uniquement 100 éléments 1 par 1 c'est une erreur. Je pensais à un autre contexte.

[Sve@r]

Effectivement doubler à chaque fois pour uniquement 100 éléments 1 par 1 c'est une erreur. Je pensais à un autre contexte.

Ben non, j'ai trouvé ça bien. Et même en partant de 1, la taille passe à 2, puis 4, puis 8, puis 16, puis 32, puis 64, puis 128... et les 100 éléments sont enregistrés...

[djm44]

Ben non, j'ai trouvé ça bien. Et même en partant de 1, la taille passe à 2, puis 4, puis 8, puis 16, puis 32, puis 64, puis 128... et les 100 éléments sont enregistrés...

Tel que le code est écrit cela ferait 100 fois multiplier par 2 . Il faut peut-être changer

if ( i == sz )

pour faire une réallocation par multiples de 2

sz = 1 ;

if ( i + 1 >= sz )
{
sz <<= 1 ;

ptr = realloc( ....)
}

[Sve@r]

Tel que le code est écrit cela ferait 100 fois multiplier par 2

Ben non, dès que i atteint sz, sz est doublée. Donc sz passe à 1, 2, 4, 8, 16, 32, 64, 128 => 8 multiplications. Faut juste gérer le premier cas quand sz est à 0.

Code c :

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
#include <stdio.h>
#include <stdlib.h>
int main() {
	unsigned long *tab = NULL;
	size_t i = 0;
	size_t sz=0;
	while (i < 100) { // par exemple
		if (i == sz) {
			sz=sz > 0 ?sz << 1 :1;
			printf("sz=%lu\n", sz);
			unsigned long *tmp=realloc(tab, sz * sizeof(*tmp));
			if (tmp == NULL) {
				// Gérer le souci (et généralement on quitte)
				free(tab);
				return 1;
			}
			tab=tmp;
		}
		tab[i] = i; // par exemple
		//printf("%lu (i=%lu, sz=%lu)\n", tab[i], i, sz);
		i++;
	}
	free(tab);
	return 0;
}

Le printf(sz) ne sort que 8 fois...

[djm44]

Ben non, dès que i atteint sz, sz est doublée. Donc sz passe à 1, 2, 4, 8, 16, 32, 64, 128 => 8 multiplications. Faut juste gérer le premier cas quand sz est à 0.

Code c :

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
#include <stdio.h>
#include <stdlib.h>
int main() {
	unsigned long *tab = NULL;
	size_t i = 0;
	size_t sz=0;
	while (i < 100) { // par exemple
		if (i == sz) {
			sz=sz > 0 ?sz << 1 :1;
			printf("sz=%lu\n", sz);
			unsigned long *tmp=realloc(tab, sz * sizeof(*tmp));
			if (tmp == NULL) {
				// Gérer le souci (et généralement on quitte)
				free(tab);
				return 1;
			}
			tab=tmp;
		}
		tab[i] = i; // par exemple
		//printf("%lu (i=%lu, sz=%lu)\n", tab[i], i, sz);
		i++;
	}
	free(tab);
	return 0;
}

Le printf(sz) ne sort que 8 fois...

Oui c'est une possibilité . J'aurais plutôt mis sz initialisé à 1 pour ne faire qu'une comparaison
if ( i + 1 >= sz )

et ne pas ajouter

sz = ( sz > 0 ) ? sz << 1 : 1;

[Sve@r]

Oui c'est une possibilité . J'aurais plutôt mis sz initialisé à 1 pour ne faire qu'une comparaison
if ( i + 1 >= sz )

Dans ce cas là tu fais une opération en plus (addition) à chaque étape (les 100 itérations). Dans l'autre, il y a certes une comparaison de plus mais la comparaison ne se fait que sur 8 itérations...

[djm44]

Dans ce cas là tu fais une opération en plus (addition) à chaque étape (les 100 itérations). Dans l'autre, il y a certes une comparaison de plus mais la comparaison ne se fait que sur 8 itérations...

Je ne pense pas qu'il y ait une addition dans if ( i + 1 >= sz ) mais une incrémentation .

Le printf(sz) ne sort que 8 fois..

oui mais if ( i == sz ) est exécuté 100 fois

[Sve@r]

Je ne pense pas qu'il y ait une addition dans if ( i + 1 >= sz ) mais une incrémentation .

Hé non, c'est bien une addition. Et une incémentation c'est une addtiion avec affectation. Donc l'un dans l'autre ça reste toujours une addition.

oui mais if ( i == sz ) est exécuté 100 fois

if (i + 1 == sz) l'est aussi.
Le sujet du dernier post portait sur la comparaison de ces deux portions de code

Code :

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

1
2
3
4
sz=0
if (i == sz) {
	sz = (sz > 0) ?sz << 1 :1; 
	...

qui fait 100 comparaisons ; et 8 comparaisons supplémentaires pour savoir s'il faut affecter "sz << 1" ou "1"
vs

Code :

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

1
2
3
4
sz=1
if (i + 1 == sz) {
	sz = sz << 1; 
	...

qui fait 100 additions et 100 comparaisons

[djm44]

Effectivement dans ce cas c'est mieux de faire 100 comparaisons + 8 comparaisons