Fonction malloc(langage C)

[deyni]

Bonjour,

je voudrai savoir si les implementations suivantes sont vraies:

/*1ere implementation*/

typedef struct _A{ 
   int x;
   int y;
} A;

A *ma = (A*) malloc(sizeof(A))



/*2eme implementation*/

void f(int *n){
   n =(int*) malloc(sizeof(int)*30);
} 

/*3eme implementation*/

int *p = (int *)malloc(sizeof(int));

Ce que je pense:

1ere) Non correct bien que le "transtypage"(cast) soit effectué. Car malloc renvoie donne une adresse.
2eme)Correct, on alloue une mémoire de 30 octet à l'adresse de n
3eme) Non correct parceque on envoie un malloc vers un pointeur.

Je suis sûr que je me trompe. Donc si vous pouvez me corriger.

Merci bien.
-----

[Zartan]

Bonjour,

Ca vous pose un problème parce que vous faites deux choses sur la même ligne : la déclaration et l'initialisation :

	A *ma ;
              ma = (A*) malloc(sizeof(A));
	ma->x = 2;
	(*ma).y = 3;

	printf ("x=%d, y=%d\n", (*ma).x, ma->y) ;

/*3eme implementation*/

	int *p ;
	p = (int *)malloc(sizeof(int))   ; 
	*p = 2;
	printf("p=%d\n", p[0]) ;
	p[0] = 4;
	printf("p=%d\n", *p) ;

Toutes ces implémentations sont correctes (mais il y avait des erreurs de syntaxe).

[kwariz]

Bonjour,

/*1ere implementation*/
typedef struct _A{ 
   int x;
   int y;
} A;

A *ma = (A*) malloc(sizeof(A))

1ere) Non correct bien que le "transtypage"(cast) soit effectué. Car malloc renvoie donne une adresse.

Bon, avant toute chose il faut savoir que si malloc réussi, alors ce qui est renvoyé est une adresse valide. En c, la valeur d'un pointeur est une adresse, on peut donc affecter à un pointeur la valeur de retour d'un malloc.
Dans l'exemple, ma est de type pointeur sur une structure, il peut (doit) contenir une adresse, et de préférence cette adresse doit pointer sur un bloc dont la taille est suffisante pour contenir une structure de type A. malloc(sizeof(A)) renvoie une adresse à laquelle il y a assez de place pour stocker une structure de type A : c;est donc correct.
Il y a une sorte de guerre pour savoir s'il faut ou non caster le retour d'un malloc (normalement un malloc renvoie un void*). Je préfère largement (et je t'encourage) à ne JAMAIS caster le retour d'un malloc si tu programmes en C (si tu veux plus d'explications n'hésite pas ...)

/*2eme implementation*/
void f(int *n){
   n =(int*) malloc(sizeof(int)*30);
}

2eme)Correct, on alloue une mémoire de 30 octet à l'adresse de n

Alors l'allocation en elle-même est correcte (au cast près), on alloue de la place pour 30 int, n est pointeur sur int ... correct. Le problème ne vient pas de l'allocation mais de la manière dont fonctionne les appels de fonctions. Les paramètres sont passé par référence, cela signifie que si tu modifies la valeur de n dans f cette modification ne sera pas répercutée au retour de l'appel (attention je parle de la valeur de n, pas de la valeur de ce qui est pointé ... mais cela est une autre histoire).
Donc allocation correcte, mais fonction incorrecte. Je t'encourage d'ailleurs à tester tout ça pour t'en convaincre. Essaye de deviner par exemple la sortie du programme suivant, puis exécute le ...

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

void f(int *n)                                                                                   
{                                                                                                
  printf("Dans f avant malloc : %p\n",n);                                                        
  n = malloc(sizeof(int)*30);                                                                    
  printf("Dans f après malloc : %p\n",n);                                                        
}

int main()                                                                                       
{                                                                                                
  int *n=NULL;                                                                                   
  printf("Dans main avant f   : %p\n", n);                                                       
  f(n);                                                                                          
  printf("Dans main après f   : %p\n", n);                                                       
                                                                                                 
                                                                                                 
  return 1;                                                                                      
}

/*3eme implementation*/
int *p = (int *)malloc(sizeof(int));

3eme) Non correct parceque on envoie un malloc vers un pointeur.

malloc renvoie une adresse à laquelle on peut stocker un int, p est de type pointeur sur int : tout est correct (au cast près).

[kwariz]

J'ai écrit une grossière connerie : il faut évidemment lire dans le paragraphe sur la deuxième question :
«Les paramètres sont passés par copie [...]»

Toutes mes excuses ...

[A voir en vidéo sur Futura]

[PA5CAL]

Bonsoir

Dans la deuxième implémentation, la valeur de retour est stockée dans n, puis immédiatement perdue au retour de la fonction f(). La mémoire est alloué, mais pas utilisable, ni même libérable.

EDIT: zut, déjà dit...

[deyni]

Bonjour, merci à tous de vos réponses.
Zartan a raison ça me bloque beaucoup de faire deux choses sur la même ligne.
je pensais que:

int *p = ( int * ) malloc( sizeof( int ) ); //était équivalent à

int *p;
*p = (int *) malloc( sizeof( int ) );

Autre petite chose: est-ce que ces deux choses sont équivalentes:

A *ma ;
              ma = (A*) malloc(sizeof(A));
	ma->x = 2;
	(*ma).y = 3;

/*équivalent à */

A *ma ;
              ma = (A*) malloc(sizeof(A));
	ma->x = 2;
	ma->.y = 3;

Excusez aussi mon imprecision,j'aurai du écrire le cas où l'allocation echoue.

Pour le transtypage, j'ai effectivement deux profs dont l'un dit qu'il faut le faire, l'autre qui dit que c'est inutile. Moi je ne comprends pas pourquoi il ne faut pas faire de transtypage. Puisque on a un void*, censé retourner rien dit de manière abusive.
Les questions suivantes demandent justement de savoir si les modifications seront répercutées au retour de l'appel.

Dans votre programme kwariz, je pense que le programme affiche:

Dans f avant malloc : 0x1234 //une adresse
Car on fait un appel par n, et non *n. Donc on affiche une adresse et non le contenu.

Dans f après malloc : 120
Car si la taille d'un int est de 4(pour la plupart du temps), alors 30*4 = 120. J'ai un peu hésité en me disant que ça aurai pu être une adresse.

Dans main avant f : NULL
ou \0, j'hesite entre les deux. Car on initialise le pointeur à NULL, son adresse est NULL et son contenu est NULL.

Dans main après f : NULL.
Car on a un passage par copie. Donc il n'y a pas de répercusion dans la suite du programme.

Merci bien.

[Zartan]

Bonjour, merci à tous de vos réponses.
Zartan a raison ça me bloque beaucoup de faire deux choses sur la même ligne.
je pensais que:

int *p = ( int * ) malloc( sizeof( int ) ); //était équivalent à

int *p;
*p = (int *) malloc( sizeof( int ) );

Attention, c'est p= car *p représente le contenu et p l'adresse.

Autre petite chose: est-ce que ces deux choses sont équivalentes:

A *ma ;
              ma = (A*) malloc(sizeof(A));
	ma->x = 2;
	(*ma).y = 3;

/*équivalent à */

A *ma ;
              ma = (A*) malloc(sizeof(A));
	ma->x = 2;
	ma->.y = 3;

.

Oui, la forme (*ma) est inusitée mais ça permet de comprendre que *ma est de type A quand ma est de type A*

Quand je débutais j'écrivais systématiquement A* ma au lieu de A *ma pour ne pas me tromper.

Quant au cast, je le fais car j'ai appris comme cela, je n'ai pas encore eu de réflexion philosophique à ce sujet

[Zartan]

ma->.y ça n'existe pas, je n'avais pas vu...

[kwariz]

Bonjour, merci à tous de vos réponses.
Zartan a raison ça me bloque beaucoup de faire deux choses sur la même ligne.
je pensais que:

int *p = ( int * ) malloc( sizeof( int ) ); //était équivalent à

int *p;
*p = (int *) malloc( sizeof( int ) );

Autre petite chose: est-ce que ces deux choses sont équivalentes:

A *ma ;
              ma = (A*) malloc(sizeof(A));
	ma->x = 2;
	(*ma).y = 3;

/*équivalent à */

A *ma ;
              ma = (A*) malloc(sizeof(A));
	ma->x = 2;
	ma->.y = 3;

Excusez aussi mon imprecision,j'aurai du écrire le cas où l'allocation echoue.

Bonjour,
c'est vrai que les "raccourcis" peuvent dérouter. Sans trop entrer dans les détails, il faut différencier la déclaration (dire de quel type est une variable), l'initialisation (donner une valeur à la varaible) et le déréférencement (la variable est un pointeur et on ne manipule pas la variable mais ce qui est pointé par la variable).

int *p;
int* p;

c'est pareil : on déclare une variable nommée p et de type int *=pointeur vers int

int *p,*q;

on déclare deux variables p et q toutes les deux de type pointeur vers int. Pour déclarer un pointeur on préfixe la variable lors de la déclaration avec un *. Même si tu écris

int*   p;

le * ne s'applique qu'à p. C'est-à-dire que :

int*  p,q

est équivalent à

int *p,  q;

soit

int *p;
int q;

L'initialisation ne concerne que la variable :

int i=0;

On déclare une variable i qu'on initialise avec la valeur 0. De la même manière :

int* ptr=malloc(sizeof(int))

on déclare une variable ptr (de type pointeur sur int) et on intialise la variable (donc ptr) avec un malloc.

Déréférencer un pointeur c'est aller voir/modifier/manipuler ce qui est pointé. Là on est dans le code et plus dans une déclaration.

*ptr=10;

on ne modifie pas ptr, mais uniquement ce qui est pointé.

Pour donner une image : un pointeur c'est un peu comme un marque page (pointeur sur un page) pour un livre (un tableau de page). Manipuler un pointeur c'est manipuler le marque page (on le place sur la page 10) marqueur=10, le déréférencer c'est lire/gribouiller sur la page marquée (écrire je gribouille à la page 10) *marqueur="je gribouille"

En ce qui concerne les notations :

a->b est un raccourci pour (*a).b
a->.b provoque une erreur
pour info: a[b] est un raccourci pour *(a+b)

Pour le transtypage, j'ai effectivement deux profs dont l'un dit qu'il faut le faire, l'autre qui dit que c'est inutile. Moi je ne comprends pas pourquoi il ne faut pas faire de transtypage. Puisque on a un void*, censé retourner rien dit de manière abusive.
Les questions suivantes demandent justement de savoir si les modifications seront répercutées au retour de l'appel.

C'est tout à fait ça : caster le retour d'un malloc est inutile en C avec les compilateurs actuels. Avant 90, void* n'existait pas et malloc renvoyait un char* : le cast était obligatoire. Avec la normalisation on a introduit void*. C'est un pointeur générique : ATTENTION, il ne "retourne" pas rien, mais il contient une adresse dont on ne donne aucune information sur le type. Donc si tu utilises un compilo qui ne date pas des années 70/80, ni un compilateur C++ alors tu peux complètement te passer du cast. Entre autre ça simplifie le refactoring et évite certaines erreurs (entre autre l'oubli de l'inclusion de stdlib ...). L'idéal d'ailleur est même de ne pas utiliser le type de la variable mais le type de ce que le variable pointe (ok c'est pas clair).
Au lieu de :

int *p=(int *)malloc(sizeof(int));

il est plus simple d'utiliser

int *p=malloc(sizeof(*p));

Mais bon ... souvent il vaut mieux suivre l'avis du prof ...

Dans votre programme kwariz, je pense que le programme affiche:

Dans f avant malloc : 0x1234 //une adresse
Car on fait un appel par n, et non *n. Donc on affiche une adresse et non le contenu.

Dans f après malloc : 120
Car si la taille d'un int est de 4(pour la plupart du temps), alors 30*4 = 120. J'ai un peu hésité en me disant que ça aurai pu être une adresse.

Dans main avant f : NULL
ou \0, j'hesite entre les deux. Car on initialise le pointeur à NULL, son adresse est NULL et son contenu est NULL.

Dans main après f : NULL.
Car on a un passage par copie. Donc il n'y a pas de répercusion dans la suite du programme.

Merci bien.

Le plus simple est de le compiler et de l'exécuter
C'est le seul moyen de se familiariser avec le code : mettre la main dedans ; puis essayer de voir pourquoi ce qu'on croyait obtenir n'est pas ce qu'on obtient réellement.

[deyni]

Bonjour,
Excusez-moi pour ma->.y c'est un mauvais copié/coller.
Je voulais écrire ma ->y

Truc qui me bloque:

int addition(int a, int b){
 int c = a + b;
 return c;
}
/*Ce qui revient à*/
int c; 
c = a + b;

/*Mais pas ça*/
int c;
&c = a + b;

Comment ça ce fait que l'analogie ne fonctionne pas?

[kwariz]

Quelle analogie ???



int c=a+b
on déclare une variable nommée c de type int et on l'initialise avec la valeur a+b

int *ptr=malloc(sizeof(int))
on déclare une variable nommée ptr de type pointeur sur int et on l'initialise avec la valeur malloc(sizeof(int))

&c : on applique l'opérateur unaire & à la variable c, celui-ci renvoie l'adresse où est stockée la valeur de c. &c ne peut pas être modifié du tout (dans le sens tu ne peux pas trouver &c à la gauche de l'opérateur =)

Il n'y a pas d'analogie dans ce que tu écris; pour m'aider à comprendre où tu voies une analogie, pourrais-tu colorier un peu comme moi ?

[deyni]

Bonjour,
excusez-moi kwariz, je repondais au message de Zartan( le votre n'était pas encore là), et j'ai vu votre message apparaitre après que j'ai posté le mien.
Je pense que nous avons écrit nos messages en même temps. Vous avez postez le votre pendant que j'écrivais le mien.

Je vous remercie de ces rappels sur ces raccourcis. Le truc c'est que dés que je bloque, je me rabat sur quelquechose que je sais faire et rapporter au cas pour me débloquer.
Néanmoins, je crois que j'arrive beaucoup mieux à saisir la fonction.

Lorsque je vous ai vu écrire l'équivalent du tableau j'ai pensé à un truc que j'ai pas compris:

tab[ j ] = malloc( 30 * sizeof( char ));
tab[ j ] = memcpy( tab[ j ], debut, 30 - 1);
( tab[ i ] ) [ 30 - 1 ] ='\0';

Je ne comprends pas la 3eme ligne.
Comme vous me l'avez bien dit, on déclare le pointeur(int *) et on initialise(ptr), donc on utilise que le ptr et non *ptr.

Quand je serai en examen je demanderai au prof s'il veut le transtypage( par contre je sais qu'il naime pas le mot "cast", c'est un francophone invétéré. Il a même utiliser un "typedef entier int" pour ne pas utiliser "integer").

Je vais tenter de compiler le programme avec un Makefile maintenant que j'y arrive

[deyni]

J'ai une fois de plus tapé le message en même temps que le votre.

Je pensais que:
int c = a + b
On déclare une variable de type int, nommée cet on lui donne la valeur de a + b

int *ptr = malloc( sizeof( int ) );
On déclare une variable de type pointeur sur entiernommée ptr et on l'initialise avec malloc( sizeof( int ) );

Je pensais que on devait mettre le résultat de malloc à une adresse et non une variable.
Pour moi:
int *p; //déclaration du pointeur p
p = 12; //on donne 12 à l'adresse du pointeur.

Merci

[kwariz]

int* p; // on déclare un pointeur sur un int
p = 12; // p prend la valeur 12, c'est-à-dire que p vaut 12, on dit que p pointe sur 12
*p = 10; // on écrit l'entier 10 à l'adresse mémoire pointée par p, c'est-à-dire qu'à l'adresse 12 on écrit la valeur 10

En dessin ça donnerait :

[deyni]

Merci de vos explications et votre patience.

int *p, a = 12; //declaration d' un pointeur sur un int, et un entier initialisé à 12
p = &a //p pointe vers l'adresse de a
*p = 10 // a vaut maintenant 10

De manière totalement independante de mon exemple précédent:
int *ptr;
que représente ptr, comment on accède à l'adresse de *ptr, et l'adresse de ptr?
ptr n'est-ce pas l'adresse de *ptr?

[Jack]

que représente ptr

c'est une adresse

comment on accède à l'adresse de *ptr

c'est ptr

et l'adresse de ptr

&ptr

A+

[kwariz]

ptr est une variable de type pointeur sur int, ce qu'elle représente ? pour simplifier elle représente une adresse quelque part e n mémoire, et si on essaye de lire ce qu'il y a à cette adresse en utilisant ptr alors on va essayer d'y lire un int.
*ptr est la valeur stockée à l'adresse pointée par ptr, l'adresse de *ptr est la valeur de ptr : ptr=&(*ptr);
l'adresse de ptr est &ptr, &ptr sera une expression de type pointeur sur pointeur sur int (=int**)

[Zartan]

L'adresse de ptr c'est &ptr

Les adresses sont en lecture seule, donc &c = a + b est invalide, quels que soient a et b.

[deyni]

Merci.

C'est là que je ne comprends pas la décomposition de
int *p = malloc( sizeof(int) )
en
int* p;
p = malloc(sizeof( int )) /*On stocke à un adresse.

Alors que
int a = 1, b = 2;
int c = a + b; //on stocke dans une variable
Ca se décompose en
int a = 1, b = 2;
int c;
c = a + b;

[kwariz]

p=malloc(sizeof(int);

on ne stocke pas à une adresse mais on stocke une adresse.
malloc renvoie une adresse où il y aura suffisament de place pour stocker un int.

[deyni]

Excusez-moi, mais je suis très lent à comprendre.
Jack à écrit que ptr représente l'adresse de *ptr.
Lorsque on écrit:

ptr = malloc( sizeof( int ))

Est-ce que ptr représente l'adresse de *ptr? On srocke une adresse où?

[Zartan]

On stocke une adresse dans un pointeur, c'est pour ça que c'est plus facile à comprendre en écrivant int* ptr = malloc(sizeof(int)) ;

Ou alors on utilise un typedef int* intPtr; et après intPtr ptr = malloc(sizeof(int));

Ne vous inquiétez pas on en est tous passés par là, après vous n'aurez plus de mal à comprendre ça

typedef int (*a10ptoa5i[10])[5];
/* or */
typedef int a5i[5];
typedef a5i *atenptoa5i[10];

http://publications.gbdirect.co.uk/c...8/typedef.html

[deyni]

Merci.
Mais je ne comprends pas la décomposition de int *ptr.
Pour votre code, fait-il référence à mon message de la page 1(avec (tab[i])[30-1])?

Merci.

[kwariz]

Imagine la mémoire comme un immense livre, chaque page de ce livre est "une case mémoire" dans laquelle tu peux écrire quelque chose. Chaque page de ce livre possède un numéro de page. Pour pouvoir y écrire il faut demander au gestionnaire de livre de te donner un endroit où écrire. Tu lui demandes quelque chose du genre "je veux de la place pour écrire un entier", le gestionnaire sait qu'il te faut 4 pages pour écrire un entier, il regarde où il y a de la place (4 pages de libres) et te dit "ok écrit à partir de la page 12". Tu mets un marque page à la page 12 et tu y écris 10.
Le pointeur c'est le marque page, le gestionnaire c'est malloc, la page 12 c'est l'adresse (la valeur du marque page) et 10 est ce qui est écrit à cette adresse (sur la page pointée par le marque page).

int* ptr; // j'ai besoin d'un marque page pour repérer où je vais écrire un entier
ptr=malloc(sizeof(int); // je mets le marque page où le gestionnaire me dit qu'il y a de la place
*ptr=10; // j'écris 10 à la page marquée par le marque page

Tu comprends avec cette image ?

[deyni]

Bonjour, je vous remercie pour vos réponses.
Au risque d'abuser de votre patience et votre gentillesse, je vais tenter d'écourter mes réponses.

Je comprends effectivement l'image du livre.
mais ce qui me bloque c'est int* ptr = malloc(sizeof(int)) qui saute à mes yeux comme
int *ptr;
*ptr = malloc(sizeof(int));

Merci

[Jack]

int* ptr

C'est un problème de syntaxe. int* ptr veut dire déclaration d'une variable de type pointeur sur des entiers.
*ptr = ... veut dire qu'il s'agit maintenant d'affecter une VALEUR de type entier pour la stocker à l'emplacement mémoire désigné par ptr.

A+

[deyni]

Dernière question, désolé si j'abuse.
Est-ce que ces deux implementations sont correctes:

int *p;
*p = malloc( sizeof( int ) );

2eme)

int *p;
p = malloc( sizeof( int ) )

Merci et désolé.

edit: et produisent la même chose.

[kwariz]

Non :
malloc est une fonction dont le type de retour est un pointeur (void *)
int* p déclare un pointeur

p=malloc(...) est valide (un pointeur est assigné à une variable de type pointeur)

*p est un int, *p=malloc est invalide (un pointeur est assigné à une "variable" de type int)

[deyni]

Ok, merci de toutes vos réponses.

Elles m'aident bien. Je ne me ferai plus avoir avec le malloc.

merci de votre aide.