Discussion :

[Reverse_]

Bonjour,
j'ai jeté un petit coup d’œil sur le tutoriel, Programmation générique en C, et, voulant coder une petit bibliothèque personnel de fonction que j'utilise souvent, je me suis demandé si ça vaut le coup de le faire de manière générique ?
J'aimerai avoir des avis sur ce sujet. (Des effets négatifs ? est-ce déconseillé ? Si oui, tout le temps ? Dans certains cas ?).

Si possible, j'aimerai avoir des explications, pas un simple : "c'est bien", "c'est pas bien".

Je vous remercies d'avoir pris le temps de lire ce post,
De peut-être y répondre,
Cordialement, Reverse_

[Sve@r]

Bonjour

Si je comprends bien, tu as créé des fonctions qui traitent (par exemple) de l'int et tu voudrais les transformer pour leur faire traiter du n'importe quoi. Un peu comme qsort (qui peut trier réellement un tableau de "n'importe quoi").

Aucun langage de programmation n'est parfait. Il n'existe même pas un langage meilleur que d'autres ; il n'y a que des langages en adéquation ou peu conseillés pour des buts particuliers. (Herbert Mayer).

Ainsi personne ne pourra te dire "c'est bien" ou "c'est pas bien" parce que ça dépend fondamentalement de tes besoins. Par exemple un tournevis cruciforme est super bien quand on veut serrer des vis cruciformes. En fait n'importe qui te dirra qu'il n'y a pas mieux. Mais essaye de serrer/desserrer des vis simples et là ça ne va plus.

Donc si c'est pour une fonction dont la généricité est naturellement implicite (par exemple la moyenne des valeurs d'un tableau peut se faire aussi bien sur des ints que des floats) c'est bien. Ou si tu as naturellement besoin de gérer des données disparates là encore c'est bien. Sinon ben ça devient un simple exercice de style qui peut te faire progresser en prog mais qui sera inutile du point de vue besoins opérationnels.

[o_Nejma]

Bonjour,

Je suis d’accord avec Sve@r et veux ajouter que les programmes génériques ont généralement l’aire intéressant quand il s’agit de grand projet où l’on a souvent besoin d’utiliser des drivers, des couches interfaçant l’application avec son hardware, ou aussi un ensemble d’opérations qui servent à un grand nombre de projets (qu’on appelle souvent des services ou utilités) … Dans ce cas-là une ‘‘library’’ pourra être plus intéressante que développer à chaque fois ces interfaces. Il ne faut toutefois nier l’étape du portage qui est parfois impérative à chaque fois la cible change (processeur ou µControlleur…).

Meryem

[yetimothee]

Salut,

la programmation générique, c'est un vaste domaine. Il faut déjà se mettre d'accord sur ce que tu entends par là.

Si tu te réfères au tuto http://rperrot.developpez.com/articles/c/genericite/, tu parles de généricité à base de void*, ce qui est à mon sens du générique logiciel, et pas de compilation. Tu vas perdre beaucoup de perfs.
Par exemple, pour le swap, si tu utilises une macro, c'est plus rapide : tu n'as pas besoin de déréférencer ton pointeur, ce qui peut être coûteux (surtout si tu déréférence quelque chose qui n'est pas en cache).

J'aurais fait :

Code :

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

1
2
3
4
5
6
7
 
#define swap(x, y) \
{
    typeof(x) _tmp = x;
    x = y;
    y = _tmp;
}

Tu peux aller très loin en programmation générique à base de macro en C :

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
 
#define LIST_TYPE(_name, _type) \
typedef struct _name {          \
    _type value;                \
    struct _name* next;         \
} _name##_t;
 
#define LIST_NEW(_name, _type) \
static struct _name* _name##_new(_type v) { \
    struct _name* l = malloc(sizeof(struct _name)); \
    l->value = v; \
    l->next = NULL; \
    return l; \
}
 
#define LIST_CLEAR(_name, _type) \
static void _name##_clear(struct _name *l) { \
    while (l) { \
        struct _name *next = l->next; \
        _name##_delete(l); \
        l = next; \
    } \
}
 
#define LIST_APPENDV(_name, _type) \
static void _name##_appendv(struct _name** list, _type v) { \
    while (*list) { \
        list = &(*list)->next; \
    } \
    *list = _name##_new(v); \
}
 
#define LIST_LEN(_name, _type) \
static int _name##_len(const struct _name* list) { \
    int len = 0; \
    while (list) { \
        len++; \
        list = list->next; \
    } \
    return len; \
}
 
#define LIST(_name, _type) \
LIST_TYPE(_name, _type) \
LIST_NEW(_name, _type) \
LIST_CLEAR(_name, _type) \
LIST_APPENDV(_name, _type) \
LIST_LEN(_name, _type)
 
LIST(float_list, float)
LIST(int_list, int)
 
int main(void) {
    int_list_t* ilist = int_list_new(1);
    int_list_appendv(&ilist, 2);
    int_list_appendv(&ilist, 3);
 
    float_list_t* flist = float_list_new(1.0f);
    float_list_appendv(&flist, 2.0f);
    float_list_appendv(&flist, 3.0f);
 
    printf("%d\n", int_list_len(ilist));    // 3
    printf("%d\n", float_list_len(flist)); // 3
 
    float_list_clear(flist);
    int_list_clear(ilist);
 
    return 0;
}

Bref, là tu n'as aucun inconvénient par rapport à écrire les fonctions en dur, si ce n'est la difficulté de débugging (suffit de pas faire de bug ahah !). Et comme tu vas faire une plétore de listes de tout type dans ta vie, ce type de généricité c'est quasi indispensable. L'exemple que je donne est très simple, mais tu peux aller beaucoup plus loin, en créant tes propres allocateurs, pour ne plus dépendre forcément de malloc, en créant des itérateurs pour écrire des fonctions s'appliquant à plusieurs structures de données différentes, etc.

En C t'as assez peu de limites de ce coté là, c'est juste hyper lourd à écrire ces grosses macros en langage délicieusement archaïque.

Après, il est inutile de tout rendre générique. Juste ce qui va être utilisé très souvent tout en ayant des types bien différents.

Moi si je m'amuses à faire du générique en C c'est que je n'aime guère le C++ et ce qu'il implique, mais je te conseil néanmoins d'aller faire un tour du coté des templates, c'est tellement plus agréable !

[Reverse_]

Bonjour,

tout d'abord veuillez m'excusez pour mon absence, et donc, mon temps à répondre.
Merci pour vos réponses très intéressantes. Je vais aussi allez voir la généricité au niveau des macros.

Justement j'avais fais un peu de C++, pour voir, et je n'avais pas trop accrochés à la POO, et j'avais vue qu'il y avait les templates, et c'est en cherchant un équivalent en C que j'étais tombé sur la généricité à base de void*.

Encore merci à tous pour vos réponses !