Discussion :

[gumpman]

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 !

[Sve@r]

Bonjour

Chez-moi ça marche

Code c :

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

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));
}

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...

[gumpman]

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;
}

[Sve@r]

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.

[dalfab]

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 :

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

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 :

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

1
2
3
4
5
6
int  rtype_to_int( rtype  x ) {
   return  x;
}
rtype  int_to_rtype( int x ) {
   return  (rtype)x;
}

[Sve@r]

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 c :

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

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;

[foetus]

Tu ne dis pas pourquoi ton code ne fonctionne pas

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
Il faut plutôt coder comme cela :

Code :

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

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 ) 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

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
#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;
}

[Sve@r]

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

T'as un trou sur la gestion des trous?
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)

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...

[foetus]

Ben si un peu quand-même.

Oui il est générique … mais pas tant que cela 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 … 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 ?

[edgarjacobs]

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 ) : dans l'enum, ce n'est pas un ; qui sépare les valeurs, mais une ,