Répondre à la discussion
Affichage des résultats 1 à 29 sur 29

Fonction malloc(langage C)



  1. #1
    deyni

    Fonction malloc(langage C)


    ------

    Bonjour,

    je voudrai savoir si les implementations suivantes sont vraies:

    Code:
    /*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.

    -----
    Deynid'oiseaux partout !! :rire:

  2. Publicité
  3. 📣 Nouveau projet éditorial de Futura
    🔥🧠 Le Mag Futura est lancé, découvrez notre 1er magazine papier

    Une belle revue de plus de 200 pages et 4 dossiers scientifiques pour tout comprendre à la science qui fera le futur. Nous avons besoin de vous 🙏 pour nous aider à le lancer...

    👉 Je découvre le projet

    Quatre questions à explorer en 2022 :
    → Quels mystères nous cache encore la Lune 🌙 ?
    → Pourra-t-on bientôt tout guérir grâce aux gènes 👩‍⚕️?
    → Comment nourrir le monde sans le détruire 🌍 ?
    → L’intelligence artificielle peut-elle devenir vraiment intelligente 🤖 ?
  4. #2
    Zartan

    Re : Fonction malloc(langage C)

    Bonjour,

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

    Code:
    	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).

  5. #3
    kwariz

    Re : Fonction malloc(langage C)

    Bonjour,

    Code:
    /*1ere implementation*/
    typedef struct _A{ 
       int x;
       int y;
    } A;
    
    A *ma = (A*) malloc(sizeof(A))
    Citation Envoyé par deyni Voir le message
    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 ...)


    Code:
    /*2eme implementation*/
    void f(int *n){
       n =(int*) malloc(sizeof(int)*30);
    }
    Citation Envoyé par deyni Voir le message
    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 ...
    Code:
    #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;                                                                                      
    }




    Code:
    /*3eme implementation*/
    int *p = (int *)malloc(sizeof(int));
    Citation Envoyé par deyni Voir le message
    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).

  6. #4
    kwariz

    Re : Fonction malloc(langage C)

    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 ...

  7. A voir en vidéo sur Futura
  8. #5
    PA5CAL

    Re : Fonction malloc(langage C)

    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...
    Dernière modification par PA5CAL ; 19/10/2012 à 21h51.

  9. #6
    deyni

    Re : Fonction malloc(langage C)

    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:
    Code:
    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:
    Code:
    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.
    Deynid'oiseaux partout !! :rire:

  10. Publicité
  11. #7
    Zartan

    Re : Fonction malloc(langage C)

    Citation Envoyé par deyni Voir le message
    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:
    Code:
    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:
    Code:
    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

  12. #8
    Zartan

    Re : Fonction malloc(langage C)

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

  13. #9
    kwariz

    Re : Fonction malloc(langage C)

    Citation Envoyé par deyni Voir le message
    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:
    Code:
    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:
    Code:
    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).
    Code:
    int *p;
    int* p;
    c'est pareil : on déclare une variable nommée p et de type int *=pointeur vers int
    Code:
    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
    Code:
    int*   p;
    le * ne s'applique qu'à p. C'est-à-dire que :
    Code:
    int*  p,q
    est équivalent à
    Code:
    int *p,  q;
    soit
    Code:
    int *p;
    int q;
    L'initialisation ne concerne que la variable :
    Code:
    int i=0;
    On déclare une variable i qu'on initialise avec la valeur 0. De la même manière :
    Code:
    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.
    Code:
    *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)

    Citation Envoyé par deyni Voir le message
    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 :
    Code:
    int *p=(int *)malloc(sizeof(int));
    il est plus simple d'utiliser
    Code:
    int *p=malloc(sizeof(*p));
    Mais bon ... souvent il vaut mieux suivre l'avis du prof ...

    Citation Envoyé par deyni Voir le message
    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.

  14. #10
    deyni

    Re : Fonction malloc(langage C)

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

    Truc qui me bloque:
    Code:
    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?
    Deynid'oiseaux partout !! :rire:

  15. #11
    kwariz

    Re : Fonction malloc(langage C)

    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 ?

  16. #12
    deyni

    Re : Fonction malloc(langage C)

    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:
    Code:
    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
    Deynid'oiseaux partout !! :rire:

  17. Publicité
  18. #13
    deyni

    Re : Fonction malloc(langage C)

    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
    Dernière modification par deyni ; 20/10/2012 à 15h01.
    Deynid'oiseaux partout !! :rire:

  19. #14
    kwariz

    Re : Fonction malloc(langage C)

    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 :
    Nom : ptr1.png
Affichages : 121
Taille : 10,4 Ko

  20. #15
    deyni

    Re : Fonction malloc(langage C)

    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?
    Deynid'oiseaux partout !! :rire:

  21. #16
    Jack
    Modérateur

    Re : Fonction malloc(langage C)

    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+

  22. #17
    kwariz

    Re : Fonction malloc(langage C)

    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**)

  23. #18
    Zartan

    Re : Fonction malloc(langage C)

    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.

  24. Publicité
  25. #19
    deyni

    Re : Fonction malloc(langage C)

    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;
    Deynid'oiseaux partout !! :rire:

  26. #20
    kwariz

    Re : Fonction malloc(langage C)

    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.

  27. #21
    deyni

    Re : Fonction malloc(langage C)

    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ù?
    Deynid'oiseaux partout !! :rire:

  28. #22
    Zartan

    Re : Fonction malloc(langage C)

    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

    Code:
    typedef int (*a10ptoa5i[10])[5];
    /* or */
    typedef int a5i[5];
    typedef a5i *atenptoa5i[10];
    http://publications.gbdirect.co.uk/c...8/typedef.html
    Dernière modification par Zartan ; 20/10/2012 à 16h10.

  29. #23
    deyni

    Re : Fonction malloc(langage C)

    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.
    Deynid'oiseaux partout !! :rire:

  30. #24
    kwariz

    Re : Fonction malloc(langage C)

    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 ?

  31. Publicité
  32. #25
    deyni

    Re : Fonction malloc(langage C)

    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
    Deynid'oiseaux partout !! :rire:

  33. #26
    Jack
    Modérateur

    Re : Fonction malloc(langage C)

    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+

  34. #27
    deyni

    Re : Fonction malloc(langage C)

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

    Code:
    int *p;
    *p = malloc( sizeof( int ) );
    2eme)
    Code:
    int *p;
    p = malloc( sizeof( int ) )
    Merci et désolé.

    edit: et produisent la même chose.
    Dernière modification par deyni ; 20/10/2012 à 16h47. Motif: Oubli.
    Deynid'oiseaux partout !! :rire:

  35. #28
    kwariz

    Re : Fonction malloc(langage C)

    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)

  36. #29
    deyni

    Re : Fonction malloc(langage C)

    Ok, merci de toutes vos réponses.

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

    merci de votre aide.
    Deynid'oiseaux partout !! :rire:

Discussions similaires

  1. Langage C problemes Header- fonction
    Par frequi1 dans le forum Programmation et langages, Algorithmique
    Réponses: 5
    Dernier message: 01/10/2012, 21h11
  2. Fonction KILL langage c
    Par SEIYA00 dans le forum Programmation et langages, Algorithmique
    Réponses: 3
    Dernier message: 10/02/2012, 19h20
  3. problème avec malloc en C
    Par olver62 dans le forum Logiciel - Software - Open Source
    Réponses: 5
    Dernier message: 06/03/2009, 19h33
  4. langage c++ fonction get
    Par Eunomia dans le forum Logiciel - Software - Open Source
    Réponses: 2
    Dernier message: 09/10/2007, 13h54
  5. Fonction attente en langage C
    Par DLEGALL dans le forum Logiciel - Software - Open Source
    Réponses: 3
    Dernier message: 26/03/2006, 17h14