IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

 C Discussion :

Traiter liste


Sujet :

C

Vue hybride

Message précédent Message précédent   Message suivant Message suivant
  1. #1
    Membre régulier
    Homme Profil pro
    Étudiant
    Inscrit en
    Décembre 2018
    Messages
    11
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Décembre 2018
    Messages : 11
    Par défaut Traiter liste
    Bonjour !

    je viens solliciter votre aide car j'ai quelques soucis a implementer des procedures pour traiter une SD.

    Voici le liste.h qui m'a été donné :
    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
     
    #ifndef listeSTAT
    #define listeSTAT
     
    #include "elementliste.h"
    #define DIMMAX 100 // taille maximale de la liste statique
    #define VIDE -1   // constante  pour indiquer que la liste est vide (par convention)
    struct liste {
        Elementliste Tabliste[DIMMAX];
        int Tete;
        int nbElt;
    };
     
    typedef struct liste liste;
    int nbEltList(liste lst); // nombre d'éléments
    void createList(liste *p); // renvoie une liste statique
    void addFrontList(liste *p, Elementliste e); // ajoute un élément devant
    void addTailList(liste *p, Elementliste e); // ajoute un élément derrière
    void delTailList(liste *p); // supprime l'élément de fin
    void delFrontList(liste *p); // supprime l'élément de tête
    void headList(liste p, Elementliste *e); // renvoie l'élément de tête
    void tailList(liste p, Elementliste *e); // renvoie l'élément de fin
    bool emptyList(liste p); // renvoie true si la pile est vide, false sinon
    bool fullList(liste p); // renvoie true si la pile est pleine, false sinon
    void dumpList(liste p,FILE *fp); // affiche le contenu de la liste
    void swapEltList(Elementliste *a,Elementliste *b); // échange deux éléments de la liste
    void bubbleSortList(liste *p); // trie la liste
    void pickEltList(liste l,Elementliste *e,int index); // renvoie l'élément n° index
    bool belongEltList(liste p,Elementliste e); // true si l'élément est dans la liste
    #endif
    le Elementliste.h
    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
     
    /* Pour éviter les inclusions multiples */
     
    #ifndef ELEMENTLISTE_H
    #define ELEMENTLISTE_H
     
    #include "global.h" // définit le type t_arc_p
     
    typedef t_arc_p Elementliste;
    void saisie_element(Elementliste *e);
    void copie_element(Elementliste *cible, Elementliste source);
    void afficher_element(Elementliste e,FILE *fp);
    bool cmp_elements(Elementliste e1,Elementliste e2);
     
    #endif
    j'ai beau faire des recherches, je n'arrive pas a comprendre comment traiter une SD qui a entre autres un tableau.
    Voici ce que j'ai fait :
    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
     
    #include <stdio.h>
    #include <stdbool.h>
    #include <string.h>
    #include "liste.h"
     
    int nbEltList(liste lst)
    {
    	return lst.nbElt;
    }
     
     
     
    void createList(liste *p)
    {
    	p->Tabiste = NULL;
    	p->Tete = 0;
    	p->nbElt = 0;
    }
     
     
     
    void addFrontList(liste *p, Elementliste e)
    {
    	liste *l = malloc(sizeof(liste));
    	if (p == NULL || l == NULL)
    	{
    		exit 1;
    	}
     
    }
    J'aimerai deja essayer de comprendre comment traiter une telle liste, avec un tab dans la sd
    merci pour votre aide

  2. #2
    Membre prolifique
    Avatar de Sve@r
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Février 2006
    Messages
    12 840
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Oise (Picardie)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : Février 2006
    Messages : 12 840
    Billets dans le blog
    1
    Par défaut
    Bonjour
    Citation Envoyé par Gayura Voir le message
    je viens solliciter votre aide car j'ai quelques soucis a implementer des procedures pour traiter une SD.

    j'ai beau faire des recherches, je n'arrive pas a comprendre comment traiter une SD
    Qu'entends-tu par "SD" ???

    Citation Envoyé par Gayura Voir le message
    qui a entre autres un tableau.
    Ben un tableau reste à la base défini par un nom. Ce nom est donc accessible. Donc imaginons que tu aies une variable "toto" de type "struct liste" ben de même que tu peux accéder à toto.Tete tu peux de la même manière accéder à toto.Tabliste. Sauf que comme "Tabliste" est un tableau tu peux aller un peu plus loin et accéder aussi à toto.Tabliste[x].

    Citation Envoyé par Gayura Voir le message
    Voici ce que j'ai fait :
    Code c : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    int nbEltList(liste lst)
    {
    	return lst.nbElt;
    }
    vaudrait mieux que la fonction travaille à partir d'une adresse car n'oublions pas qu'un paramètre passé à une fonction est recopié dans la fonction. Et, en dehors des soucis inhérents à la taille limitée de la pile (la zone mémoire utilisée pour les variables locales et les paramètres) il vaut mieux recopier une adresse de 8 octets qu'une structure de taille non maîtrisée.

    Code c : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    int nbEltList(liste *lst)
    {
    	return lst->nbElt;
    }

    Citation Envoyé par Gayura Voir le message
    Code c : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    void addFrontList(liste *p, Elementliste e)
    {
    	liste *l = malloc(sizeof(liste));
    	if (p == NULL || l == NULL)
    	{
    		exit 1;
    	}
    }
    Mouais. Mis à part qu'on évite de sortir d'une fonction via exit() et que ton allocation mémoire est faite pour rien si "p" est NULL et de toute façon perdue car non récupérée dans la fonction ; ce que t'as écrit n'est pas foncièrement mauvais. On sent le manque d'habitude mais pas le manque de volonté et c'est ce qui importe le plus.
    Mon Tutoriel sur la programmation «Python»
    Mon Tutoriel sur la programmation «Shell»
    Sinon il y en a pleins d'autres. N'oubliez pas non plus les différentes faq disponibles sur ce site
    Et on poste ses codes entre balises [code] et [/code]

  3. #3
    Membre régulier
    Homme Profil pro
    Étudiant
    Inscrit en
    Décembre 2018
    Messages
    11
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Décembre 2018
    Messages : 11
    Par défaut
    Merci pour ta reponse !

    Quand je dis "SD", je voulais dire Structure de Donnees.

    Concernant la fonction int nbEltList, je pensais aussi qu'un pointeur aurait été preferable en parametre mais le prototype de la fonction m'a deja ete donné dans le fichier .h auquel je n'ai pas le droit de modifier, le fichier .c par contre, ca vient de moi.

    Je remets donc le fichier liste.h (fichier donné non modifiable)
    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
    /* liste statique */
     
    #ifndef listeSTAT
    #define listeSTAT
     
    #include "elementliste.h"
    #define DIMMAX 100 // taille maximale de la liste statique
    #define VIDE -1   // constante  pour indiquer que la liste est vide (par convention)
     
    /* ----------------------------------
            Déclaration des types
       --------------------------------*/
     
    struct liste {
        Elementliste Tabliste[DIMMAX];
        int Tete;
        int nbElt;
    };
     
    typedef struct liste liste;
    int nbEltList(liste lst); // nombre d'éléments
    void createList(liste *p); // renvoie une liste statique
    void addFrontList(liste *p, Elementliste e); // ajoute un élément devant
    void addTailList(liste *p, Elementliste e); // ajoute un élément derrière
    void delTailList(liste *p); // supprime l'élément de fin
    void delFrontList(liste *p); // supprime l'élément de tête
    void headList(liste p, Elementliste *e); // renvoie l'élément de tête
    void tailList(liste p, Elementliste *e); // renvoie l'élément de fin
    bool emptyList(liste p); // renvoie true si la pile est vide, false sinon
    bool fullList(liste p); // renvoie true si la pile est pleine, false sinon
    void dumpList(liste p,FILE *fp); // affiche le contenu de la liste
    void swapEltList(Elementliste *a,Elementliste *b); // échange deux éléments de la liste
    void bubbleSortList(liste *p); // trie la liste
    void pickEltList(liste l,Elementliste *e,int index); // renvoie l'élément n° index
    bool belongEltList(liste p,Elementliste e); // true si l'élément est dans la liste
    #endif
    le fichier Elementliste.h (fichier donné non modifiable)
    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
    /* liste statique */
     
    /* Pour éviter les inclusions multiples */
     
    #ifndef ELEMENTLISTE_H
    #define ELEMENTLISTE_H
     
    #include "global.h" // définit le type t_arc_p
     
    typedef t_arc_p Elementliste;
    void saisie_element(Elementliste *e);
    void copie_element(Elementliste *cible, Elementliste source);
    void afficher_element(Elementliste e,FILE *fp);
    bool cmp_elements(Elementliste e1,Elementliste e2);
     
    #endif
    le fichier global.h (fichier donné non modifiable, qui contient la declaration de la SD s_arc_p, le type de Elementliste)
    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
    /// \file global.h
    /// \author X
    /// \date august 2018
    #ifndef GLOBAL_H
    #define GLOBAL_H
    #include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
    #include <stdbool.h>
     
    typedef struct s_arc_p{ /// arc pondéré
      int orig;
      int dest;
      int poids;
    } t_arc_p;
     
    #endif


    et enfin le fichier liste.c que j'ai creer :
    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
    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
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    #include <stdio.h>
    #include <stdbool.h>
    #include <string.h>
    #include "liste.h"
     
    // nombre d'éléments
    int nbEltList(liste lst)
    {
    	return lst.nbElt;
    }
     
    //----------------------------------------------------------------------------
     
    // renvoie une liste statique
    void createList(liste *p)
    {
    	p = malloc(sizeof(liste));
    	p->Tete = VIDE;
    	p->nbElt = VIDE;
    }
     
    //----------------------------------------------------------------------------
     
    // ajoute un élément devant
    void addFrontList(liste *p, Elementliste e)
    {
    	if (!fullList(p))
    	{
    		p->Tete = p->Tete+1;
    		p->Tabist[p->Tete] = e;
    		p->nbElt = p->nbElt+1;
    	}
    	else
            /* la liste est pleine : erreur */
    		fprintf(stderr,"liste pleine !\n");
    		exit(1);
     
    }
     
    //----------------------------------------------------------------------------
     
    // ajoute un élément derrière
    void addTailList(liste *p, Elementliste e)
    {
    	if (!fullList(p))
    	{
    		liste *l = malloc(sizeof(liste));
    		if (l == NULL)
    		{
    			exit(EXIT_FAILURE);
    		}
    		l->Tabist[0] = e;
    	// A remplir
     
    	}
    	else
            /* la liste est pleine : erreur */
    		fprintf(stderr,"liste pleine !\n");
    		exit(1);
    }
     
    //----------------------------------------------------------------------------
     
    // supprime l'élément de fin
    void delTailList(liste *p)
    {
    	// Pas fini
    }
     
    //----------------------------------------------------------------------------
     
    // supprime l'élément de tête
    void delFrontList(liste *p)
    {
    	// Pas fini
    }
     
    //----------------------------------------------------------------------------
     
    // renvoie l'élément de tête
    void headList(liste p, Elementliste *e)
    {
    	if (!emptyList(p))
    	{
    		*e = p.Tabist[Tete];
    	}
    	else
            /* la liste est vide : erreur */
    		fprintf(stderr,"liste vide !\n");
    		exit(1);
    }
     
    //----------------------------------------------------------------------------
     
    // renvoie l'élément de fin
    void tailList(liste p, Elementliste *e)
    {
    	if (!emptyList(p))
    	{
    		*e = p.Tabist[0];
    	}
    	else
            /* la liste est vide : erreur */
    		fprintf(stderr,"liste vide !\n");
    		exit(1);
    }
     
    //----------------------------------------------------------------------------
     
    // renvoie true si la pile est vide, false sinon
    bool emptyList(liste p)
    {
    	return (p.nbElt == VIDE);
    }
     
    //----------------------------------------------------------------------------
     
    // renvoie true si la pile est pleine, false sinon
    bool fullList(liste p)
    {
    	return (p.nbElt == DIMMAX);
    }
     
    //----------------------------------------------------------------------------
     
    // affiche le contenu de la liste
    void dumpList(liste p,FILE *fp)
    {
    	for (int i=0; i<=p.Tete; i++)
    	{
    		fputs(p->Tabist[i],fp);
    	}
    }
     
    //----------------------------------------------------------------------------
     
    // échange deux éléments de la liste
    void swapEltList(Elementliste *a,Elementliste *b)
    {
    	Elementliste *aux = a;
    	a = b;
    	b = aux;
    }
     
    //----------------------------------------------------------------------------
     
    // trie la liste
    void bubbleSortList(liste *p)
    {
    	liste *l = malloc(sizeof(liste));
    		if (l == NULL)
    		{
    			exit(EXIT_FAILURE);
    		}
     
    	// Pas fini
    }
     
    //----------------------------------------------------------------------------
     
    // renvoie l'élément n° index
    void pickEltList(liste l,Elementliste *e,int index)
    {
    	if (!emptyList(l) && index < l.nbElt)
    	{
    		*e = l.Tabist[index];
    	}
    	else
            /* la liste est vide ou ne contient pas l'element : erreur */
    		fprintf(stderr,"L'element n'est pas present dans la liste !\n");
    		exit(1);
    }
     
    //----------------------------------------------------------------------------
     
    // true si l'élément est dans la liste
    bool belongEltList(liste p,Elementliste e)
    {
    	int i = 0;
    	while (i < p.nbElt && p.Tabist[i] != e)
    	{			
    		i++;
    	}
    	return (p.Tabist[i] != e);
    }
    J'ai essayé d'avancer un maximum sur un peu toutes les fonctions, je bloque un peu la.
    j'ai aussi un peu du mal avec certains de leur commentaires (ceux de mes profs de projet) presents dans liste.h, par exemple "ajoute un élément devant" c'est a dire a la tete de la chaine ? et "ajoute un élément derriere" au premier indice donc ? ca me parait bizarre non ?
    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
    // ajoute un élément devant
    void addFrontList(liste *p, Elementliste e)
    {
    	if (!fullList(p))
    	{
    		p->Tete = p->Tete+1;
    		p->Tabist[p->Tete] = e;
    		p->nbElt = p->nbElt+1;
    	}
    	else
            /* la liste est pleine : erreur */
    		fprintf(stderr,"liste pleine !\n");
    		exit(1);
     
    }
     
    //----------------------------------------------------------------------------
     
    // ajoute un élément derrière
    void addTailList(liste *p, Elementliste e)
    {
    	if (!fullList(p))
    	{
    		liste *l = malloc(sizeof(liste));
    		if (l == NULL)
    		{
    			exit(EXIT_FAILURE);
    		}
    		l->Tabist[0] = e;
    	// A remplir
     
    	}
    	else
            /* la liste est pleine : erreur */
    		fprintf(stderr,"liste pleine !\n");
    		exit(1);
    }
    Pour ce qui est de la fonction "void headList(liste p, Elementliste *e)" j'ai comme commentaire "renvoie l'élément de tête", sachant qu'elle est de type void, il n'y a pas de return, du coup je stock l'element de tete dans e ?
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    // renvoie l'élément de tête
    void headList(liste p, Elementliste *e)
    {
    	if (!emptyList(p))
    	{
    		*e = p.Tabist[Tete];
    	}
    	else
            /* la liste est vide : erreur */
    		fprintf(stderr,"liste vide !\n");
    		exit(1);
    }

  4. #4
    Membre prolifique
    Avatar de Sve@r
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Février 2006
    Messages
    12 840
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Oise (Picardie)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : Février 2006
    Messages : 12 840
    Billets dans le blog
    1
    Par défaut
    Citation Envoyé par Gayura Voir le message
    Concernant la fonction int nbEltList, je pensais aussi qu'un pointeur aurait été preferable en parametre mais le prototype de la fonction m'a deja ete donné dans le fichier .h auquel je n'ai pas le droit de modifier
    Ok. Ca ne t'interdit toutefois pas de soumettre ma remarque à tes profs...

    Citation Envoyé par Gayura Voir le message
    et enfin le fichier liste.c que j'ai creer :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    // renvoie une liste statique
    void createList(liste *p)
    {
    	p = malloc(sizeof(liste));
    	p->Tete = VIDE;
    	p->nbElt = VIDE;
    }
    Ca c'est clair que cela ne peut absolument pas marcher. C'est lié au fait qu'une fonction ne reçoit qu'une copie de ce qu'on lui passe et que si on vent qu'elle modifie un truc, on doit alors lui passer l'adresse de ce truc qu'elle stocke dans un "truc étoile".
    Exemple: une fonction qui modifie un int
    Code c : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    void modifInt (int *p) {
    	(*p)=0;
    }
     
    int main() {
    	int var;
    	modifInt(&var);
    }

    Si on l'applique à un truc qui est une "liste étoile", alors ta fonction devra recevoir là aussi l'adresse de ce truc qu'elle stockera dans une "liste étoile étoile". Ca donnerait...
    Code c : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    // renvoie une liste statique
    void createList(liste **p) {
    	(*p) = malloc(sizeof(liste));
    	(*p)->Tete = VIDE;
    	(*p)->nbElt = VIDE;
    }
    Mais ça modifie la signature imposée de ta fonction.

    On peut aussi demander à la fonction de renvoyer le pointeur créé...
    Code c : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    // renvoie une liste statique
    liste *createList() {
    	liste *p;
    	p = malloc(sizeof(liste));
    	p->Tete = VIDE;
    	p->nbElt = VIDE;
    	return p;
    }
    Déjà la fonction correspond plus à son commentaire. Mais là encore on modifie sa signature.

    Je pense donc qu'il faut voir la "liste" comme un truc immuable et la fonction se charge simplement d'initialiser son contenu...
    Code c : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    // renvoie une liste statique
    void createList(liste *p) {
    	int i;
    	Elementliste *e;
    	for (i=0, e=p->Tabliste; i < DIMMAX; i++, e++)
    		memset(e, 0, sizeof(Elementliste));
    	// Toute cette boucle peut être remplacée par un simple memset(p->Tabliste, 0, DIMMAX * sizeof(Elementliste))
    	p->Tete=VIDE;
    	p->nbElt=VIDE;
    }

    ...et tu t'en sers de cette façon...
    Code c : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    int main() {
    	liste l;
    	createList(&l);
    }

    Citation Envoyé par Gayura Voir le message
    Code c : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    // échange deux éléments de la liste
    void swapEltList(Elementliste *a,Elementliste *b)
    {
    	Elementliste *aux = a;
    	a = b;
    	b = aux;
    }
    Même remarque: tu ne swappes que des copies, pas les originaux. Si tu ne peux pas modifier la signature, alors ta fonction devra swapper le contenu des pointés
    Code c : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    // échange deux éléments de la liste
    void swapEltList(Elementliste *a,Elementliste *b) {
    	Elementliste aux;
    	memcpy(&aux, a, sizeof(Elementliste));
    	memcpy(a, b, sizeof(Elementliste));
    	memcpy(b, &aux, sizeof(Elementliste)); 
    }

    Citation Envoyé par Gayura Voir le message
    Code c : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    // trie la liste
    void bubbleSortList(liste *p)
    {
    	liste *l = malloc(sizeof(liste));
    		if (l == NULL)
    		{
    			exit(EXIT_FAILURE);
    		}
     
    	// Pas fini
    }
    Pas besoin de malloc. Cette fonction est sensée recevoir une liste déjà remplie d'éléments stockés dans Tabliste et son rôle est de permuter ces éléments jusqu'à ce qu'ils soient rangés.

    Citation Envoyé par Gayura Voir le message
    J'ai essayé d'avancer un maximum sur un peu toutes les fonctions, je bloque un peu la.
    En fait, je pense que ce que t'as pas compris c'est que "liste" ce n'est pas la liste elle-même. C'est une structure qui habille la liste proprement dite en rajoutant des outils de contrôles et de gestion (nb d'éléments, indice du premier). Les éléments proprement dits sont, eux, stockés dans le tableau "Tabliste" et c'est le contenu de ce tableau que tu dois manipuler.

    Citation Envoyé par Gayura Voir le message
    j'ai aussi un peu du mal avec certains de leur commentaires (ceux de mes profs de projet) presents dans liste.h, par exemple "ajoute un élément devant" c'est a dire a la tete de la chaine ? et "ajoute un élément derriere" au premier indice donc ? ca me parait bizarre non ?
    Je dirais plutôt que "ajoute un élément derrière" c'est l'ajouter en fin de tableau...

    Citation Envoyé par Gayura Voir le message
    Pour ce qui est de la fonction "void headList(liste p, Elementliste *e)" j'ai comme commentaire "renvoie l'élément de tête", sachant qu'elle est de type void, il n'y a pas de return, du coup je stock l'element de tete dans e ?
    Je pense aussi. Tes profs ont une conception un peu bizarre. Parce que si je veux écrire une fonction qui envoie un truc, je le renvoie bêtement.
    Code c : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    int renvoieInt() {
    	return 123;
    }

    Charge à l'appelant de le récupérer s'il en a envie...
    Code c : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    int main() {
    	printf("%d\n", renvoieInt());
    }
    ...ou pas. Ca reste son choix.
    Code c : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    int main() {
    	renvoieInt();
    }

    Alors que si j'écris cette fonction avec la conception de tes profs...
    Code c : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    void renvoieInt(int *p) {
    	(*p)=123;
    }
    ...l'appelant est obligé de prévoir la zone où stocker le nombre renvoyé
    Code c : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    int main() {
    	int xxx;
    	renvoieInt(&xxx);
    }
    ...sans pouvoir ne serait-ce qu'utiliser simplement la fonction dans une expression. Bizarre quoi.
    Mon Tutoriel sur la programmation «Python»
    Mon Tutoriel sur la programmation «Shell»
    Sinon il y en a pleins d'autres. N'oubliez pas non plus les différentes faq disponibles sur ce site
    Et on poste ses codes entre balises [code] et [/code]

  5. #5
    Membre régulier
    Homme Profil pro
    Étudiant
    Inscrit en
    Décembre 2018
    Messages
    11
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Décembre 2018
    Messages : 11
    Par défaut
    J'ai une question ...
    Quand on a une fonction declaré comme suit :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    void copie_element(Elementliste *cible, Elementliste source)
    avec :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    typedef t_arc_p Elementliste;
    typedef struct s_arc_p{
      int orig;
      int dest;
      int poids;
    } t_arc_p;
    dans le corps de la fonction void copie_element, comment peut-on acceder aux differentes variables de cible et de source ?
    est ce que c'est par exemple source.orig et cible->orig ?
    Vous l'aurez compris, j'ai du mal avec les adresses et les pointeurs.


    Par ailleurs, pour ce cas precis, j'ai pensé utiliser la fonction memcpy, c'est bon ?
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    void copie_element(Elementliste *cible, Elementliste source)
    {
    	memcpy(cible,&source,sizeof(Elementliste));
    }
    Merci

  6. #6
    Membre prolifique
    Avatar de Sve@r
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Février 2006
    Messages
    12 840
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Oise (Picardie)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : Février 2006
    Messages : 12 840
    Billets dans le blog
    1
    Par défaut
    Citation Envoyé par Gayura Voir le message
    Quand on a une fonction declaré comme suit :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    void copie_element(Elementliste *cible, Elementliste source)
    avec :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    typedef t_arc_p Elementliste;
    typedef struct s_arc_p{
      int orig;
      int dest;
      int poids;
    } t_arc_p;
    dans le corps de la fonction void copie_element, comment peut-on acceder aux differentes variables de cible et de source ?
    est ce que c'est par exemple source.orig et cible->orig ?
    Exactement. Quand la variable qui référence la structure est un pointeur, on accède aux membres de la structure avec l'opérateur "flèche". Et si ta structure possède elle-même un pointeur, comme par exemple
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    typedef t_arc_p Elementliste;
    typedef struct s_arc_p{
      int orig;
      int dest;
      int poids;
      char *pt;
    } t_arc_p;
    alors tu accèdes au pointé de "pt" de cette façon: *source.pt et *cible->pt (l'étoile s'adresse à "pt" et non à "source" ou "cible").

    Citation Envoyé par Gayura Voir le message
    Vous l'aurez compris, j'ai du mal avec les adresses et les pointeurs.
    En fait l'explication est assez simple: "cible" est un pointeur. La logique voudrait que si on doit référencer "orig", il faut alors référencer "pointé de cible point orig" soit (*cible).orig. Le souci de cette écriture c'est que les parenthèses sont obligatoires à cause des priorités des opérateurs (point plus prioritaire que l'étoile). Pour alléger, les concepteurs ont alors créé l'opérateur "flèche" qui remplace cette écriture => cible->orig. Tu as cependant le droit d'utiliser l'écriture plus traditionnelle si tu préfères (mais avec un peu d'habitude ça viendra tout seul).

    Citation Envoyé par Gayura Voir le message
    Par ailleurs, pour ce cas precis, j'ai pensé utiliser la fonction memcpy, c'est bon ?
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    void copie_element(Elementliste *cible, Elementliste source)
    {
    	memcpy(cible,&source,sizeof(Elementliste));
    }
    C'est bon. memcpy() veut deux adresses. "cible" étant déjà l'adresse du truc devant recevoir la copie, c'est cette valeur qu'on passe directement à la fonction. En revanche "source" étant, elle, le truc à copier, on passe alors là son adresse à la fonction.
    Mon Tutoriel sur la programmation «Python»
    Mon Tutoriel sur la programmation «Shell»
    Sinon il y en a pleins d'autres. N'oubliez pas non plus les différentes faq disponibles sur ce site
    Et on poste ses codes entre balises [code] et [/code]

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. traiter un liste de date
    Par Stouille89 dans le forum PL/SQL
    Réponses: 1
    Dernier message: 05/08/2008, 16h28
  2. Liste de données à traiter
    Par julien2602 dans le forum Macros et VBA Excel
    Réponses: 16
    Dernier message: 18/12/2007, 16h15
  3. Réponses: 4
    Dernier message: 07/11/2007, 18h48
  4. Zone de liste : traiter le déplacement clavier
    Par titi29 dans le forum Access
    Réponses: 2
    Dernier message: 03/04/2006, 13h46

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo