Vérifier la valeur d'un type enum

Shalom, Bonjour,

J'ai un projet à rendre en C mais je bloque un peu sur ce type de problème:

En fait, j'ai un type enum défini comme ceci:

typedef enum { A = 2; B;C;...} rtype;

Maintenant mon problème c'est que j'aimerais bien avoir une fonction du type:

bool valeur_est_A(rtype id); Qui vérifie que la valeur de id est celle de A (Ainsi pouvoir le faire pour chaqun des éléments de cet enum).
J'ai écris une fonction de ce type:

bool valeur_est_A(rtype id) {
if(id == A) { return true;}
return false;
}

Mais cela ne fonctionne pas à la compilation, j'obtiens l'erreur: lvalue required as left operand of assignment

Je ne sais pas trop quoi faire.
Merci d'avance !

Bonjour

Chez-moi ça marche

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

#include <stdio.h> #include <stdbool.h>   typedef enum { A = 2, B, C = 5} rtype;   bool valeur_is(rtype id, rtype x) { return id == x; }   int main() { rtype x=B; printf("A: %d\n", valeur_is(x, A)); printf("B: %d\n", valeur_is(x, B)); printf("C: %d\n", valeur_is(x, C)); }

---

Citation:

---

Envoyé par gumpman

Qui vérifie que la valeur de id est celle de A (Ainsi pouvoir le faire pour chaqun des éléments de cet enum).

---

En effet, pourquoi faire simple. Moi c'est pareil, quand je veux checker les 1500 éléments de mon tableau, au lieu de faire "une" fonction un peu générique qui checke "un" élément, je préfère écrire 1500 fonctions...

Je viens de trouver une solution:
C’est d’utiliser l’indexation que j’ai dans mon enum j’ai fait quelques chose qui ressemble à ça:

bool est_A(rtype id) {
if(id == 2){
return true;
}
return false;
}

Citation:

---

Envoyé par gumpman

C’est d’utiliser l’indexation que j’ai dans mon enum

---

Ce qui fait perdre définitivement tout l'intérêt d'utiliser un enum.

Attention, tu crées un enum anonyme. Il est important de donner un nom aux enum, struct et union. Rien n'empêche de leur donner le même nom que le typedef.
J'écrirais plutôt:

Code:

---

1 2 3 4 5

typedef enum rtype { A = 2, B, C = 5} rtype; // rtype est un alias vers l'enum rtype   bool valeur_is(rtype id, rtype x) { return id == x; }

---

D'ailleurs l'enum est converti en sa veleur entière implicitement, l'inverse est aussi vrai mais peut produire un warning

Code:

---

1 2 3 4 5 6

int rtype_to_int( rtype x ) { return x; } rtype int_to_rtype( int x ) { return (rtype)x; }

---

Citation:

---

Envoyé par dalfab

Il est important de donner un nom aux enum, struct et union.

---

Ah? Pourquoi faire? Si je crée un type avec un nom de type, à quoi sert le nom de la structure puisque le nom du type va prendre la prépondérance?
A l'exception des structures nécessitant de connaitre leur propre identification au moment de l'écriture (exemple des listes chainées) je ne mets jamais de nom à mes structures

Code:

---

1 2 3 4 5

typedef struct /* pourquoi mettre un nom puisque je crée un type ??? */ { unsigned short jj; unsigned short mm; unsigned short aa; } t_date;

---

Tu ne dis pas pourquoi ton code ne fonctionne pas :aie:

Mais, il y des chances que tu tombes sur le "problème" des énumérations : les valeurs sont globales et donc ton nommage est très mauvais :aie:
Il faut plutôt coder comme cela :

Code:

---

1 2 3 4 5

typedef enum e_rtype { G_RTYPE_A = 2, G_RTYPE_B, G_RTYPE_C = 5 } t_rtype;

---

• qu'on donne 1 nom ou pas, le compilateur va en donner 1 aux structures/ énumérations anonymes. Moi je commence par "e_" pour les énumérations et "s_" pour les structures
• comme on crée 1 type et qu'on va utiliser dans le code, il faut mieux dire que c'est 1 type en commençant par "t_"
• en C, il n'y a pas de "décoration de nom" (mangling en anglais), donc même si c'est pénible/ s'en rappeler/ …, il faut mieux rappeler le nom du type dans le nom de la valeur/ constante.
• "G_", c'est pour "global"

Et je tiens à signaler que lorsque @Sve@r dit de faire 1 algo générique, ton énumération n'est pas prévue pour cela : il manque le nombre de valeurs (toujours la dernière valeur, 1 astuce C :zoubi:) et il faut éviter les trous dans les valeurs.
Après peut-être que ce sont des valeurs imposées et j'ai 1 trou de mémoire sur la gestion des trous dans les valeurs :oops: :oops:

Code:

---

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

#include <stdio.h> #include <stdlib.h>     typedef enum e_rtype { G_RTYPE_A = 2, G_RTYPE_B, G_RTYPE_C, G_RTYPE_NB_VALUES, G_RTYPE_FIRST = G_RTYPE_A } t_rtype;     unsigned char rtype_is_value(t_rtype value) { return ((value >= G_RTYPE_FIRST) && (value < G_RTYPE_NB_VALUES)); }       int main(/*int argc, char* argv[]*/) { printf("RTYPE_A: %d\n", rtype_is_value(G_RTYPE_A)); printf("RTYPE_B: %d\n", rtype_is_value(G_RTYPE_B)); printf("7: %d\n", rtype_is_value(7)); printf("RTYPE_C: %d\n", rtype_is_value(G_RTYPE_C)); printf("1: %d\n", rtype_is_value(1)); printf("5: %d\n", rtype_is_value(5));     return EXIT_SUCCESS; }

---

Citation:

---

Envoyé par foetus

et j'ai 1 trou de mémoire sur la gestion des trous dans les valeurs :oops: :oops:

---

T'as un trou sur la gestion des trous? :mouarf:
Pas compliqué: chaque valeur non spécifiée récupère la précédente +1. Et si la première valeur n'est pas spécifiée, alors c'est 0 par défaut.
Dans par exemple enum {A, B, C=7, D, E}, A=0 (non spécifié donc 0 par défaut), B=1 (non spécifié donc dernière valeur +1), C=7 (spécifié), D=8 (non spécifié donc dernière valeur +1) et E=9 (idem que pour D)

Citation:

---

Envoyé par foetus

Et je tiens à signaler que lorsque @Sve@r dit de faire 1 algo générique, ton énumération n'est pas prévue pour cela

---

Ben si un peu quand-même. Par exemple mon premier code me semble assez générique même avec son enum. Au lieu d'écrire une fonction "valeur_is_A" et une autre "valeur_is_B" (et yalla si l'énum contient 50 items !!!) j'ai écrit une fonction "valeur_is" et je lui passe les valeurs à checker...

Citation:

---

Envoyé par Sve@r

Ben si un peu quand-même.

---

Oui il est générique … mais pas tant que cela :mrgreen: parce que tu passes la valeur à tester.

C'est surtout si tu fais 1 boucle pour parcourir les valeurs for(val=G_RTYPE_FIRST, val < G_RTYPE_NB_VALUES, ++val), tu vas prendre en compte les trous.
Pour 1 code complètement générique.
Le nom de la constante, c'est pour l'humain :mrgreen: … je pense même que le débugger ne l'affiche pas lorsque tu es en pas à pas.

Pour les trous peut-être "casser" son énumération en parties contiguës ? ou utiliser 1 tableau associatif ? :koi: :koi:

Citation:

---

Envoyé par gumpman

J'ai un projet à rendre en C mais je bloque un peu sur ce type de problème:

En fait, j'ai un type enum défini comme ceci:

typedef enum { A = 2; B;C;...} rtype;

Maintenant mon problème c'est que j'aimerais bien avoir une fonction du type:

bool valeur_est_A(rtype id); Qui vérifie que la valeur de id est celle de A (Ainsi pouvoir le faire pour chaqun des éléments de cet enum).
J'ai écris une fonction de ce type:

bool valeur_est_A(rtype id) {
if(id == A) { return true;}
return false;
}

Mais cela ne fonctionne pas à la compilation, j'obtiens l'erreur: lvalue required as left operand of assignment

Je ne sais pas trop quoi faire.
Merci d'avance !

---

Je ne vois pas d'assignement dans ce que tu écris.

Edit (my bad :calim2:) : dans l'enum, ce n'est pas un ; qui sépare les valeurs, mais une ,