Langage C liste chainée Fermé

Question

Bonjour, 

j'aborde maintenant la notion de structure en C.

je souhaite établir une liste chainée. 
je souhaiterais si possible que vous m'aidiez. j'ai des difficultés au niveau de l'allocation avec le malloc. aussi je sais pas comment stocker par exemple un entier dans ma liste.

je vous donne un exemple.

struct maliste
{
   int nbre;
   struct maliste *psuivant;
}
  struct maliste *tete ;  

main()

/* ajout*/
  
 struct maliste *nouveau ; /* pour une nouvelle cellule */
nouveau = (struct maliste*)malloc(sizeof(struct maliste); /* jai besoin dexplications  pour l allocation */


je veux mettre 5 par exemple dans une cellule. comment je fais ?

jai une proposition, corrigez moi.

maliste.nbre = 5 ;


merci de me corriger.




Configuration: Windows 7 / Safari 536.11

Hxyp · Answer

Bonjour, 
malloc retourne l'adresse d'un bloc de bytes nouvellement alloués, on lui donne en paramètre le nombre de bytes que l'on veut en mémoire, si la mémoire est suffisante pour qu'un bloc de bytes de la taille indiquée puisse être "réquisitionné" alors malloc retourne l'adresse du début de ce bloc de bytes qui est maintenant réservé pour le programme qui à fait cette acquisition, sans quoi (si la mémoire ne le permet pas) malloc retourne pour adresse NULL. 
Donc malloc retourne l'adresse du début du bloc de bytes, et c'est à vous de mettre cette adresse dans le type de pointeur qu'il vous convient le mieux (aucune restriction là dessus donc pas besoin de cast). 
Car le type dans lequel vous allez mettre cette adresse déterminera la façon dont le bloc de bytes alloué sera traité à partir du pointeur (sera traité en fonction du type). 
Donc rien ne vous empêche de faire : 

int *ptr; 
ptr = malloc(sizeof(char)*16); 

en admettant que sizeof(int) = 4 , ptr peut être utilisé pour stocker 4 int dans ce bloc mémoire. Comme vous pouvez aussi faire : 
char *ptr; 
ptr = malloc(sizeof(int)*16); 
Et là en admettant que sizeof(int)=4bytes, le type char faisant 1, il est alors possible de stocker 4*16 char dans ce bloc mémoire. Voyez malloc ne fait que bêtement réserver en mémoire le nombre de bytes qu'on veut, et retourne l'adresse de départ de ce bloc, seul le type (plus précisément sa taille) qui récupère l'adresse déterminera la façon dont ils seront utilisés (les bytes alloués). 

Tout ça rend possible l'utilisation de plusieurs types de pointeurs différents pour administrer un même bloc, etc. 

Pour en venir au problème principal : 

struct maliste  
{  
 int nbre;  
 struct maliste *psuivant;  
}; 
struct maliste *tete; 

int main(void){ 
    struct maliste *nouveau; 
    tete=NULL; /* on met le ptr à NULL */ 
    nouveau = malloc(sizeof(struct maliste)); /* "struct maliste" est un type */ 
    nouveau->nbre = 5; /* on accède au membre par un pointeur donc -> */ 
    nouveau->psuivant=tete; /* ajoute par empilement */ 
    tete=nouveau; /* tete prend alors le nouveau */ 
    /* etc, ne pas oublier de free les adresses résultantes d'un malloc */ 
    return 0; 
}

Utilisateur anonyme · Answer

Je vais continuer la réponse de Hxyp pour donner quelques précisions :

On l'a compris, malloc sert à alouer de l'espace mémoire, la taille dépend de ce que tu met en argument dans la fonction malloc.

Exemple :
- En mémoire, un int fait 4 bytes alors qu'un char n'en fait qu'un seul.

Quand tu créer une structure, tu crée un type, alors un 

"nouveau = malloc(sizeof(struct maliste));"

alouera autant d'espace mémoire qu'il en faut pour stocker toutes les données présente dans la structure. Ainsi ton int nbre est aloué dans l'espace mémoire automatiquement (c'est pas la seule chose automatique en C ? xD) et tu peux l'utiliser.

Pour ce qui est d'accéder aux données dans chaque maillon de la liste chainée, il te faut en faite accéder aux infos d'une structure : faire comme ceci :

Mettons notre liste chainée se nomme liste , elle possèdent un int nommé nbr et un pointeur sur le prochain maillon nommé next:

struct liste
{
   int nbre;
   struct *next;
}

Si on utilise l'adresse de la liste (un pointeur), alors on utilise une flèche :

struct liste *new;

new = malloc(sizeof(new));
new->nbre = 0 /*nbre est mis a zero*/;
new->next = NULL /* le maillon suivant est mis a null*/;

Sinon, un point :

struct liste new;
new.nbre = 0 /*nbr est mis a zero*/
new.next = NULL /* le maillon suivant est mis a null */

versaille21 · Answer

bsr !
merci pour vos réponses qui m'ont beaucoup aidé.  

HunterX7 j'ai une question. 

est ce qu'il est possible de crée la variable new comme vous l'avez fait " new = malloc(sizeof(new)); "   ?


voici ma proposition :

struct liste *new; 

new = malloc(sizeof(struct liste));

Langage C liste chainée

3 réponses

Discussions similaires