liste chainée

Version imprimable

Voir 40 message(s) de cette discussion en une page

liste chainée

Bonjour,

Je doit réaliser une liste chainée, créer un nouveau maillon, l' insérer en fin de liste, afficher à l'écran la valeur du maillon , son adresse et l' adresse du maillon suivant.

Sachant que les types sont prédéfinis, et que je doit utiliser les arguments entrer au clavier lors de l'execution.

Voici mon code, plusieurs erreurs interviennent lors de la compilation :
Code:

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 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 #include <stdio.h> #include <stdlib.h> #include <math.h> #include <windows.h> #include <string.h> int Tvaleur; typedef struct Tmaillon{ Tvaleur valeur; Tmaillon * suivant; }Tmaillon; Tmaillon *Tliste; void nouveau_maillon(Tvaleur val) { Tmaillon* L; L=malloc(2*sizeof(int)); *L.suivant=0; *L.valeur=val; return &L; } void insertion_fin(Tliste* liste, Tmaillon * maillon) { Tmaillon * curseur; curseur = liste ; while (curseur->suivant)(!= 0) { curseur=curseur-> suivant; } curseur-> suivant =maillon; } void afficher_liste(Tliste liste) { int cpt; for(cpt=0;cpt=argc;cpt++) { printf(" %d....%d....%d...., *liste[cpt],(**liste).valeur,*liste[cpt+1]/n"); } int main(int argc,char**argv) { int*n int cpt; for(cpt=0;cpt=argc;cpt++) { n=nouveau_maillon(argv[cpt]); insertion_fin(@L,n); afficher_liste(L); } }

23/12/2005, 16h09
PRomu@ld

donne les erreurs que tu obtiens :
23/12/2005, 16h11
gege2061

Re: liste chainée

Bonjour,

Citation:

Envoyé par duranton

plusieurs erreurs interviennent lors de la compilation :

Et ? Peut être que si on avez les messages d'erreur ainsi que les lignes de codes correspondantes ça serait plus facile pour trouvé le(s) problème(s)

Citation:

Envoyé par duranton

Code:

insertion_fin(@L,n);

8O C'est du C ça ?
23/12/2005, 16h16
Nasky
Citation:
Code:

1 2 3 4 5 int Tvaleur; typedef struct Tmaillon{ Tvaleur valeur; Tmaillon * suivant; }Tmaillon;
T'as oublié un typedef quelque part? Tvaleur est une variable et non un type.
De plus, Tmaillon n'est pas encore connu lorsque tu déclares le pointeur "suivant". Il faut utiliser :

Code:

struct Tmaillon *suivant;

Nas'
23/12/2005, 16h30
duranton

Erreurs
Merci pour ces réponses presque immédiate.

Voici les différentes erreurs qui me sont donner leurs de la compilation :

parse error before `Tvaleur'
.c:10: warning: no semicolon at end of struct or union
c:12: parse error before `}'
c:12: warning: data definition has no type or storage class
c:14: parse error before `*'
c:14: warning: data definition has no type or storage class
c:16: parse error before `val'
c: In function `nouveau_maillon':
c:18: `L' undeclared (first use in this function)
c:18: (Each undeclared identifier is reported only once
c:18: for each function it appears in.)
.c:24: `val' undeclared (first use in this function)
c:26: warning: `return' with a value, in function returning void
c: At top level:
c:30: parse error before `*'
c: In function `insertion_fin':
c:33: `curseur' undeclared (first use in this function)
c:34: `liste' undeclared (first use in this function)
c:36: parse error before `!='
c: At top level:
c:43: parse error before `->'
c:47: parse error before `liste'
c: In function `afficher_liste':
c:52: `argc' undeclared (first use in this function)
c:58: parse error before `int'
c:66: `n' undeclared (first use in this function)
c:66: `argv' undeclared (first use in this function)
c:67: parse error before `@'
c:68: `L' undeclared (first use in this function)

Je débute en C et pour moi :
Code:

1 2 insertion_fin(@L,n);
veut dire que j'appelle la fonction insertion_fin et que je lui donne l'adresse de L et la valeur de n.
23/12/2005, 16h48
ggnore

je n'ai jamais vu de @ en c.

Tu fais une fonctione void qui renvoie une adresse :?

l'indentation aide a la lisibilité.

Tu déclares ton pointeur en globale, alors que ça n'est pas du tout nécessaire. Les globales, c'est laid. De temps en temps c'est nécessaire, mais ici, ça n'a aucun sens.

Tout ce qu'ont dit les précédents posteurs reste vrai.

Essaie de vérifier tes accolades : la fonction d'insertion n'a pas d'accolade fermante

Si tu ne mets pas à jour ton code et tes messages d'erreur, ne t'attend pas à ce que quelqu'un le fasse à ta place.

Je ne vois pas pourquoi dans main, L pourrait être connu.
23/12/2005, 17h51
CGi

Citation:

Code:

insertion_fin(@L,n);

veut dire que j'appelle la fonction insertion_fin et que je lui donne l'adresse de L et la valeur de n.

L'orérateur adresse de c'est &

Ce qui fait :

Code:

insertion_fin(&L,n);

Attention au test dans les boucle for

Citation:

for(cpt=0;cpt==argc;cpt++)

Dans la fonction printf le guillemet de fermeture de la chaine de caractère n'est pas au bon endroit.

......

nouveau code

J' ai essayer de reprendre mon code avec vos différentes remarques et j' ai tjs des erreurs, je pense qu'elles viennent essentiellement de la déclaration des types ou je sais pas bien comment mis prendre.

Voila le nouveau code :
Code:

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 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 #include <stdio.h> #include <stdlib.h> #include <math.h> #include <windows.h> #include <string.h> int Tvaleur; typedef struct Tmaillon{ struct Tmaillon * suivant; struct Tvaleur valeur; }Tmaillon; struct Tmaillon *Tliste; void nouveau_maillon(struct Tvaleur val) { Tmaillon* L; L=malloc(2*sizeof(int)); *L.suivant=0; *L.valeur=val; return L; } void insertion_fin(Tliste* liste, Tmaillon * maillon) { Tmaillon * curseur; curseur = liste ; while ((**liste).suivant=!0) { curseur=(**liste).suivant ; } (**liste).suivant=maillon; } void afficher_liste(Tliste liste) { int cpt; for(cpt=0;cpt=argc;cpt++) { printf(" %d....%d....%d...., *liste[cpt],(**liste).valeur,*liste[cpt+1]/n"); } } int main(int argc,char**argv) { int*n; int cpt; for(cpt=0;cpt==argc;cpt++) { n=nouveau_maillon(argv[cpt]); insertion_fin(Tliste,n); afficher_liste(Tliste); } }
et voici les erreurs :

c:11: field `valeur' has incomplete type
c:17: parameter `val' has incomplete type
c: In function `nouveau_maillon':
c:22: request for member `suivant' in something not a structure or union
c:24: request for member `valeur' in something not a structure or union
c:26: warning: `return' with a value, in function returning void
c: At top level:
c:30: parse error before `*'
c: In function `insertion_fin':
c:34: `liste' undeclared (first use in this function)
c:34: (Each undeclared identifier is reported only once
c:34: for each function it appears in.)
c:43: `maillon' undeclared (first use in this function)
c: At top level:
c:47: parse error before `liste'
c: In function `afficher_liste':
c:52: `argc' undeclared (first use in this function)
c: In function `main':
c:67: type of formal parameter 1 is incomplete
c:67: void value not ignored as it ought to be

Code:

1
2
3
4
5
6
 
int Tvaleur; 
typedef struct Tmaillon{ 
struct Tmaillon * suivant; 
struct Tvaleur valeur; 
}Tmaillon;

Pourquoi tu utilise une structure pour la valeur, ceci ne serait pas plus correct :

Code:

1
2
3
4
5
6
7
8
 
struct maillon
{
     int valeur;
     struct maillon * suivant;
};
 
typedef struct maillon maillon;

J'ai pas testé le code :

Code:

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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
#include <stdio.h>
#include <stdlib.h>
 
 
 
typedef struct _Tmaillon{
  int valeur;
  struct _Tmaillon * suivant;
}Tmaillon,*TListe;
 
 
TListe nouveau_maillon(int val)
{
  Tmaillon* L;
 
  L = (Tmaillon*)malloc(sizeof(Tmaillon));
  if(L == NULL) return NULL;
 
  L->valeur = val;
 
  L->suivant = NULL;
 
  return L;
}
 
 
void insertion_fin(TListe *liste, int valeur)
{
  if(*liste == NULL)
    {
      *liste = nouveau_maillon(valeur);  
    }
 
  while ((*liste) -> suivant != NULL)
    {
 
      *liste = (*liste) -> suivant ;
    }
 
  (*liste) -> suivant = nouveau_maillon(valeur);
}
 
 
void afficher_liste(TListe liste)
{
 
  while(liste != NULL)
    printf("%d ",liste -> valeur); 
 
}
 
 
int main(int argc,char**argv)
{
  TListe liste = NULL; 
  int cpt;
  int v;
 
  for(cpt=1; cpt<argc; cpt++)
    {
      v = atoi(argv[cpt]);
      insertion_fin(&liste,v);
      afficher_liste(liste);
 
    }
  return 0;
}

23/12/2005, 18h49
PRomu@ld

Citation:

J'ai pas testé le code :

Content de l'aprendre !!! :bravo: :bravo:

Non et puis plus sérieusement, si tu arrive à le faire marcher en l'état actuel et bien rebravo !!!
23/12/2005, 18h55
Gryzzly

Citation:

Envoyé par PRomu@ld

Citation:

J'ai pas testé le code :

Content de l'aprendre !!! :bravo: :bravo:

Non et puis plus sérieusement, si tu arrive à le faire marcher en l'état actuel et bien rebravo !!!

Je n'ai pas testé son code mais je l'ai modifié.

Citation:

Envoyé par Gryzzly

J'ai pas testé le code :

<...>

Jolie boucle. J'en ai plein l'écran...

Il est recommandé d'écrire des choses simples, de ne pas cacher les pointeurs, de ne pas confondre 'liste' et 'maillon' (list / node), d'éviter les pointeurs doubles, de regarder ce qu'on met dans ses boucles... bref d'arréter de programmer à la Shadok...

Code:

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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
 
#include <stdio.h>
#include <stdlib.h>
 
struct maillon
{
   int valeur;
   struct maillon * suivant;
};
 
struct liste
{
   struct maillon * tete;
};
 
 
static struct maillon *nouveau_maillon(int val)
{
   struct maillon* L = malloc (sizeof *L);
 
   if (L != NULL)
   {
      L->valeur = val;
      L->suivant = NULL;
   }
   return L;
}
 
static void insertion_fin(struct liste *liste, int valeur)
{
   if (liste->tete == NULL)
   {
      liste->tete = nouveau_maillon(valeur);
   }
   else
   {
      struct maillon *p = liste->tete;
      while ( p-> suivant != NULL)
      {
 
         p = p->suivant ;
      }
 
      p->suivant = nouveau_maillon(valeur);
   }
}
 
static void afficher_liste(struct liste const *liste)
{
   struct maillon *p = liste->tete;
 
   while (p != NULL)
   {
      printf("%d \n", p->valeur);
      p = p->suivant ;
   }
}
 
 
int main(int argc, char**argv)
{
   struct liste L = 
   {
      0
   };
   int cpt;
 
   for (cpt = 1; cpt < argc; cpt++)
   {
      int v = atoi(argv[cpt]);
      insertion_fin(&L, v);
   }
   afficher_liste(&L);
   return 0;
}

23/12/2005, 19h00
PRomu@ld

Ne le prend pas mal, c'est la fin de journée, je suis un peu euphorique.

En fait, il y a pas quelques soucis. regarde par exemple la fonction d'affichage, si elle arrive à afficher la liste c'est un joli tiur de magie.
23/12/2005, 19h04
Gryzzly
Citation:

Envoyé par PRomu@ld

Ne le prend pas mal, c'est la fin de journée, je suis un peu euphorique.

En fait, il y a pas quelques soucis. regarde par exemple la fonction d'affichage, si elle arrive à afficher la liste c'est un joli tiur de magie.

Exact:
Code:

1 2 3 4 5 6 7 8 9 void afficher_liste(TListe liste) { while(liste != NULL) { printf("%d ",liste -> valeur); liste = liste -> suivant; } }
23/12/2005, 19h11
granquet

je me pose une question stupide:
pour designer l'element suivant dans la structure, vaut mieux utiliser un struct maillon *maillon ou un void *maillon ?

j'utilise un void *maillon pour une liste chainée (des clients) d'un server tcp.

et donc je pourrit un peu le post en demandant:

c'est quoi le mieux? (tant qu'on oublie pas les cast en utilisant le void *)
23/12/2005, 19h44
Nasky

Dark_Ebola : le void* peut être utilisé pour les données 'utiles' pour pointer sur du int, char ou autre. Mais avec les listes chainées, pourquoi l'utiliser? On connait le type de la structure sur laquelle le pointeur pointe, donc ça ne sert à rien si ce n'est allourdir inutilement le code.

duranton : on aide volontier les gens mais il faut un minimum de connaissance avant de poster un code qui ne marche pas. Tu as du zapper les bases du C je pense. Je te recommande les cours de Developpez : http://c.developpez.com/cours/
Bon courage ;)

Nas'

petit problème

Tous d'abord merci pour les différentes remarques et conseils que vous m'avez donner,en effet j' ai d'énorme difficulté à programmer et votre cour ma bien aider à comprendre ce que je fesai.

Ensuite mon code n' a plus aucune erreurs lors de la compilation mais ne fonctionne pas lors que je le lance.

Je dois garder les types car ils sont donné dans l' énoncer.

Voici le code final :
Code:

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 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 #include <stdio.h> #include <stdlib.h> typedef int Tvaleur; typedef struct Tmaillon{ Tvaleur valeur; struct Tmaillon*suivant; }Tmaillon; typedef struct Tmaillon*Tliste; struct Tmaillon * nouveau_maillon(Tvaleur val) { struct Tmaillon*L; L=malloc(sizeof*L); (*L).suivant=NULL; (*L).valeur=val; return L; } void insertion_fin(Tliste *liste,struct Tmaillon*maillon) { struct Tmaillon*curseur; curseur = liste; while ((**liste).suivant!=NULL) { curseur=(**liste).suivant ; } (**liste).suivant=maillon; } void afficher_liste(Tliste liste) { printf(" %d",(*liste).valeur); liste=liste->suivant; } int main(int argc,char**argv) { Tliste liste; struct Tmaillon*n; int cpt; n=NULL; for(cpt=1;cpt<argc;cpt++) { n=nouveau_maillon(atoi(argv[cpt])); insertion_fin(&liste,n); } afficher_liste(liste); } [/cpp]

24/12/2005, 08h13
Trap D

Salut
Dans le main, Tliste liste; n'est pas initialisé à NULL.
24/12/2005, 09h16
PRomu@ld

Fais les choses simplement, et utilise un papier un crayon avant d'écrire ton code, il y a en effet quelques erreurs.

Par exemple lorsque tu affiches ta liste, tu passe les éléments un a un, c'est bien mais d'une part, quand t'arrête tu ? d'autre part, comment fais tu après l'éxécution de ta fonction pour réafficher une liste (ou tout simplement y accéder). En effet, tu ne garde aucun pointeur sur le début de ta liste.

Ensuite, si je ne m'abuse, ta liste n'est jamais initialisée : dans ta fonction d'ajout d'un élément, comment fais tu lorsque ta liste est vide (ce qui arrive dès le début)

Voir 40 message(s) de cette discussion en une page