Discussion :

[Trunks]

Bonsoir,

je veux faire une liste chainée en C. Pour celà j'ai défini 2 structures :

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
typedef struct s_list_item		t_list_item;
 
struct												s_list_item
{
   int												val;
   t_list_item								*back;
   t_list_item								*front;
};
 
 
 
typedef struct s_list		t_list;
 
struct												s_list
{
   t_list_item								*p_list_item;
   int												pos;
   int												size;
};

ensuite j'ai 2 fonctions display :

Code :

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

1
2
3
void display(t_list *);
 
void display(t_list_item *);

Le problème, c'est qu'il y a un conflit, en C les surcharge de fonctions ne sont pas permis. J'aimerais savoir comment résoudre ce problème sans pour autant changer le nom de la fonction, car quand je vais inclure la struct list dans une autre, il faudra que je regarde quel nom de fonction je n'ai pas droit de donner, ... enfin vous voyez ce que je veux dire.

Voilà merci de me proposer une alternative pour ce problème.

Trunks

[Skyounet]

J'aurai bien une petite idée mais je sais pas si c'est très propre.

Donc mon idée et de passer la taille de la structure en parametre, les 2 tailles etant différentes, et un void* en premier argument.

Et dans les fonctions tu compares la taille à la premiere structure, si c'est la meme tu cast le void en le bon type.

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
 
struct s {
       int a;
       char b;
       char *c;
};
 
struct s2 {
       int a;
       int b;
};
 
void test(void *a, int t) {
     struct s *b;
     struct s2 *c;
     if(t == sizeof(struct s)) 
         b = a;
     else
         c = a;   
}
 
int main(void) {
    struct s a = { 4, 'a' };
    struct s2 b = { 5, 6 };
    test(&a, sizeof a);
    test(&b, sizeof b);
    return 0;
}

Vérifie quand meme que les tailles sont différentes, sinon je vois pas comment faire.

[edit]
Arf il me semble que les tailles sont identiques
1ere : int + pointeur * 2 = 12
2eme : pointeur + int * 2 = 12
Bien evidemment si int = 4 octets sur ton archi
[/edit]

[fearyourself]

[edit]
Arf il me semble que les tailles sont identiques
1ere : int + pointeur * 2 = 12
2eme : pointeur + int * 2 = 12
Bien evidemment si int = 4 octets sur ton archi
[/edit]

Sur certaines architectures, c'est le cas...

Jc

[Skyounet]

[edit]
Arf il me semble que les tailles sont identiques
1ere : int + pointeur * 2 = 12
2eme : pointeur + int * 2 = 12
Bien evidemment si int = 4 octets sur ton archi
[/edit]

Sur certaines architectures, c'est le cas...

Jc

Ah je suis pas le seul a pas dormir.
Ben sur les archi les plus courantes c'est le cas donc c'est plus que probable que sur son archi ce soit aussi 4 octet.

[Pouic]

Sinon, tu peux utiliser le principe des unions : tu définis un type union global, qui regroupe tes structures.
Par contre, cela impose de changer un peu celles-ci, de manière à introduire un attribut discriminant (plus un enum pour faire propre):

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
/* un enum */
enum mon_enum {
    S1;
    S2
}
 
typedef struct s_list_item      t_list_item; 
 
struct                                    s_list_item 
{ 
   enum mon_enum              type; /* nouvelle entree */
   int                                    val; 
   t_list_item                        *back; 
   t_list_item                        *front; 
}; 
 
 
 
typedef struct s_list      t_list; 
 
struct                                    s_list 
{ 
   enum mon_enum              type; /* nouvelle entree */
   t_list_item                        *p_list_item; 
   int                                    pos; 
   int                                    size; 
};
 
 
/* union */
union mon_union {
    enum mon_enum              type; /* nouvelle entree */
    struct s_list                       s1;
    struct  s_lis_item               s2;
}

Et qui s'utilise ainsi, dans tes 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
void display(union mon_union U){
struct s_list var;
 
switch (U.type){
    case S1:{
        var = (s_list)U;
        break;
    }
    default : /*  erreur */
}
}
<....>
 
void display(union mon_union U){
struct                                    s_list_item var;
switch (U.type){
    case S2:{
        var = (s_list_item)U;
        break;
    }
    default : /*  erreur */
}
}

L'idée est d'utiliser le champ commun des struct ET de l'union pour caster comme il convient dans les fonctions. Et ca te permet eventuellement, en regroupant les fonctions, d'avoir un seul prototype...

Bon, j'espère etre clair, parceque repondre a 5h du mat', je ne sais pas si j'explique encore bien... (Et je ne parle pas des inévitables erreurs de syntaxe...)

Mais en tout cas, l'idée est là

<hs>
Bon, vais me coucher, moi, maintenant...
</hs>

[Trunks]

merci pour ces idéezs. Ah le C++ est quand meme plus pratique