utilisation de la fonction malloc

**nass956** · 04/01/2018, 01h30

Bonsoir,
je n'arrive pas a comprendre ce bout de code. Qu'est-ce qu'un pointeur sur un type ?
merci d avance

Code :

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

1
2
int* memoire = NULL; 
memoire = malloc(sizeof(int));

**Daïmanu** · 04/01/2018, 09h33

Bonjour,

Je pense que tu trouveras des réponses dans notre FAQ, notamment les premières sections : https://c.developpez.com/faq/?page=Les-pointeurs

Une réponse rapide :
Première ligne : memoire est un pointeur (sa valeur est une adresse de la mémoire RAM) qui pointe sur un entier. memoire vaut au départ NULL (il ne pointe sur rien).
Deuxième ligne : malloc demande au système d'exploitation un peu de mémoire RAM et si il en reste, le système réserve cette RAM et l'indique à memoire. La valeur de memoire (l'adresse pointée) est alors l'adresse de l'emplacement réserve par le système.
A noter qu'il doit exister un free(memoire) quelque part après qui indique au système qu'il n'y a plus besoin plus besoin de l'entier pointé par memoire, et donc plus besoin de memoire lui-même.

**ternel** · 04/01/2018, 09h36

Un pointeur est une simple variable qui contient l'adresse en mémoire d'une chose d'un type donné.

La fonction malloc permet de faire allouer au système de la mémoire (issue du "tas" ou "heap").
Elle retourne l'adresse du bloc mémoire alloué, sous la forme d'un pointeur.

Un pointeur ne contient pas toujours l'adresse d'un bloc alloué par malloc, il peut contenir l'adresse d'une autre variable (par exemple: int entier; int * p = &entier;).

**sambia39** · 04/01/2018, 11h20

Bonjour,

Envoyé par Daïmanu

Bonjour,

Je pense que tu trouveras des réponses dans notre FAQ, notamment les premières sections : https://c.developpez.com/faq/?page=Les-pointeurs

Une réponse rapide :
Première ligne : memoire est un pointeur (sa valeur est une adresse de la mémoire RAM) qui pointe sur un entier. memoire vaut au départ NULL (il ne pointe sur rien).
Deuxième ligne : malloc demande au système d'exploitation un peu de mémoire RAM et si il en reste, le système réserve cette RAM et l'indique à memoire. La valeur de memoire (l'adresse pointée) est alors l'adresse de l'emplacement réserve par le système.
A noter qu'il doit exister un free(memoire) quelque part après qui indique au système qu'il n'y a plus besoin plus besoin de l'entier pointé par memoire, et donc plus besoin de memoire lui-même.

Attention, malloc n'alloue pas la mémoire dans la RAM immédiatement , contrairement, à ce qui a été dit elle attribue des adresses mémoire virtuelle, c'est ce que l'on appelle une mascarade mémoire (utilisation de la mémoire virtuelle ce que fait le système d'exploitation GNU/Linux ou Unix et probablement Windows afin de vous donner une illusion de mémoire infinie pour chaque processus). La mémoire est réellement allouée quand vous allez écrire dedans et c'est le système d'exploitation qui va vous attribuer la mémoire souhaiter en RAM, mais pas avants, c'est pour cela que personnellement pour masure de la réelle disposition de la mémoire, il faut initialiser à zéro cette mémoire ou autres voire exemple ci-dessous qui déclenchera ainsi une erreur d’accès (une erreur de segmentation) qui à l’issue fournira là une page mémoire réelle et non virtuelle. (Une des raisons aussi est que malloc échoue rarement dû à cette utilisation d'adresse virtuelle).

Ceci dit pour des questions d'optimisation il faut utiliser la mémoire allouée au plus vite et rendre ce qui vous a été alloué par le système de façon rapide après toute opération d'exploitation. Bien entendu cela sous-entend faire appel à free qui en réalité dit au système d'exploitation que je n'utiliserai plus cette mémoire sans où après que j'ai reset les données qui s’y trouvent. Et à l'issue changer l’adresser mémoire contenue dans variables pointeur que vous avez utilisées par l'adresse mémoire invalide NULL pour dire que la variable pointeur pointe maintenant sur rien d'autre qu'une adresse invalide; garantissant ainsi que toute mauvaise manipulation incorrecte du pointeur sera automatiquement détectée.

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
26
27
28
29
30
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
int main( void ){
 
	size_t i = 0;
	char *p = NULL;
	extern int errno;
 
	errno = 0;
	if( NULL == ( p = malloc( sizeof(*p) * 10) ) ){
		(void)fprintf(stderr, "Erreur(%d)\t:%s\n\t:%s\n",
			errno, "Allocation mémoire", strerror(errno) );
		return errno;
	}
 
	(void)memset(p, 0x0, (sizeof(*p)*10) );
	for( i = 0; i < 10; i++ )
		*(p+i) = i;
 
	for( i = 0; i < 10; i++ )
		(void)fprintf(stderr, "%d", *(p+i) );
 
	free( p );
	p = NULL;
 
	return EXIT_SUCCESS;
}

à bientôt

**Bktero** · 04/01/2018, 11h42

Ca, c'est un beau discours qui est valable sur PC avec des OS comme Linux et Windows. Ce n'est pas forcément vrai tout le temps. Et c'est absolument inutile de sortir un tel discours à un grand débutant en C...

Le vrai boulot de malloc() est donné par sa page de manuel. C'est simple et précis = ça alloue de la mémoire sans l'initialiser :

La fonction malloc() alloue size octets, et renvoie un pointeur sur la mémoire allouée. Le contenu de la zone de mémoire n'est pas initialisé. Si size est nulle, malloc renvoie soit NULL ou un unique pointeur qui pourra être passé ultérieurement à free() avec succès.

**sambia39** · 04/01/2018, 15h04

Attention, il n'est pas question de faire un beau discours, il est question d'apporter une notion de compréhension à comment est attribuée réellement la mémoire sollicitée à travers la fonction d'allocation mémoire malloc et non, l'utilisation de la fonction malloc pour allouer de la mémoire et comprendre ou sous-entendre que l'on obtient une adresse mémoire qui est directement celle de la RAM comme ce qui a été dis . Et en parlant du manuel, le manuel présente l'utilisation de la fonction (ce qui est fourni ou demandé et ce qui est rendu en retour par la fonction) plus bas à la section note, il est précisé et je cite:

"By default, Linux follows an optimistic memory allocation strategy. This means that when malloc() returns non-NULL there is no guarantee that the memory really is available. In case it turns out that the system is out of memory, one or more processes will be killed by the OOM killer. For more information, see the description of /proc/sys/vm/overcommit_memory and /proc/sys/vm/oom_adj in proc(5), and the Linux kernel source file Documentation/vm/overcommit-accounting. ....".

En clair cela veut dire de façon simple que malloc réserve de la mémoire, mais cela ne veut pas dire que la mémoire est disponible automatiquement (réserver de la mémoire ce n'est pas en disposer immédiatement) . De mon point de vue, je trouve qu'il est donc important de préciser cela.

En ma connaissance FreeBsd, GNU/Linux, Mac OS et probablement Windows, tous attribuent une adresse virtuelle. J’en conclus qu'aucun système d'exploitation sur PC n'échappe à cette règle, mais attention tout dépend de la quantité de mémoire sollicitée et de la stratégie d'allocation qu'utilise la fonction malloc pour pouvoir réserver de la mémoire souhaitée et en disposer. Tout comme, cela dépend également de l'implémentation de la fonction qui varie d'un système a un autre. Là n'est pas le debat ni la question posée et d'ailleurs, je n'ai pas répondu à la question posée.

Envoyé par nass956

bonsoir je n arrive pas a comprendre ce bout de code ,qu'est-ce q'un pointeur sur un type ?
merci d avance

Code :

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

1
2
3
 
int* memoire = NULL; //(1)
memoire = malloc(sizeof(int));  //(2)

Pour y répondre, je dirais juste qu'une variable pointeur est une variable comme tant d’autres avec un type, mais sa particularité, c’est qu’il contient uniquement des adresses. On la qualifie de pointeur parce qu’il contient l’adresse de ce qui se trouve en mémoire. Par définition, on peut dire qu'un pointeur est une adresse associée à un type de donnée et que ces deux éléments sont absolument indissociables. Si la variable pointeur contient l’adresse d’un objet du type entier par "exemple ", l’objet pointé permet donc de savoir comment en doit interpréter les bits qui comptent cet objet, ainsi que ça taille.

Quant à la fonction malloc, elle est utilisée pour réserver un espace mémoire en cours d'exécution (c'est ce que l'on appelle communément une allocation dynamique). malloc renvoie donc un pointeur universel ou dit autrement générique (c'est-à-dire capable de pointer vers n'importe quel type d'objet) qui contient l'adresse de la zone mémoire allouée ou NULL cas contraire.

Votre code ci-dessus veut dire que :

Que l'on déclarer un pointeur sur un entier
Que l'on demande au système de bien vouloir nous réserver de la mémoire pour pouvoir y stocker un objet de type entier. Si c'est possible une adresse, nous est fournie, mais attention, rien ne nous dit qu’a cette adresse la mémoire est réellement disponible. Pour sen assuré, il faut écrire dedans. Cas contraire si la réservation de mémoire n'est pas disponible, il faut consulter la variable errno pour connaître la raison de l'échec et prendre les mesures adéquates pour quitter proprement le système ; raison pour lequel on compare l’adresse NULL avec le pointeur.

Lorsque l'on a plus besoin de la mémoire réserver (cela sous-entend que l'on utilise plus le pointeur initialiser avec les fonctions d'allocation dynamique) il faut libérer l'espace de la mémoire et ceci se fait grâce a la fonction free. Cela libère le bloc de mémoire désigné par votre pointeur, mais attention l'adresse contenue dans le pointeur n'est pas modifiée si vous tenter utiliser ou écrire voir autre, cela finirait systématiquement par une erreur. Le plus souvent après libération mémoire il est conseillé d'attribuer au pointeur l'adresse de NULL pour dire que le variable pointeur ne pointe maintenant sur rien d'autre qu'une adresse invalide (donc pas utilisée); garantissant ainsi que toute mauvaise manipulation incorrecte du pointeur sera automatiquement détectée.

À bientôt

**Bktero** · 04/01/2018, 15h43

J'aurais dû citer la norme C et non une page de manuel de Linux qui a justement cette stratégie de "j'alloue mais en fait non".

Ce que dit la norme C99 :

7.20.3.3 The malloc function
Synopsis
1 #include <stdlib.h>
void *malloc(size_t size);
Description
2 The malloc function allocates space for an object whose size is specified by size and
whose value is indeterminate.
Returns
3 The malloc function returns either a null pointer or a pointer to the allocated space.

Pour le reste, je suis désolé mais ça reste un beau discours, aussi vrai soit-il. Ne pas comprendre que c'est inutile de parler de choses aussi avancées à un débutant qui demande ce qu'est un pointeur, c'est dommage.

**Daïmanu** · 04/01/2018, 16h41

Je pense comme @BKtero qu'autant de détails n'est peut-être pas nécessaire dans ce thread et c'est pourquoi je suis resté simple dans ma réponse.
Même si à titre personnel j'ai également appris quelques trucs grâce à vous (ce pourquoi j'ai

vos interventions).

**sambia39** · 04/01/2018, 16h52

Envoyé par Bktero

J'aurais dû citer la norme C et non une page de manuel de Linux qui a justement cette stratégie de "j'alloue mais en fait non".

Ce que dit la norme C99 :

Pour le reste, je suis désolé mais ça reste un beau discours, aussi vrai soit-il. Ne pas comprendre que c'est inutile de parler de choses aussi avancées à un débutant qui demande ce qu'est un pointeur, c'est dommage.

Désolé d'être têtus, mais la norme écrite ceci:

"Memory management functions
The order and contiguity of storage allocated by successive calls to the calloc, malloc, and realloc functions is unspecified. The pointer returned if the allocation succeeds is suitably aligned so that it may be assigned to a pointer to any type of object and then used to access such an object or an array of such objects in the space allocated (until the space is explicitly deallocated). The lifetime of an allocated object extends from the allocation until the deallocation. Each such allocation shall yield a pointer to an object disjoint from any other object. The pointer returned points to the start (lowest byte address) of the allocated space. If the space cannot be allocated, a null pointer is returned. If the size of the space requested is zero, the behavior is implementation- defined: either a null pointer is returned, or the behavior is as if the size were some nonzero value, except that the returned pointer shall not be used to access an object."

Le passage en gras précis bien dans l'espace alloué et d'un autre côté, je n'ai pas parlé des choses avancées, j'apporte une notion de compréhension quand pourrais comprendre autrement par ce qu'a été écrit.

Si vraiment, je parlais de chose avancer, j'apporterais plus de précision sur le réel mécanisme d'allocation mémoire en avale (les fonctions d'allocation dynamique) et en amont sur les mécanismes d’interaction entre le processeur et la mémoire (plus particulièrement le MMU, car c'est lui qui effectue toute la transformation des adresses virtuelles en une adresse physique) pour offrir une vue d'ensemble plus concrète chose que je n'ai pas faite. Pour ma part, je pense également avoir répondue à la question posée dans mon précédent post de façon générale en partant de l'exemple fourni.

**nass956** · 05/01/2018, 02h59

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
26
27
28
29
30
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
int main( void ){
 
	size_t i = 0;
	char *p = NULL;
	extern int errno;
 
	errno = 0;
	if( NULL == ( p = malloc( sizeof(*p) * 10) ) ){
		(void)fprintf(stderr, "Erreur(%d)\t:%s\n\t:%s\n",
			errno, "Allocation mémoire", strerror(errno) );
		return errno;
	}
 
	(void)memset(p, 0x0, (sizeof(*p)*10) );
	for( i = 0; i < 10; i++ )
		*(p+i) = i;
 
	for( i = 0; i < 10; i++ )
		(void)fprintf(stderr, "%d", *(p+i) );
 
	free( p );
	p = NULL;
 
	return EXIT_SUCCESS;
}

je n'ai pas tres bien compris ton code si tu pourais me l'expliquer en détails stp
a partir de extern int errno je ne comprend plus trop merci

**sambia39** · 05/01/2018, 13h05

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
26
27
28
29
30
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
int main( void ){
 
	size_t i = 0;
	char *p = NULL;
	/*(1)*/extern int errno;
 
	 errno = 0;
	/*(2)*/if( NULL == ( p = malloc( sizeof(*p) * 10) ) ){
		(void)fprintf(stderr, "Erreur(%d)\t:%s\n\t:%s\n",
			errno, "Allocation mémoire", strerror(errno) );
		return errno;
	}
 
	/*(3)*/(void)memset(p, 0x0, (sizeof(*p)*10) );
	/*(4)*/for( i = 0; i < 10; i++ )
		    *(p+i) = i;
 
	/*(5)*/for( i = 0; i < 10; i++ )
		(void)fprintf(stderr, "%d", *(p+i) );
 
	/*(6)*/free( p );
	p = NULL;
 
	return EXIT_SUCCESS;
}

La variable errno est une variable globale du type entier dont la valeur est modifiée s'il y a une erreur. En clair, c'est une variable qui va contenir le numéro d'erreurs lors d'une erreur survenue pendant l'exécution de votre programme. Vous pourriez par la suite l'utiliser avec la fonction strerror qui renvoie une chaîne de caractères correspondant au numéro contenu dans errno pour savoir de quelle erreur il s'agit. Exemple si errno = 1 (donc a pour numéro 1) et que l'on utilise avec la fonction strerror(errno) cela renverra une chaîne de caractères de ce type "opération not permitted" cela veut dire qu'il y a eu une erreur parce que votre programme a fais une opération qui est pas permis. Autre exemple si c'est le numéro d'erreur et 12 cela renverra "cannot allocate memory" qui veut dire Impossible d'attribuer une mémoire. errno est mise a zéro pour dire qu'il n'y a pour instant aucune erreur (je le fait au tout debut du programme)

Le terme extern est un spécificateur qui s'applique indifféremment d'une variable globale ou fonction. Dans mon exemple, elle s'applique à la variable globale errno pour signifier que la variable errno est déclarée ailleurs et qu'elle ne sera connue que par l'éditeur de liens et qu'il ne faut donc pas lui réserver de la memoire (pas dans le module actuel).

fprintf est une fonction qui s'utilise comme printf a ceci près que les arguments sont les flux sur lequel écrire. Ici stderr est le flux erreur, c'est-à-dire la deuxième sortie écrans (console si vous préférer) utiliser pour afficher les messages d'erreur. Il existe son homologue stdout qui est la première sortie par défaut "donc la console " et stdin pour les entrées clavier. Les (void) devant les fonctions veulent dire que je n'utilise pas les valeurs de retour de ces fonctions.
sizeof est un opérateur qui renvoie le nombre d'octets nécessaires pour stocker un objet du type spécifié; dans mon exemple, j'ai utilisé sizeof(*p) cela veut dire que sizeof renvoie la taille du type sur lequel "p" peut pointé. En résumé, pour faciliter la compréhension de cette instruction if( NULL == ( p = malloc( sizeof(*p) * 10) ), cela veut dire que je fourni à la fonction d'allocation dynamique de mémoire malloc la taille du type sur lequel "p" pointe, fois dix. A l'issue la fonction d'allocation me fournira une adresse qui est stocker dans la variable pointeur; puis je compare la variable pointeur avec l'adresse de NULL. Si cela correspond alors, il y a eu échec lors de ma demande de réservation de mémoire et dans ce cas, je fais afficher pourquoi j'ai eu cette erreur puis j'utilise return pour mettre fin à mon programme en indiquant au système d'exploitation que mon programme, c'est arrêter parce qu'il y a eu une erreur de type errno (exemple de type opération not permitted).
La fonction memset est une fonction qui permet de copier 0x0 soit zéro vers les "x" premiers caractères de la chaîne pointée par l'argument "p". Donc j'écris des données à l'adresse contenu dans mon pointeur. Et comme je l'avais souligné au départ en écrivant à cette adresse, je m'assure alors que je dispose bien de la mémoire et par la même occasion, j'initialise cet mémoire; c'est-à-dire que je mets tout à zéro.
Juste après memset j'utilise une boucle pour écrire les données a l'aide des arithmétiques des pointeurs.
*p est un déréférencement de pointeur cela veut dire que j'accède à la valeur de l'élément qui se trouve a la première case mémoire donc, la case zéro. l'instruction *(p+i) = i; veux dire que j'accède à la valeur de la case mémoire "i" et je luis attribue la valeur de "i" en plus simple; si i vaut 2 cela veut donc dire que j'accède à la valeur qui se trouve dans la case mémoire 2 (p[2]) et je la change en mettant la valeur qui correspond a i donc 2 (p[2] = 2; ).
J'utilise à nouveau une boucle pour afficher ce que j'ai inscrit dans la mémoire à l'aide des arithmétiques de pointeurs [I](sous cette forme p c'est également possible) mais sous un autre format %d qui veut dire affiche moi les valeurs décimales.
Je fais appel à la fonction free pour rendre la mémoire au système donc je ne l'utilise plus et par la suite NULL pour dire que je pointe maintenant sur rien d'autre qu'une adresse invalide ; garantissant ainsi que toute mauvaise manipulation incorrecte du pointeur sera automatiquement détectée. Je retourne EXIT_SUCCESSqui a pour valeur 0 qui veut dire que le programme, c'est terminer sans erreur.

à bientôt

utilisation de la fonction malloc

C

Discussions similaires

Partager

Partager