Discussion :

[Sivenruot]

Bonjour à tous et toutes.

Alors voilà, j'aimerais faire une fonction qui me permettrait de créer une liste chaînée pouvant contenir au choix, des int, des char, des doubles etc...

Pour faire ça, j'avais pensé à une structure ressemblant à ça :

Code :

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

1
2
3
4
5
6
7
 
typedef struct s_chain
{
void *elem;
size_t elemsize;
struct s_chain *next;
}t_chain;

"elemsize" me sert à savoir quelle place prends l'élément en mémoire. Donc en gros, si je lui envoie "salut" il vaut 6 et si je lui envoi 5.5 il vaut 8.
Ensuite, pour la fonction créant un nouveau maillon, je pensais à quelque chose comme ça :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
t_chain *newlist(void *elem, size_t elemsize)
{
t_chain *new;
 
new = malloc(sizeof(t_chain));
new->elem = elem;
new->elemsize = elemsize;
new->next = NULL;
return (new);
}

Mais je vais avoir quelques soucis, le premier c'est que mon programme ne compilera pas puisque si j'envoie un char à ma fonction, elle me dira que ce n'est pas un "void *", donc il faudra que j'envoie "&variable" à ma fonction, mais du coup, si je modifie ma variable, je modifierais dans le même temps la variable de ma liste chaînée.

Donc il faut que je fasse un cast, et c'est mon deuxième problème, comment cast alors que je ne connais pas le type ? J'avais pensé à faire une fonction à part, qui ferrait un memalloc et un memcpy de mon "elem" grâce à mon "elemsize" mais je me demande si ça serait viable ?

De toute on en arrive au troisième problème, lorsque j'essaierais d'afficher mon elem, on me demandera "" quel type veut-tu afficher ?". Donc si je fais un :

Code :

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

printf("%d\n", begin->elem)

J'aurais une erreur me disant que printf attends un "int" et non un "void *".

Donc si vous avez des idée/conseils pour m'aider à faire progresser le shmilblik, je suis preneur. D'autant plus que j'ai grand mal encore à gérer les types "void" et que je suis sûr que ce genre d'exercice peut m'aider à mieux les appréhender.

Merci du temps passé à lire ce message jusqu'au bout, et du temps que vous prendrez pour m'aider.

PS : Désolé pour l'indentation, mais apparemment, ma touche tab ne fonctionne pas sur le forums .

[foetus]

Tout me semble normal et déjà discuter ici : il faut caster un void*.

Donc il faut faire une méthode pour chaque ajout: list_add_int, list_add_str, list_add_double, ...
Également pour l'affichage et tous les traitements.

Ensuite, il y a peut-être 2 façons à réfléchir:

• Au lieu de mettre la taille, faire une énumération avec le type et ainsi pouvoir faire une méthode générique avec un switch.
• Mettre plus de chose dans ta structure, comme des pointeurs de fonctions (spécifiques pour un type), des formats ("%s", "%d", même cela n'évite pas le cast), ...

[imperio]

Comme l'a dit foetus, stocke en castant en void*. Je précise un peu ce qu'il veut dire :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
typedef enum {
   INT,
   CHAR,
   FLOAT,
   ...
} type;
 
typedef struct {
   void *number;
   type  _type;
} number;

@foetus: je ne vois pas trop pourquoi tu veux faire des pointeurs sur fonction. Tu veux dire que quand le maillon est créé, on met un pointeur sur fonction directement dans une variable membre de la structure ? Ou tu penses à autre chose ?

[foetus]

@foetus: je ne vois pas trop pourquoi tu veux faire des pointeurs sur fonction. Tu veux dire que quand le maillon est créé, on met un pointeur sur fonction directement dans une variable membre de la structure ? Ou tu penses à autre chose ?

Un pointeur de fonctions dans la structure crée de la redondance niveau mémoire en plus d'avoir X octets en plus.
Mais, par exemple, cela peut être intéressant si tu veux faire différents traitements pour 1 même type: à réfléchir

Un petit exemple, qui n'est pas forcément propre en plus de ne pas être le code du siècle
Alors garder vos -1

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
#include<stdlib.h>
#include<stdio.h>
#include<string.h>
 
 
typedef struct s_chain t_chain;
 
typedef void (*PRINT) (t_chain*, char*);
typedef void (*DO) (t_chain*, unsigned short);
 
 
struct s_chain {
    void* elem;
    struct s_chain* next;
    PRINT print;
    DO do_something;
};
 
 
// Functions DO
void multiply(t_chain* t, unsigned short multiplier) {
    if ((t == NULL) || (t->elem == NULL)) { return; }
 
    printf("multiply: %d\n", multiplier);
 
    *((size_t*) t->elem) *= multiplier;
}
 
 
void my_pow(t_chain* t, unsigned short p) {
    if ((t == NULL) || (t->elem == NULL)) { return; }
 
    printf("pow: %d\n", p);
 
    size_t tmp = *((size_t*) t->elem);
 
    for (; p > 1; --p) {
        *((size_t*) t->elem) *= tmp;
    }
}
 
 
void reverse_str(t_chain* t, unsigned short useless) {
    if ((t == NULL) || (t->elem == NULL)) { return; }
 
    size_t len = strlen((char*) t->elem), pos = 0;
    char c = '\0';
 
    for(--len; pos < (len / 2); ++pos) {
        c = *((char*) t->elem + (len - pos));
        *((char*) t->elem + (len - pos)) = *((char*) t->elem + pos);
        *((char*) t->elem + pos) = c;
    }
}
 
 
// Functions PRINT
void print_int(t_chain* t, char* extra) {
    if ((t == NULL) || (t->elem == NULL)) { return; }
 
    printf("Int: %d%s\n", *((int*) t->elem), ((extra)? extra: ""));
}
 
 
void print_my_type(t_chain* t, char* extra) {
    if ((t == NULL) || (t->elem == NULL)) { return; }
 
    size_t data = *((int*) t->elem);
 
    printf("id: %d, char: %c%s\n", (data & (0XFFFFFF)), ((data >> 24) & 0XFF), ((extra)? extra: ""));
}
 
 
void print_str(t_chain* t, char* extra) {
    if ((t == NULL) || (t->elem == NULL)) { return; }
 
    printf("Str: %s%s\n", (char*) t->elem, ((extra)? extra: ""));
}
 
 
int main(void)
{
    struct s_chain* first_elt  = NULL;
    struct s_chain* second_elt = NULL;
    struct s_chain* third_elt  = NULL;
    struct s_chain* fourth_elt = NULL;
    struct s_chain* tmp  = NULL;
    size_t tmp_1 = 157, tmp_2 = 0, tmp_3 = 54;
    unsigned short count = 1;
    char* str = NULL;
 
//  First element
    first_elt = malloc( sizeof(t_chain) );
    if (first_elt == NULL) { return 0; }
 
    first_elt->elem = &tmp_1;
    first_elt->print = print_int;
    first_elt->do_something = multiply;
 
//  Second element
    second_elt = malloc( sizeof(t_chain) );
    if (second_elt == NULL) { free(first_elt); return 0; }
 
    asprintf(&str, "test str %d", tmp_1);
    second_elt->elem = str;
    second_elt->print = print_str;
    second_elt->do_something = reverse_str;
    first_elt->next = second_elt;
 
//  Third element
    third_elt = malloc( sizeof(t_chain) );
    if (third_elt == NULL) { free(first_elt); free(str); free(second_elt); return 0; }
 
    tmp_2 = 'm';
    tmp_2 = ((tmp_2 << 24) + 8542561);
    third_elt->elem = &tmp_2;
    third_elt->print = print_my_type;
    third_elt->do_something = NULL;
    second_elt->next = third_elt;
 
//  Fourth element
    fourth_elt = malloc( sizeof(t_chain) );
    if (fourth_elt == NULL) { free(first_elt); free(str); free(second_elt); free(third_elt); return 0; }
 
    fourth_elt->elem = &tmp_3;
    fourth_elt->print = print_int;
    fourth_elt->do_something = my_pow;
    fourth_elt->next  = NULL;
    third_elt->next = fourth_elt;
 
//  Process
    tmp = first_elt;
 
    do { // first exists
        printf("%sElement %d:\n", ((count != 1)? "\n": ""), count);
        count++;
 
        if (tmp->do_something) {
            tmp->print(tmp, " (before)");
            tmp->do_something(tmp, count);
            tmp->print(tmp, " (after)");
        } else {
            tmp->print(tmp, NULL);
        }
 
        tmp = tmp->next;
    } while(tmp != NULL);
 
//  Clean all
    free(first_elt);
    free(str);
    free(second_elt);
    free(third_elt);
    free(fourth_elt);
 
    return 0;
}

[Sivenruot]

Salut à tous !

Merci pour vos réponses, je me rends compte que j'avais oublié de préciser un impératif, c'est que je ne pouvais pas modifier ma struct

J'ai fini par réussir sans faire de cast (en tous les cas pas directement dans ma fonction) en utilisant les fonctions memalloc, memcpy et une fonction "memlen" pour connaître la taille mémoire de mon elem et pour pouvoir l'envoyer à memcpy.

Finalement cela donne ça :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
t_list *newlist(void const *elem, size_t elemsize)
{
     t_list *new;
     void *value;
     value = memalloc(elemsize);
     value = memcpy(value, elem, (memlen(elem)));
     new = malloc(sizeof(t_list));
     new->elem = value;
     new->elemsize = elemsize;
     new->next = NULL;
     return (new);
}

Voilà, ça fonctionne mais qu'en pensez vous ? Est-ce une solution "propre" (je débute en programmation et je fais souvent des choses qui fonctionnent mais pas très propre/adaptables) ?

PS : Comment fait-on pour copier son code avec l'indentation ? Le forum m'enlève systématiquement mes \t et impossible de les remettre à la main (obliger de rajouter des espaces )

[Médinoc]

memalloc, memlen? D'où viennent ces fonctions?

[Sivenruot]

memalloc, memlen? D'où viennent ces fonctions?

On peut trouvé memalloc dans la bibliothéque ldap.h

Code :

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

void *ldap_memalloc(ber_len_t s);

Lorsque je l'ai vu je me suis dit qu'elle irait bien dans ce que je voulais faire. Je l'ai tout de même recodé histoire de bien comprendre comment elle fonctionne.

Sa donne ça :

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
 
static void *memalloc(size_t size)
{
void *p;
size_t i;
i = 0;
p = (void*)malloc(sizeof(void*) * size);
if (p)
{
while (i != size)
((char*)p)[i++] = 0;
return (p);
}
return (NULL);
}

Et memlen c'est une fonction que j'ai faite pour pouvoir savoir si le "elem" de mon maillon est une string, un tableau. Où juste un int/char. Elle ressemble à ça :

Code :

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

1
2
3
4
5
6
7
8
9
 
static size_t memlen(const void *src)
{
size_t i;
i = 0;
while(((char*)src)[i] != '\0')
i++;
return (i + 1);
}

[foetus]

Donc memalloc est l'équivalent de calloc, et memlen de strlen (avec un passage ou un cast void*)

Et ldap -> OpenLDAP Lightweight Directory Access Protocol API (documentation linux), donc inutile si tu ne manipules pas des annuaires

Et en regardant ton code, je me suis aperçu que memcpy retourne la destination: cela m'interpelle

[Sivenruot]

Effectivement, mais pour le coup, je ne connaissais pas calloc

Et pour memcpy, je ne comprends pas ce que tu veux dire, tu parle de la fonction en elle-même où de mon utilisation de cette dernière ?

[foetus]

Et pour memcpy, je ne comprends pas ce que tu veux dire, tu parle de la fonction en elle-même où de mon utilisation de cette dernière ?

Tu as codé ceci:

Code :

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

value = memcpy(value, elem, (memlen(elem)));

Mais moi je fais toujours cela

Code :

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

memcpy(value, elem, (memlen(elem)));

... parce que 1) je pensais qu'elle retourne un code erreur (alors que pas du tout) 2) tu n'as pas besoin t'affecter le retour de la fonction memcpy dans ta variable (c'est déjà fait).

Et en regardant sur les Internets, ce sont certaines fonctions standards qui retournent un paramètre (pour memcpy c'est la destination) pour pouvoir chaîner les fonctions et ainsi faire du code compact (et même ne pas créer une variable locale)

Je me coucherai moins bête comme on dit

[Médinoc]

Ce memlen est tout sauf safe dès que tu sors des environnements de débogage (qui possèdent des octets "sentinelles" aux extrémités).

En Release, ou sur d'autres OS, tu peux avoir un buffer alloué non-suivi d'octets non-nuls, et donc tu peux déborder hors de ton buffer!
Possiblement sur une autre page. Ou pas. Comportement indéfini.