Discussion :

[liraquikhalil]

Bonjour,
voila j'ai un petit problème : je dois insérer un élément dans une liste chaînée pour cela j'ai crée une méthode " inserer() ", cette méthode insère et tout mais le problème c'est qu'elle insère dans une copie de ma liste, problème de passage par référence/valeur je pense mais pourtant ma liste est un pointeur normalement ça doit passer par référence je ne comprend pas si vous pouvez m'aider ça sera sympa et merci beaucoup.

voici mon code :

Code :

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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
// structure du noeud
typedef struct  Noeud
{
       int val;
       struct Noeud * suiv;
}Noeud;
 
//Une Liste contient un enssemble de noeud
typedef Noeud* Liste;
 
//les methode qui seront utilisé pour gérer la liste
void afficher(Liste);
int inserer(Liste ,int);
 
 
int main()
{
    Liste l = NULL;
    inserer(l,21);
    inserer(l,22);
    inserer(l,23);
    afficher(l);
}
 
 
int inserer(Liste l,int a)
{
 
    Noeud* nouv = (Noeud*) malloc(sizeof(struct Noeud));
    nouv->val=a;
    nouv->suiv=l;
    l=nouv;
 
 
}
void afficher(Liste l)
{
    Noeud * parcours=l;
     while(parcours)
     {
        printf("\n- %d",parcours->val);
        parcours=parcours->suiv;
     }
 
}

[foetus]

Utilise la balise code signalée par le croisillon pour poster du code

Référence (ou alias) n'existe pas en C . Mais en C++, il faut utiliser l'esperluette Liste& l.

En C, l'esperluette sert à récupérer une adresse d'une variable

Code :

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

1
2
    int i = 9;
    int* p_i = &i;

[Neckara]

En C, l'esperluette sert à récupérer une adresse d'une variable

Code :

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

1
2
    int i = 9;
    int* p_i = &i;

En C++ aussi :

Code :

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

1
2
int & foo = i;// référence
&foo; // adresse

[Sve@r]

Bonjour,
voila j'ai un petit problème : je dois insérer un élément dans une liste chaînée pour cela j'ai crée une méthode " inserer() ", cette méthode insère et tout mais le problème c'est qu'elle insère dans une copie de ma liste, problème de passage par référence/valeur je pense mais pourtant ma liste est un pointeur normalement ça doit passer par référence je ne comprend pas si vous pouvez m'aider ça sera sympa et merci beaucoup.

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
int main()
{
    Liste l = NULL;
    inserer(l,21);
    inserer(l,22);
    inserer(l,23);
    afficher(l);
}
 
int inserer(Liste l,int a)
{
    Noeud* nouv = (Noeud*) malloc(sizeof(struct Noeud));
    nouv->val=a;
    nouv->suiv=l;
    l=nouv;
}

Bonjour

Dans ton raisonnement tu n'as oublié qu'une seule chose (la plus importante): si ta fonction "inserer()" modifie la liste (qui, comme tu le dis est un pointeur), alors elle ne peut le faire que si elle reçoit l'adresse de ce pointeur. Hé oui, même pour les pointeurs la règle reste la même: une fonction qui veut modifier un élément reçu doit recevoir l'adresse de cet élément.

Normalement (désolé suis dans un aéroport en attendant mon vol j'ai pas le temps de tester) ceci devrait fonctionner

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
int main()
{
    Liste l = NULL;
    inserer(&l,21);
    inserer(&l,22);
    inserer(&l,23);
    afficher(l);
}
 
int inserer(Liste *l,int a)
{
 
    Noeud* nouv = (Noeud*) malloc(sizeof(struct Noeud));
    nouv->val=a;
    nouv->suiv=(*l);
    (*l)=nouv;
}

Ce détail est anodin mais il va avoir quand-même des conséquences importante (j'espère) sur ta façon de coder. En effet, tu remarqueras que masquer l'étoile de "Noeud*" derrière un nouveau type "Liste" ne te fait rien gagner vu que t'es quand-même obligé d'utiliser un pointeur "Liste *" dans ta fonction "inserer()". Ca peut même être négatif dans la mesure où un développeur C a besoin de savoir ce qu'il manipule. Or toi tu caches le pointeur. Et au lieu de simplifier ton code ça le rend plus complexe à décrypter pour les autres (n'oublie pas qu'un code est 100 fois plus lu qu'écrit).
Donc arrête d'avoir peur des pointeurs et apprend à les manipuler.

Surtout que t'es pas obligé d'utiliser un "Noeud **" si ça devient trop diffiicle. Tu peux très bien créer un vrait type "Liste" qui encpasulera le noeud dans une structure dédiée. Te suffira alors de passer l'adresse de cette structure (un pointeur à une étoile) à ta fonction "inserer()". Et en plus c'est tout bénef si, ensuite, tu veux rajouter des éléments de gestion à ta liste (comme par exemple nombre d'éléments, adresse du dernier, etc). Tu le rajoutes dans la structure et toutes tes fonctions y auront immédiatement accès sans modif dans ta façon de leur passer des paramètres. Comme je dis souvent, on peut tenir une chemise par le col mais c'est mieux si on la met sur un cintre.

Dernier détail: nomme tes structures "s_xxx" et tes types "t_xxx" ça rendra ton code plus clair.

Donc exemple de ce que tu pourrais faire

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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
// structure du noeud
typedef struct s_noeud
{
       int val;
       struct s_noeud * suiv;
} t_noeud;
 
//Une Liste contient un enssemble de noeud
typedef struct {
    t_noeud *first;
} t_liste;
 
//les methode qui seront utilisé pour gérer la liste
void init(t_liste*)
void afficher(t_liste*);
int inserer(t_liste* ,int);
 
int main()
{
    t_liste l;
    init(&l);
    inserer(&l,21);
    inserer(&l,22);
    inserer(&l,23);
    afficher(&l);
}
 
void init(t_liste *l)
{
    l->first=NULL;
}
 
int inserer(t_liste *l, int a)
{
    t_noeud* nouv = malloc(sizeof(t_noeud));      // On ne caste pas un malloc
    nouv->val=a;
    nouv->suiv=l->first;
    l->first=nouv;
}
 
void afficher(t_liste *l)
{
     t_noeud *parcours=l->first;
     for (parcours=l->first; parcours != NULL; parcours=parcours->suiv)
        printf("\n- %d", parcours->val);
}

Absolument pas plus compliqué que ton premier code mais tellement plus évolutif...