30

:x

Les macros c'est bien, mais ça devient excessif là, non?

31

C'est de l'art embarrassed

(Ça doit être facile à débuguer grin)

32

J'imagine que ça dépend du niveau qu'on a dans le langage. Mais peut-être que si j'avais besoin d'autant de macros dans un langage donné, j'irais voir vers un langage de plus haut niveau pour lequel ces choses sont basiques.
avatar<<< Kernel Extremist©®™ >>>
Feel the power of (int16) !

33

Pen^2 (./31) :
C'est de l'art embarrassed
(Ça doit être facile à débuguer grin)
Oui ! Ca reste très simple à débugger
Folco (./32) :
J'imagine que ça dépend du niveau qu'on a dans le langage. Mais peut-être que si j'avais besoin d'autant de macros dans un langage donné, j'irais voir vers un langage de plus haut niveau pour lequel ces choses sont basiques.
Je sais, mais le python n'est pas assez performant ! embarrassed

34

Mouais, faudrait me rouler dessus pour qu'un code pareil passe ailleurs que dans un projet strictement perso ^^
avatarAll right. Keep doing whatever it is you think you're doing.
------------------------------------------
Besoin d'aide sur le site ? Essayez par ici :)

35

En fait, je ne vois pas en quoi ces macros te font gagner du temps par rapport à des typedefs directs :/

36

Et pourquoi pas du C++ tout simplement? Même le projet GNU permet le C++ pour ses projets de nos jours.
avatarMes news pour calculatrices TI: Ti-Gen
Mes projets PC pour calculatrices TI: TIGCC, CalcForge (CalcForgeLP, Emu-TIGCC)
Mes chans IRC: #tigcc et #inspired sur irc.freequest.net (UTF-8)

Liberté, Égalité, Fraternité

37

Zeph (./34) :
Mouais, faudrait me rouler dessus pour qu'un code pareil passe ailleurs que dans un projet strictement perso ^^
PpHd, lâche ce volant tout de suite embarrassed
avatarZeroblog

« Tout homme porte sur l'épaule gauche un singe et, sur l'épaule droite, un perroquet. » — Jean Cocteau
« Moi je cherche plus de logique non plus. C'est surement pour cela que j'apprécie les Ataris, ils sont aussi logiques que moi ! » — GT Turbo

38

Ca s'appelle BOOST (a peu de choses prêt)
avatarProud to be CAKE©®™


GCC4TI importe qui a problème en Autriche, pour l'UE plus et une encore de correspours nucléaire, ce n'est pas ytre d'instérier. L'état très même contraire, toujours reconstruire un pouvoir une choyer d'aucrée de compris le plus mite de genre, ce n'est pas moins)
Stalin est l'élection de la langie.

39

Zeph (./34) :
Mouais, faudrait me rouler dessus pour qu'un code pareil passe ailleurs que dans un projet strictement perso ^^
Oué, les INIT, CLEAR et compagnie sont quand même moches ! M'enfin certains codes que je vois en production sont largement plus sales!

Warpten (./35) :
En fait, je ne vois pas en quoi ces macros te font gagner du temps par rapport à des typedefs directs :/
Elles définissent aussi toutes les fonctions permettant d'utiliser ces structures.

Kevin Kofler (./36) :
Et pourquoi pas du C++ tout simplement? Même le projet GNU permet le C++ pour ses projets de nos jours.
Cite-moi une seule personne qui maitrise le C++ ? grin

40

Mouarf grin
Perso je me suis arrêté au C++11, la syntaxe devient ultra-bordélique avec le C++14 ^^
avatar<<< Kernel Extremist©®™ >>>
Feel the power of (int16) !

41

Tu n'es pas obligé d'utiliser toutes ces syntaxes tordues. Par exemple, les déclarations style C ne vont pas disparaître. Je ne connais sans doute pas l'intégralité du standard C++, mais je pense quand-même maîtriser les parties que j'utilise (et en particulier, connaître les pièges auxquels faire attention: genre, il est une très mauvaise idée de retourner une référence à une variable locale dans une fonction). Qt aide aussi à nous simplifier la vie, la STL est clairement le point faible du langage (et il lui manque aussi toute la partie graphique pour être un runtime complet, il faut lui rajouter une solution tierce comme wxWidgets pour avoir quelque chose de vaguement comparable à Qt).

Et franchement, PpHd, le C++ est plus maîtrisable que le bordel de macros C que tu proposes.
avatarMes news pour calculatrices TI: Ti-Gen
Mes projets PC pour calculatrices TI: TIGCC, CalcForge (CalcForgeLP, Emu-TIGCC)
Mes chans IRC: #tigcc et #inspired sur irc.freequest.net (UTF-8)

Liberté, Égalité, Fraternité

42

C'est bien de maîtriser ce que tu utilises, mais si tu ne travailles pas seul... Ou que tu reprends des projets... #Awesome#

43

Kevin Kofler (./41) :
il est une très mauvaise idée de retourner une référence à une variable locale dans une fonction).
rotfl Merci Captain Obvious !
Et franchement, PpHd, le C++ est plus maîtrisable que le bordel de macros C que tu proposes.
rotfl Le C++ maitrisable !
Pen^2 (./42) :
C'est bien de maîtriser ce que tu utilises, mais si tu ne travailles pas seul... Ou que tu reprends des projets... #Awesome#
Oué. Lorsque tu reprends un projet en C++, le mainteneur précédent n'a jamais utilisé la même sous-partie du langage C++ que celle que tu maitrises. Ah le paria ! vtff ... grin

44

grin
Et ça c'est dans le meilleur des cas. Souvent il ne maîtrisait pas réellement sa sous-partie cheeky

45

Médisance que tout cela!

http://i.imgur.com/9owO4OS.png

46

aazazrazazeaaeaeghgghhhh #vomi#
avatar<<< Kernel Extremist©®™ >>>
Feel the power of (int16) !

47

Là, c'est du code asynchrone avec de la synchronisation explicite, ce sera moche quel que soit le langage impératif utilisé. (C'est bien ça le problème avec les processeurs modernes avec de plus en plus de cores.)
avatarMes news pour calculatrices TI: Ti-Gen
Mes projets PC pour calculatrices TI: TIGCC, CalcForge (CalcForgeLP, Emu-TIGCC)
Mes chans IRC: #tigcc et #inspired sur irc.freequest.net (UTF-8)

Liberté, Égalité, Fraternité

48

Voilà. Alors qu'avec un bon vieux 68000, ça ne serait jamais arrivé !
avatar<<< Kernel Extremist©®™ >>>
Feel the power of (int16) !

49

De toute façon ASIO est probablement la partie de Boost la plus complexe, même quand on a un peu d'expérience avec.

50

Folco (./48) :
Voilà. Alors qu'avec un bon vieux 68000, ça ne serait jamais arrivé !
Tût tût tût. Tu oublies que le 68000 supporte le multiprocesseurs tongue
avatarZeroblog

« Tout homme porte sur l'épaule gauche un singe et, sur l'épaule droite, un perroquet. » — Jean Cocteau
« Moi je cherche plus de logique non plus. C'est surement pour cela que j'apprécie les Ataris, ils sont aussi logiques que moi ! » — GT Turbo

51

52

Oui, c'est même pour ça que l'instruction TAS existe.
avatarZeroblog

« Tout homme porte sur l'épaule gauche un singe et, sur l'épaule droite, un perroquet. » — Jean Cocteau
« Moi je cherche plus de logique non plus. C'est surement pour cela que j'apprécie les Ataris, ils sont aussi logiques que moi ! » — GT Turbo

53

tiens je savais pas qu'elle etait dispo dès le premier 68000!

54

Bah c'est qu'il est fortiche, le processeur chéri de Folco ^^
avatarZeroblog

« Tout homme porte sur l'épaule gauche un singe et, sur l'épaule droite, un perroquet. » — Jean Cocteau
« Moi je cherche plus de logique non plus. C'est surement pour cela que j'apprécie les Ataris, ils sont aussi logiques que moi ! » — GT Turbo

55

C'est une hérésie de faire du multiproc avec des 68000. Un 68000 seul a les épaules assez larges pour tout faire tout seul. Et tas peut très bien servir sur un seul proc, quand on utilise une variable volatile dans une interruption par exemple.
avatar<<< Kernel Extremist©®™ >>>
Feel the power of (int16) !

56

grin
avatarZeroblog

« Tout homme porte sur l'épaule gauche un singe et, sur l'épaule droite, un perroquet. » — Jean Cocteau
« Moi je cherche plus de logique non plus. C'est surement pour cela que j'apprécie les Ataris, ils sont aussi logiques que moi ! » — GT Turbo

57

58

./28: Mise à jour du code exemple (pour ceux que ça intéresse, c'est à dire pas grand monde embarrassed)
#include "m-tuple.h" #include "m-list.h" #include "m-array.h" // Définition d'une paire (string, mpz_t) et ses fonctions utilitaires TUPLE_DEF(pair, (key, string_t, STRING_OPLIST), (value, mpz_t, CLASSIC_OPLIST(mpz))) #define PAIR_OPLIST TUPLE_OPLIST(STRING_OPLIST, CLASSIC_OPLIST(mpz)) // Définition d'une liste de paire et ses fonctions utilitaires LIST_DEF(pair, pair_t, PAIR_OPLIST) // Définition d'un tableau de liste de paire et ses fonctions utilitaires ARRAY_DEF(list_pair, list_pair_t, LIST_OPLIST(PAIR_OPLIST)) int f(const array_list_pair_t org) { array_list_pair_t x; array_list_pair_init_set(x, org); int n = array_list_pair_size(x); array_list_pair_clear(x); return n; } int f2(const array_list_pair_t org) { array_list_pair_it_t it; int n = 0; for(array_list_pair_begin(it, org); !array_list_pair_end_p(it); array_list_pair_next(it)) { n += list_pair_size(*array_list_pair_cref(it)); } return n; }

59

Pour revenir au sujet, la macro REDUCE /* Map a macro to all given arguments and reduce all theses computation with another reduce macro */ /* Example: REDUCE(f, g, a, b, c) ==> g( f(a), g( f(b), f(c)) */ #define REDUCE_L0_INDIRECT() REDUCE_L0 #define REDUCE_L1(f, g, cur, a, ...) DELAY3(REDUCE_L0_INDIRECT) () (f, g, g(cur, f(a)), __VA_ARGS__) #define REDUCE_L0(f, g, cur, ...) IF_NARGS_EQ1(__VA_ARGS__)( g(cur, f(__VA_ARGS__)) , REDUCE_L1(f, g, cur, __VA_ARGS__)) #define REDUCE1(f, g, a, ...) EVAL(REDUCE_L0(f, g, f(a), __VA_ARGS__)) #define REDUCE(f, g, ...) IF_NARGS_EQ1(__VA_ARGS__)( f(__VA_ARGS__), REDUCE1(f, g, __VA_ARGS__))
Exemples: REDUCE(BOOL, AND, 0, 1, 2, 3, 4) REDUCE(BOOL, AND, 1, 2, 3, 4) cc -E ==> 0 1
Sinon petit retour d'expérience sur la récursivité décrite dans ./1. Cela marche bien avec une limitation: seul c'est ok, mais dès qu'il y a plusieurs récursivités qui s'appelle entre elles, ca ne marche plus.
Exemple (cf. ADD récursif et le RECUCE récursif déjà définit dans ce topic) : REDUCE(ID, ADD, 0, 1, 2, 3, 4) cc -E ==> EVAL(INC_INC_INC_INC_EVAL(ADD_L0 (INC_INC_INC_EVAL(3), 0))) Ça peut être réglé en ajustant les délais d'évaluations (REDUCE(ID, DELAY256(ADD), 0, 1, 2, 3, 4)), mais dans ce cas, le préprocesseur C devient lent.