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

Discussion: Traiter liste

  1. #1
    Candidat au Club
    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
    Points : 2
    Points
    2

    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
    Expert éminent sénior
    Avatar de Sve@r
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    février 2006
    Messages
    7 196
    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 : 7 196
    Points : 20 500
    Points
    20 500
    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 «Shell»
    Sinon il y en a pleins d'autres. N'oubliez pas non plus les différentes faq disponibles sur ce site

  3. #3
    Candidat au Club
    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
    Points : 2
    Points
    2

    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
    Expert éminent sénior
    Avatar de Sve@r
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    février 2006
    Messages
    7 196
    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 : 7 196
    Points : 20 500
    Points
    20 500
    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 «Shell»
    Sinon il y en a pleins d'autres. N'oubliez pas non plus les différentes faq disponibles sur ce site

  5. #5
    Candidat au Club
    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
    Points : 2
    Points
    2

    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
    Expert éminent sénior
    Avatar de Sve@r
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    février 2006
    Messages
    7 196
    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 : 7 196
    Points : 20 500
    Points
    20 500
    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 «Shell»
    Sinon il y en a pleins d'autres. N'oubliez pas non plus les différentes faq disponibles sur ce site

  7. #7
    Candidat au Club
    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
    Points : 2
    Points
    2

    Par défaut

    Merci !
    J'arrive a voir plus clair !

    Une derniere chose
    je viens de finir les fonctions pour ajouter, supprimer trier et afficher, c'est tout bon aussi ? j'ai un doute pour celle d'afficher
    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
    // ajoute un élément devant
    void addFrontList(liste *p, Elementliste e)
    {
    	if (!fullList(p))
    	{
    		liste *l = malloc(sizeof(liste));
    		if (l == NULL)
    		{
    			exit(EXIT_FAILURE);
    		}
    		l->Tabliste[0] = e;
    		for (int i=1; i<=p.nbElt; i++)
    		{
    			l->Tabliste[i] = p->Tabliste[i-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))
    	{
    		p->Tete = p->Tete+1;
    		p->Tabliste[p->Tete] = e;
    		p->nbElt = p->nbElt+1;
    	}
    	else
            /* la liste est pleine : erreur */
    		fprintf(stderr,"liste pleine !\n");
    		exit(1);
    }
     
    //----------------------------------------------------------------------------
     
    // supprime l'élément de fin
    void delTailList(liste *p)
    {
    	if (!emptyList(p))
    	{
    		p->nbElt = p->nbElt-1;
    		memset(p->Tabliste[0], VIDE, DIMMAX * sizeof(Elementliste));
    		p->Tete = p->Tete-1;
    	}
    }
     
    //----------------------------------------------------------------------------
     
    // supprime l'élément de tête
    void delFrontList(liste *p)
    {
    	if (!emptyList(p))
    	{
    		p->nbElt = p->nbElt-1;
    		memset(p->Tabliste[Tete], VIDE, DIMMAX * sizeof(Elementliste));
    		p->Tete = p->Tete-1;
    	}
    }
     
    //----------------------------------------------------------------------------
     
    // trie la liste
    void bubbleSortList(liste *p)
    {
    	for (int i=0; i<p->nbElt-1; i++)
    	{
    		if (p->Tabliste[i] > p->Tabliste[i+1])
    		{
    			swapEltList(p->Tabliste[i],p->Tabliste[i+1]);
    		}
    	}
    }
     
    //----------------------------------------------------------------------------
     
    // affiche le contenu de la liste
    void dumpList(liste p,FILE *fp)
    {
    	for (int i=0; i<=p.Tete; i++)
    	{
    		fprintf(fp,p.Tabliste[i]);
    	}
    }

  8. #8
    Expert éminent sénior
    Avatar de Sve@r
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    février 2006
    Messages
    7 196
    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 : 7 196
    Points : 20 500
    Points
    20 500
    Billets dans le blog
    1

    Par défaut

    Citation Envoyé par Gayura Voir le message
    Une derniere chose
    A mon avis, non.

    Citation Envoyé par Gayura Voir le message
    je viens de finir les fonctions pour ajouter, supprimer trier et afficher, c'est tout bon aussi ? j'ai un doute pour celle d'afficher
    Ben je me suis arrêté à la première et malheureusement...

    Citation Envoyé par Gayura Voir le message
    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
    // ajoute un élément devant
    void addFrontList(liste *p, Elementliste e)
    {
    	if (!fullList(p))
    	{
    		liste *l = malloc(sizeof(liste));
    		if (l == NULL)
    		{
    			exit(EXIT_FAILURE);
    		}
    		l->Tabliste[0] = e;
    		for (int i=1; i<=p.nbElt; i++)		// Erreur, c'est "p->nbElt" qu'il faut écrire
    		{
    			l->Tabliste[i] = p->Tabliste[i-1];
    		}
    		
    		
    	}
    	else
            /* la liste est pleine : erreur */
    		fprintf(stderr,"liste pleine !\n");
    		exit(1);
    }
    Donc tu crées une nouvelle liste "l". Déjà on se demande pourquoi tu te sens obligé de l'allouer via malloc. Quand tu as besoin d'un int, tu n'écris pas int *i=malloc(sizeof int). Tu écris directement int i. Ben là c'est pareil. Tu aurais écrit liste l tu aurais eu ta liste.
    Donc continuons. Tu crées une nouvelle liste dans laquelle tu recopies les élements de la liste originelle. Et puis ? Plus rien. La fonction se termine et tout ce travail aussi. Le pointeur local "l" (variable auto) est libéré (mais pas la zone allouée !!!) et la liste originelle reste inchangée.

    Je te l'ai déjà dit: c'est le "Tabliste" de la liste originelle qu'il faut modifier. Effectivement insérer un élément avant obligera à tout décaler mais tout décaler dans le Tabliste de "p".

    Remarque l'idée est valable. Mais il faut au final recopier tout l->Tabliste dans p->Tabliste. De là on peut se dire "pourquoi utiliser la structure liste alors que son tableau suffit". De plus on peut un peu optimiser le code en mettant en premier le cas "échec" ce qui fait gagner une tabulation

    Ce qui peut donner
    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
    // ajoute un élément devant
    void addFrontList(liste *p, Elementliste e)
    {
    	if (fullList(p)) {
    		/* la liste est pleine : erreur */
    		fprintf(stderr,"liste pleine !\n");
    		exit(1);
    	}
    	Elementliste Tabliste[DIMMAX];
     
    	Tabliste[0] = e;
    	for (int i=0; i < p->nbElt; i++) {
    		Tabliste[i+1] = p->Tabliste[i];
    	}
     
    	for (int i=0; i < p->nbElt; i++) {
    		p->Tabliste[i] = Tabliste[i];
    	}
    	// ou bien memcpy(p->Tabliste, Tabliste, sizeof(Elementliste) * p->nbElt);
    	p->nbElt++;
    }
    Bon ce n'est pas ce que moi j'aurais écrit (moi je serais parti de la fin en copiant p->Tabliste[i - 1] dans p->Tabliste[i] ce qui ne fait au final qu'une copie au lieu de deux) mais c'était pour te montrer comment transcrire ton idée dans un code plus simple...

    PS: il existe la fonction memmove() qui permet de copier une zone dans une autre avec chevauchement (ce qui est le cas quand on copie un tableau dans lui-même). La fonction peut alors s'écrire
    Code c : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    // ajoute un élément devant
    void addFrontList(liste *p, Elementliste e)
    {
    	if (fullList(p)) {
    		/* la liste est pleine : erreur */
    		fprintf(stderr,"liste pleine !\n");
    		exit(1);
    	}
     
    	memmove(p->Tabliste + 1, p->Tabliste, sizeof(Elementliste) * p->nbElt);
    	p->Tabliste[0] = e;
    	p->nbElt++;
    }

    Remarque ce code est plus court car il utilise une fonction toute faite mais moins optimisé que ma méthode de copier p->Tabliste[i - 1] dans p->Tabliste[i] car moi, sachant que le recouvrement ne concerne qu'un seul élément, je peux programmer une copie "adaptée". Alors que la fonction memmove() étant programmée de façon "universelle" pour gérer tous les cas de recouvrement possibles, ne peut gérer tous ces cas qu'en passant par une zone intermédiaire ce qui lui fera faire deux copies là où moi je n'en fais qu'une. De plus je pense que ton prof voudrait te voir écrire l'algo que d'utiliser des trucs tout faits;
    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

  9. #9
    Candidat au Club
    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
    Points : 2
    Points
    2

    Par défaut

    C'est incroyable, je donne vraiment l'impression de ne pas relire mes codes.
    Ta methode est bien plus efficace, plus logique aussi d'ailleurs...

    J'ai donc revu les fonctions :
    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
    // ajoute un élément devant
    void addFrontList(liste *p, Elementliste e)
    {
    	if (fullList(p)) {
    		/* la liste est pleine : erreur */
    		fprintf(stderr,"liste pleine !\n");
    		exit(1);
    	}
    	for (int i=p->nbElt; i >= 1; i--)
    	{
    		p->Tabliste[i] = p->Tabliste[i-1];
    	}
    	p->Tabliste[0] = e;
    	p->nbElt++;
    	p->Tete++;
    }
     
    //----------------------------------------------------------------------------
     
    // ajoute un élément derrière
    void addTailList(liste *p, Elementliste e)
    {
    	if (fullList(p)) {
    		/* la liste est pleine : erreur */
    		fprintf(stderr,"liste pleine !\n");
    		exit(1);
    	}
    	p->nbElt = p->nbElt+1;
    	p->Tete = p->Tete+1;
    	p->Tabliste[p->nbElt-1] = e;
    }
     
    //----------------------------------------------------------------------------
     
    // supprime l'élément de fin
    void delTailList(liste *p)
    {
    	if (emptyList(p)) {
    		/* la liste est vide : erreur */
    		fprintf(stderr,"liste vide !\n");
    		exit(1);
    	}
    	for (int i=0; i < p->nbElt-1; i++)
    	{
    		p->Tabliste[i] = p->Tabliste[i+1];
    	}
    	memset(p->Tabliste[p->nbElt-1], VIDE, DIMMAX * sizeof(Elementliste));
    	p->nbElt--;
    	p->Tete--;
    }
     
    //----------------------------------------------------------------------------
     
    // supprime l'élément de tête
    void delFrontList(liste *p)
    {
    	if (emptyList(p)) {
    		/* la liste est vide : erreur */
    		fprintf(stderr,"liste vide !\n");
    		exit(1);
    	}
    	memset(p->Tabliste[p->nbElt-1], VIDE, DIMMAX * sizeof(Elementliste));
    	p->nbElt = p->nbElt-1;
    	p->Tete = p->Tete-1;
    }
     
    //----------------------------------------------------------------------------
     
    // trie la liste (tri a bulles)
    void bubbleSortList(liste *p)
    {
    	bool trier = false;
    	int taille = p->nbElt;
    	while (!trier)
    	{
    		trier = true;
    		for (int i=0; i < taille-1; i++)
    		{
    			if (p->Tabliste[i] > p->Tabliste[i+1])
    			{
    				swapEltList(p->Tabliste[i],p->Tabliste[i+1]);
    				trier = false;
    			}
    		}
    		taille--;
    	}
    }
     
    //----------------------------------------------------------------------------
     
    // affiche le contenu de la liste
    void dumpList(liste p,FILE *fp)
    {
    	for (int i=0; i<=p.nbElt; i++)
    	{
    		fprintf(fp,p.Tabliste[i]);
    	}
    }
    Pour la fonction bubbleSortList, j'ai hesité avec la methode recursive, j'ai finalement opté pour l'iterative.

    Bonne année au passage

  10. #10
    Expert éminent sénior
    Avatar de Sve@r
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    février 2006
    Messages
    7 196
    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 : 7 196
    Points : 20 500
    Points
    20 500
    Billets dans le blog
    1

    Par défaut

    Citation Envoyé par Gayura Voir le message
    J'ai donc revu les fonctions
    A vue de nez ça m'a l'air pas mal. Reste à passer le cap de la compilation. Juste que t'as inversé les codes de "delTailList" et "delFrontList".

    Citation Envoyé par Gayura Voir le message
    Pour la fonction bubbleSortList, j'ai hesité avehc la methode recursive, j'ai finalement opté pour l'iterative.
    C'est mieux. Le récursif c'est une "fausse" bonne idée. Effectivement c'est tentant de se dire "bah j'ai qu'à me rappeler moi-même avec moins de trucs et laisser le système gérer le merdier" mais on n'a pas idée à quel point c'est gourmand en ressources (justement parce que le système il a un vrai merdier à gérer quoi). Et si on commence la récursivité double avec par exemple Fibonacci là on explose en vol. La récursivité ne s'emploie que si on ne peut pas faire autrement (surtout qu'en plus je ne vois pas trop comment implémenter un bubble sort en récursif...)

    Citation Envoyé par Gayura Voir le message
    Bonne année au passage
    Eh ouais. Moi c'est dans 70mn
    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

  11. #11
    Candidat au Club
    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
    Points : 2
    Points
    2

    Par défaut

    Voila j'ai remodifié les fonctions, je remets juste les declarations des differents types pour ne plus a avoir besoin de monter tout en haut de la discussion
    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
    struct liste {
        Elementliste Tabliste[DIMMAX];
        int Tete;
        int nbElt;
    };
     
    typedef struct liste liste;
     
    typedef t_arc_p Elementliste;
     
    typedef struct s_arc_p{ /// arc pondéré
      int orig;
      int dest;
      int poids;
    } t_arc_p;
    je pensais que la fonction memset pouvait initialiser une case donnée d'un tableau, mais il n'en ait rien apperemment car c'est de type Elementliste qui est de type t_arc_p, j'ai donc changer la methode, j'ai fait une copie sur une variable auxiliaire pour memset le tableau en entier avant de refaire une copie sans l'element qui devait etre supprimé :
    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
    // supprime l'élément de fin
    void delTailList(liste *p)
    {
    	if (emptyList(*p)) {
    		/* la liste est vide : erreur */
    		fprintf(stderr,"liste vide !\n");
    		exit(1);
    	}
    	Elementliste aux[DIMMAX];
    	for (int i=0; i < p->nbElt-1; i++)
    	{
    		aux[i] = p->Tabliste[i];
    	}
    	memset(p->Tabliste,VIDE,sizeof(Elementliste) * p->nbElt);
    	p->nbElt--;
    	for (int i=0; i < p->nbElt; i++)
    	{
    		p->Tabliste[i] = aux[i];
    	}
    	p->Tete--;
    }
     
    //----------------------------------------------------------------------------
     
    // supprime l'élément de tête
    void delFrontList(liste *p)
    {
    	if (emptyList(*p)) {
    		/* la liste est vide : erreur */
    		fprintf(stderr,"liste vide !\n");
    		exit(1);
    	}
    	Elementliste aux[DIMMAX];
    	for (int i=0; i < p->nbElt-1; i++)
    	{
    		aux[i] = p->Tabliste[i+1];
    	}
    	memset(p->Tabliste,VIDE,sizeof(Elementliste) * p->nbElt);
    	p->nbElt--;
    	for (int i=0; i < p->nbElt; i++)
    	{
    		p->Tabliste[i] = aux[i];
    	}
    	p->Tete--;
    }
    Concernant la fonction affiché, j'accedais pas aux valeurs int du tableau qui est de type Elementliste, maintenant ca compile :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    // affiche le contenu de la liste
    void dumpList(liste p,FILE *fp)
    {
    	for (int i=0; i<p.nbElt; i++)
    	{
    		fprintf(fp,p.Tabliste[i].orig);
    		fprintf(fp,p.Tabliste[i].dest);
    		fprintf(fp,p.Tabliste[i].poids);
    		fprintf(fp,"\n");
    	}
    }
    Concernant la fonction bubblesortList, lors de l'appel de la fonction swap, ca n'envoyait pas les adresses, maintenant ca le fait, je pense.
    Par contre ca ne compile, je sais que c'est a cause de la condition, il suffit juste d'acceder aux vraies valeurs int, c'est juste que je ne comprends pas le but de la fonction (si les 3 valeurs int de la case i doivent etre > aux 3 valeurs de la case i+1 ou pas), j'en parlerai a mon prof.
    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
    // é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));
    }
     
    //----------------------------------------------------------------------------
     
    // trie la liste (tri a bulles)
    void bubbleSortList(liste *p)
    {
    	bool trier = false;
    	int taille = p->nbElt;
    	while (!trier)
    	{
    		trier = true;
    		for (int i=0; i < taille-1; i++)
    		{
    			if (p->Tabliste[i] > p->Tabliste[i+1]) //Condition pas complete
    			{
    				swapEltList(&p->Tabliste[i],&p->Tabliste[i+1]);
    				trier = false;
    			}
    		}
    		taille--;
    	}
    }
    Par la meme occasion, j'ai modifié la fonction qui renvoyait true si l'element etait present, le probleme etait que je comparais pas les vraies valeurs int mais seulement deux types Elementliste, maintenant ca compile :
    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
    // true si l'élément est dans la liste
    bool belongEltList(liste p,Elementliste e)
    {
    	bool trouver = false;
    	int i = 0;
     
    	while (!trouver && i < p.nbElt)
    	{
    		if ((p.Tabliste[i].orig == e.orig) && (p.Tabliste[i].dest == e.dest) && (p.Tabliste[i].poids == e.poids))
    		{
    			trouver = true;
    		}
    		i++;
    	}
    	return (trouver);
    }

  12. #12
    Expert éminent sénior
    Avatar de Sve@r
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    février 2006
    Messages
    7 196
    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 : 7 196
    Points : 20 500
    Points
    20 500
    Billets dans le blog
    1

    Par défaut

    Citation Envoyé par Gayura Voir le message
    je pensais que la fonction memset pouvait initialiser une case donnée d'un tableau, mais il n'en est rien apperemment
    memset() remplit n octets avec la valeur de ton choix. Etant donné que 1) les cases d'un tableau se suivent en mémoire et 2) les éléments d'une structure aussi tu peux tout à fait utiliser cette fonction pour taper avec précision à un endroit précis d'un tableau quelconque et y compris de structures.

    Citation Envoyé par Gayura Voir le message
    j'ai fait une copie sur une variable auxiliaire pour memset le tableau en entier avant de refaire une copie sans l'element qui devait etre supprimé
    ben...

    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
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    // supprime l'élément de fin
    void delTailList(liste *p)
    {
    	if (emptyList(*p)) {
    		/* la liste est vide : erreur */
    		fprintf(stderr,"liste vide !\n");
    		exit(1);
    	}
    	Elementliste aux[DIMMAX];
    	for (int i=0; i < p->nbElt-1; i++)
    	{
    		aux[i] = p->Tabliste[i];
    	}
    	memset(p->Tabliste,VIDE,sizeof(Elementliste) * p->nbElt);
    	p->nbElt--;
    	for (int i=0; i < p->nbElt; i++)
    	{
    		p->Tabliste[i] = aux[i];
    	}
    	p->Tete--;
    }
    Code c : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    // supprime l'élément de fin
    void delTailList(liste *p) {
    	if (emptyList(*p)) {
    		/* la liste est vide : erreur */
    		fprintf(stderr,"liste vide !\n");
    		exit(1);
    	}
    	p->nbElt--;
    	p->Tete--;
    	memset(p->Tabliste + p->nbElt, VIDE, sizeof(Elementliste));
    }


    Accessoirement je ne pige pas trop le rôle du membre "Tete" vu que la tête d'un tableau est toujours à 0...

    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
    12
    13
    14
    15
    16
    // true si l'élément est dans la liste
    bool belongEltList(liste p,Elementliste e)
    {
    	bool trouver = false;
    	int i = 0;
     
    	while (!trouver && i < p.nbElt)
    	{
    		if ((p.Tabliste[i].orig == e.orig) && (p.Tabliste[i].dest == e.dest) && (p.Tabliste[i].poids == e.poids))
    		{
    			trouver = true;
    		}
    		i++;
    	}
    	return (trouver);
    }
    Code c : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    // true si l'élément est dans la liste
    bool belongEltList(liste p,Elementliste e) {
    	Elementliste *pt
    	int i;
     
    	for (i=0, pt=p.Tabliste; i < p.nbElt; i++, pt++) {
    		if (pt->orig == e.orig  && pt->dest == e.dest && pt->poids == e.poids)		// Peut-être que "memcmp" peut se rendre utile ici...
    			return true;
    	}
    	return false;
    }
    Plus court, plus lisible et plus rapide du fait de l'utilisation du pointeur de balayage et de la suppression de variable "trouver" dans l'évaluation de la boucle. Mais certains puristes n'apprécient pas les "return" sauvages
    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

  13. #13
    Candidat au Club
    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
    Points : 2
    Points
    2

    Par défaut

    Desolé de répondre aussi tard.

    Je pense que la c'est bon, je viens de tester tout le fichier avec un main "fait maison", ca marche sans probleme.
    Je te remercie vraiment ! J'ai compris pas mal de choses grace a toi !

    Bonne journée.

+ 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