Discussion :

[systemofaxav]

Bonjour,

je me demandais s'il est possible de créer des pointeurs vers les opérateurs > et < en C/C++ (inférieur à et supérieur à) ?

Attention, je ne parle pas des opérateurs d'une classe qui sont faciles à surcharger, mais des opérateurs de base... (d'ou mon post dans la catégorie C )

J'ai essayé un bool (*p)(double, double) sans succès...

Une idée ?

Xav

[Pouet_forever]

Tu pourrais éclaircir la question stp

Ce que tu as fait en faisant bool (*p)(double, double) est un pointeur de fonction

[diogene]

je me demandais s'il est possible de créer des pointeurs vers les opérateurs > et <

Ceci n'a pas de sens en C.

Attention, je ne parle pas des opérateurs d'une classe qui sont faciles à surcharger, mais des opérateurs de base

On ne peut faire aucune surcharge d'opérateurs en C

[systemofaxav]

Mmmmh, le C vient de s'effondrer dans mon estime...

Je détaille mon problème au cas ou ça vous donnerait des idées:

J'ai une fonction qui réalise plusieurs comparaisons en fonction d'un paramètre type :
Si type=1 toutes les comparaisons sont des <
Si type=2 toutes les comparaisons sont des >

Et je n'ai pas envie d'écrire une fonction par cas, ni de tester le paramète type avant chaque comparaison !

Du coup je pense à utiliser une variable (un pointeur ?), référencant l'operateur à utiliser et remplacer tout appel à un des deux opérateur par le contenu de cette variable...

Pour l'instant j'ai créé deux fonctions sup et inf qui encapsulent respectivement > et < mais je trouve ça ridicule...

il doit bien exister une solution élégante en C ??

[diogene]

Elégante, je ne vois pas trop.
Peux être une possibilité dans le genre :

Code :

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

1
2
3
4
5
6
7
8
int inf(void * a, void * b)  { return *(int*)a < *(int*) b;}
int sup(void * a, void * b) {  return *(double*)a > *(double*) b;}
 
   typedef int (*cmpfct)(void*, void*);
   cmpfct Compare [3] = {NULL, inf, sup};
//....
   result= Compare[type](&val1,&val2);
//....

[Obsidian]

Mmmmh, le C vient de s'effondrer dans mon estime...

Si tu arrives à un point où le C est trop limité pour implémenter ton algorithme, c'est qu'il y a fort probablement une erreur de conception quelque part.

Je détaille mon problème au cas ou ça vous donnerait des idées:

Bonne idée (il aurait peut-être même fallu commencer par cela ).

J'ai une fonction qui réalise plusieurs comparaisons en fonction d'un paramètre type :
Si type=1 toutes les comparaisons sont des <
Si type=2 toutes les comparaisons sont des >

Et je n'ai pas envie d'écrire une fonction par cas, ni de tester le paramète type avant chaque comparaison !

Du coup je pense à utiliser une variable (un pointeur ?), référencant l'operateur à utiliser et remplacer tout appel à un des deux opérateur par le contenu de cette variable...

Pour l'instant j'ai créé deux fonctions sup et inf qui encapsulent respectivement > et < mais je trouve ça ridicule...

Non, cela n'est pas ridicule : cela correspond à une réalité technique. Les opérateurs de comparaison, en C, ne sont en pratique jamais compilés comme des appels de fonctions. Il existe en assembleur des instructions de comparaison des binaires (CMP, FCMP, ...) qui modifient l'état des flags du processeur. Les sauts conditionnels se font ensuite suivant l'état de ces flags. Tu peux voir cela comme une sorte de fonction inline qui, en plus, ne contiendrait que deux instructions, voire une.

Donc, pas de routine en mémoire → pas de pointeur.

La surcharge des opérateurs est bien pratique pour faire abstraction de tout cela et rendre comparable des choses qui ne le sont pas a priori, mais il faut quand même savoir un peu comment ça se passe sous le capot, de temps en temps.

il doit bien exister une solution élégante en C ??

Le plus élégant, à mon avis, est de faire un tableau de pointeurs de fonctions qui soit indexé par ton « type ». Ainsi, tu conserves sup et inf, mais tu peux les faire varier au cours du temps, tu peux étendre ton tableau au besoin, et l'accès à la bonne fonction de comparaison se fait en temps constant, et sans avoir besoin d'être codée en dur dans ton code.

[Bbaboulinet]

Salut,
pourquoi tu ne fais pas pour tous les cas < et quand tu veux supérieur, tu fait l'inverse du return de ta fonction < ?
a+,

[Obsidian]

Salut,
pourquoi tu ne fais pas pour tous les cas < et quand tu veux supérieur, tu fait l'inverse du return de ta fonction < ?
a+,

Parce qu'il faut tenir compte de l'égalité, en plus : « < » ≠ « ≤ » ≠ « = » ≠ « ≥ » ≠ « > ».

[systemofaxav]

(cf posts ci-dessus)

Merci pour ta réponse claire et très précise !

Après reflexion c'est logique de ne pas alourdir l'execution du programme avec des appels de fonctions pour des opérations aussi atomiques que la comparaison...

Je vais donc conserver inf et sup, un tableau serait de trop ici, puisqu'une fois le type connu, l'operateur de comparaison utilisé est fixe (D'ou un test au début)

Salut,
pourquoi tu ne fais pas pour tous les cas < et quand tu veux supérieur, tu fait l'inverse du return de ta fonction < ?
a+,

Parce qu'il faut tenir compte de l'égalité, en plus : « < » ≠ « ≤ » ≠ « = » ≠ « ≥ » ≠ « > ».

Et d'autant plus que ma fonction ne retourne pas de booléen, mais utilise les comparaisons pour son traitement.

Merci encore à ceux qui m'ont éclairé !

__________________

[Obsidian]

Après reflexion c'est logique de ne pas alourdir l'execution du programme avec des appels de fonctions pour des opérations aussi atomiques que la comparaison...

À la limite, si ce sont là les seules opérations que tu as réellement besoin de faire, tu peux utiliser une macro et l'opérateur ternaire :

Code C :

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

#define cmp(a,b,type) type==1?a>b:a<b

Si le type est connu à la compilation, le C simplifiera l'expression et utilisera directement le bon opérateur, sinon l'overhead engendré ne sera pas plus important que l'appel à une fonction, je pense.

[Médinoc]

À la limite, si ce sont là les seules opérations que tu as réellement besoin de faire, tu peux utiliser une macro et l'opérateur ternaire :

Code C :

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

#define cmp(a,b,type) type==1?a>b:a<b

Si le type est connu à la compilation, le C simplifiera l'expression et utilisera directement le bon opérateur, sinon l'overhead engendré ne sera pas plus important que l'appel à une fonction, je pense.

Attention! Macro sans parenthèses détectée!

Code C :

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

#define cmp(a,b,type) ((type)==1 ? ((a)>(b)) : ((a)<(b)))

Au moins, on dirait qu'il n'y a pas de problème de double-évaluation possible (contrairement aux macros min et max).