Discussion :

[gentil-personnage]

Bonjour,

j'aurais besoin d'un peut d'aide si vous aviez une solution se serait geniale.

voila concernant les listes chainées en langage c, sur lesquelles j'ai commencer a jeter un coup d'oeil, je trouve sa un peut casse pied de devoir reecrire chaque fonction de gestion (ajout/suppression de maillon, etc....) a chaque fois que la structure change (pour peut q'ont se rende compte un peut tard qu'il manque un champ.)

donc l'idée que j'ai eu c'est d'utilisé les fonction de stdarg.h pour pallié a mon probleme.
sauf que pas de bol sa le resout pas, j'arrive bien a faire une fonction qui prend "x" argument de type "f(x)" chacun mais concernant la strucure j'ai toujours le meme probleme, normale puisque mes pointeur de structure auquel j'attirbue les valeur en dépendent.

donc l'hypothese de base pour resoudre mon probleme, a condition que se soit possible, c'est d'implanté un algo qui passe au champs suivant de ma structure (dans l'ordre de la declaration initiale) a chaque detection d'une nouvelle valeur.

et une des premier soucis que je rencontre pour atteindre c'est objectif c'est de reussir a déclarer une structure de type tableau de champs.

donc voila, c'est ma première question.

en somme pour preciser peut etre un peut ma pensée, est il possible de creer une structure de type : par exemple

Code :

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

1
2
3
4
5
 
void tableau[3];
tableau[0]= int valeur;
tableau[1]=char* data1;
etc...

ainis de suite, tant que necessaire. en somme je pense (ou meme la je fais carrement des plan sur la commete)
qu'un tableau de pointeur sur mes variable de type en question serait adapté.

mais encore une fois pas de bol j'ai pas reussi a ecrire la struct correpondante.

si vous etes toujours là... merci de votre aide

[plxpy]

Bonjour gentil-personnage

désolé, ne le prends pas mal, mais ton post, c'est un véritable charabia ! Tu mélanges tout et n'importe quoi.

Les listes chainées : bien sur qu'il est impensable d'avoir/d'utiliser/d'écrire des listes qui ne traiteraient qu'un seul type de données. Généralement, les listes qu'on trouve dans diverses bibliothèques n'ont pas connaissance du type des données (je ne parle pas des pointeurs pour gérer le chaînage) qu'elles gèrent. Elles ont juste à connaître la taille de ces données. Jette un coup d'oeil aux types GList et GSList de Glib, la bibliothèque Gnome (par exemple).

Stdarg.h ne te sera d'aucun secours : c'est fait pour gérer les arguments des fonctions qui ont un nombre d'arguments variable (comme la série des printf par exemple). Pour tes listes chainées, oublie !

" ... c'est de reussir a déclarer une structure de type tableau de champs " : tu n'y arriveras pas, c'est impossible et ça n'a AUCUN sens ! Une structure (struct) c'est un type C en soi. Soit tu déclares un type structure, soit tu utilises des tableaux.

Quant à déclarer "void tableau[3];", réfléchis 2 secondes. Void est un type un peu spécial pour signifier que ça n'a pas vraiment de type (ou que ça peut être n'importe quel type). Un compilo ne peut rien allouer du tout pour "tableau", car il ne connait pas le type des éléments et encore moins leur taille.

Aussi, c'est très difficile de t'aider. Le seul conseil que je peux te donner c'est de bien mettre à plat ce que tu veux faire et, peut-être, de (re)voir les bases.

[gentil-personnage]

je vais essayer d'etre plus claire

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
 
typedef struct element element;
struct element
{
    int val;
    struct element *nxt;
}; 
typedef element* llist;
 
 
llist add_tete(llist liste, int val)
{
    /* On crée un nouvel élément */
    element* nouvelElement = malloc(sizeof(element));
 
    /* On assigne la valeur au nouvel élément */
    nouvelElement->val = val;
 
    /* On assigne l'adresse de l'élément suivant au nouvel élément */
    nouvelElement->nxt = liste;
 
    /* On retourne la nouvelle liste, i.e. le pointeur sur le premier élément */
    return nouvelElement;
}

exemle j'utilise se code basique pour faire un ajout de maillon en tete de liste
ce code est valable avec ma structure ci dessus.

si ma structure change (admetton que je rajoute un tableau de char a l'interieur par exemple), je doit reecrire ma fonction de chainage en conséquence, pareil si ma strucure change de nom, etc...

prenons le probleme dans l'autre sens, vers quelle solution dois je m'orienté pour creer des fonction de gestion de chaine (ajout en tete, en queue, suppression) sur lesquels le contenu, ou le nom de la strucure n'à aucune incidence (d'ou le void).

des fonction faites pour creer/gerer/supprimer des liste avec tout type de structure.

en gros pour faire simple est il possible de creer un tableau de pointeur sur divers elements.??

[Invité]

Pour les listes de "n'importe quoi" tu vas probablement devoir utiliser une struct comme

Code :

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

1
2
3
4
5
 
struct list_el {
  list_el *next;
  void *data;
}

Tu construis alors ta liste comme on fait dans les livres (en manipulant les pointeurs next) et quand tu as besoin des données, tu utilises le pointeur data, que tu transtypes en ce qu'il te faut.

Code :

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

1
2
 
((montype *)data)->le_champ_que_je_veux;

Maintenant, dans un tel système, la liste ne connait absolument pas le type de ses éléments, elle ne va donc pas pouvoir te dire en quoi transtyper data... Pour cela, soit tu ajoutes un champ type à list_el, soit tu fais une indirection dans data.

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
 
/*  avec champ type  */
 
struct list_el {
  list_el *next;
  int type; /* 1 = entiers, 2=texte etc... */
  void *data;
}
/* ici faut lire type pour savoir en quoi caste data */
 
 
/* avec indirection */
struct type_el {
    int type;
    void *data;
};
 
struct list_el {
  list_el *next;
  type_el elem;
}
/*la faut lire elem.type, puis caster elem.data */

Francois

[gl]

Maintenant, dans un tel système, la liste ne connait absolument pas le type de ses éléments, elle ne va donc pas pouvoir te dire en quoi transtyper data... Pour cela, soit tu ajoutes un champ type à list_el, soit tu fais une indirection dans data.

Soit laisser la connaissance du type dans le code appelant et n'avoir aucune information de type dans la liste (sauf peut être une information de taille pour pouvoir prendre et rendre la responsabilité de la gestion de la durée de vie et de la mémoire des données contenues dans la liste).

Dans le cas d'une liste uniforme (i.e. tous les éléments de la liste sont d'un même type), ce n'est pas hasardeux de supposer que le code appelant connaisse le type des données contenues dans la liste.
Et c'est beaucoup plus réutilisable que le mécanisme consistant à sauvegarder l'information du type dans la liste, surtout quand tu commences à stocker des structures ou des enum dans la liste (avec la sauvegarde du type dans la liste, l'utilisation de la liste pour stocker une nouvelle structure nécessite de rajouter un nouveau type).

[Invité]

Dans le cas d'une liste uniforme (i.e. tous les éléments de la liste sont d'un même type), ce n'est pas hasardeux de supposer que le code appelant connaisse le type des données contenues dans la liste.

Oui, mais ce cas là, c'est un peu le cas facile... La situation intéressante, à mon avis, c'est celui d'une liste où le type des éléments n'est connu qu'à l'exécution (par exemple, si on lit une donnée d'entrée qui peut etre du texte, des nombres, des tableaux, d'autres listes, n'importe quoi... C'est le vrai type de "liste hétérogène" (tous les autres ne sont que des raccourcis d'écriture).

Il va alors falloir fournir au code appelant un moyen de déterminer le type des données qu'il lit (ne serait ce que pour savoir leur taille). La méthode la plus "propre" à mon avis est l'indirection (on rajoute un pointeur "type" entre la liste et la donnée), mais ca ralentira un peu le code...

Gentil-personnage, si tu veux que les éléments de ta liste appartiennent à des types variables, mais que tu ne veux pas que la liste "le sache", tu ne peux échapper à un switch, ou une instruction similaire sur le type...

Francois

[gentil-personnage]

merci pour vos reponse mais je pense pas qu'elle vont resoudre mon problement puisque de toute facon, meme si j'utilisais un void *data je serais obligé de faire un switch prenant en parametre mon int "type" pour caster le pointeur sur data en conséquence.

ce qui ne ne fonctionne que dans les cas ou data reste un type de base. si data pointe sur une structure je devrais toujours acceder a mes champs par des pointeur de structure (struct->elem) et donc modifier mes fonction en conscéquence.

l'idée de départ etait de chercher a creer un tableau de pointeur, pointant vers struct->elem et donc vers la valeur contenue par elem. tout sa de facon a pouvoir y acceder par un indice.

mais bon, c'est vrai que c'est que plus j'y reflechis et moins je vois comment faire.

[gl]

merci pour vos reponse mais je pense pas qu'elle vont resoudre mon problement puisque de toute facon, meme si j'utilisais un void *data je serais obligé de faire un switch prenant en parametre mon int "type" pour caster le pointeur sur data en conséquence.

ce qui ne ne fonctionne que dans les cas ou data reste un type de base. si data pointe sur une structure je devrais toujours acceder a mes champs par des pointeur de structure (struct->elem) et donc modifier mes fonction en conscéquence.

Je pense qu'il y a une incompréhension.

Dans le code appelant, oui tu manipules tes données avec leur type. En même temps, tu n'as pas le choix si tu veux travailler sur tes données, il faut bien les connaître. Et cela n'a aucun impact sur la gestion de la liste.

Dans la gestion de la liste, non tu n'as plus besoin de connaître le type, donc tu n'as pas à caster le pointeur et tu n'as pas à accéder aux éléments de la structure. Tout le code de gestion de la liste ne manipules qu'une adresse générique (void*) et éventuellement une taille et une information de type (information qui n'est pas utilisé par la liste mais par le code appelant).
A partir de là la liste est bien générique, que tu stockes un int, un double ou une structure quelconque, le code de gestion de la liste est le même et n'a pas a être modifié en fonction de ce que tu stockes dedans.

[plxpy]

Code :

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

1
2
3
4
5
llist add_tete(llist liste, int val)
{
    /* On crée un nouvel élément */
    element* nouvelElement = malloc(sizeof(element));
    ...

Non, surtout pas. Tes fonctions de gestion de liste ne doivent pas connaître le type des éléments qu'elles gèrent si tu veux qu'elles soient génériques et qu'elles marchent pour toute nouvelle strcuture / type. Elles ne doivent connaître que la taille d'un élément de la liste et faire des copies "brutes" (memcpy) de ce qui est fourni.

Tes fonctions de gestion de listes doivent définir leur propre type (à priori une structure) qui inclut les données à gérer fournies par l'appelant, sans présager de leur type, et le système de chaînage que tu auras défini (un pointeur "next" et un pointeur "previous" par exemple).


Typiquement, un type element_liste

Code :

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

1
2
3
4
5
6
7
typedef struct _element_liste element_liste;
struct _element_liste
{
    void *data;   /* les donnees fournies qu'on NE veut PAS connaitre */
    element_liste *next;
    element_liste *previous
};

et un type liste qui peut ressembler à une structure

Code :

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

1
2
3
4
5
typedef struct {
    unsigned int size_elt;
    element_liste *first;   /* premier element de la liste, NULL au debut */
    element_liste *last;   /* dernier element de la liste, NULL au debut */
} liste;