Discussion :

[tduverger]

Bonjour,

j'ai declaré plusieurs valeurs pour des variables

Code :

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

1
2
3
4
5
 
#define PIN_IN1 1
#define PIN_IN2 5
#define PIN_IN3 6
#define PIN_IN4 22

je souhaiterai obtenir la valeur de ces variables avec PIN_IN(x)
j'ai donc ajouté

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
#define PIN_IN(x) PIN_IN##x
 
//dans ce cas PIN_IN(4) me renvoie bien  22
 
// mais lorsque je veux l'intégrer dans un boucle
 
int i;
while ( i < 4) {
printf("valeur: %d\n', PIN_IN(i));
}
 
//j'ai une erreur car il cherche PIN_INi

Merci d'avance pour votre aide

[Sve@r]

Bonjour

je souhaiterai obtenir la valeur de ces variables avec PIN_IN(x)

Tu peux pas. Faut pas oublier que le préprocesseur (étape qui se déroule avant la compilation) n'est qu'un bête traducteur littéral. Ce n'est pas un pré-langage de prog !!! Il peut traduire littéralement PIN_IN(1) en PIN_IN1 mais il n'a pas pour rôle d'analyser la valeur de la variable "i" pour la récupérer (d'ailleurs à son niveau il ne la voit même pas). Ca ce sera au compilateur de le faire et lui il passe après.

Accessoirement dans ton code tu n'initialises pas "i" et tu ne l'incrémentes pas. Et t'as mélangé quotes doubles et quotes simples.

[tduverger]

Merci pour ta réponse,

Dans ce cas ma seule solution est la déclaration d'un tableau en variable globale

Effectivement il y a des fautes de recopie de cette partie de mon code. dsl

[Sve@r]

Dans ce cas ma seule solution est la déclaration d'un tableau en variable globale

Ce n'est pas la seule. Un tableau oui (c'est d'ailleurs généralement ce vers quoi on se trourne instinctivement dès qu'on veut manipuler ses séries d'items de même nature) ou alors t'as aussi l'enum qui peut le faire ; mais pourquoi en global ?
Passer par des globales pour "ne pas se fatiguer la vie" est généralement la pire des mauvaises fausses bonnes idées.

[tduverger]

Bon j’avoue la variable globale c’est de la feneantise.
Je connaissais pas enum c’est se que je cherchais
Encore merci

[wistiti1234]

Ce n'est pas la seule. Un tableau oui (c'est d'ailleurs généralement ce vers quoi on se trourne instinctivement dès qu'on veut manipuler ses séries d'items de même nature) ou alors t'as aussi l'enum qui peut le faire ; mais pourquoi en global ?
Passer par des globales pour "ne pas se fatiguer la vie" est généralement la pire des mauvaises fausses bonnes idées.

Un enum? Pour itérer dans une boucle? Là ça m'échappe.

[Sve@r]

Un enum? Pour itérer dans une boucle? Là ça m'échappe.

Oui, j'ai lancé ça un peu en l'air sans trop réfléchir. Mais en forçant un peu ça le fait. Tout d'abord l'enum pour associer les divers tokens "pin_ini" à leurs valeurs respectives et ensuite si on veut itérer sur les différentes valeurs, évidemment on est obligé de les stocker dans un tableau.

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
16
#include <stdio.h>
 
typedef enum {
	pin_ini1=1,
	pin_ini2=5,
	pin_ini3=6,
	pin_ini4=22,
} t_pin;
 
int main() {
	t_pin pin[]={pin_ini1, pin_ini2, pin_ini3, pin_ini4};
	size_t i;
	for (i=0; i < 4; i++)
		printf("pin[%zd]=%d\n", i, pin[i]);
 
}

[wistiti1234]

Oui voilà, avec un tableau.
Ou avec un switch/case, mais c'est un peu degeu:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
t_pin i;
for(i=pin_ini1; i<=pin_ini4; i++){
    switch(i){
        case pin_ini1:
        case pin_ini2:
        case pin_ini3:
        case pin_ini4:
            printf("valeur: %d\n", i);
            break;
        default:
    }
}

Ce qui serait classe, ça serait de pouvoir incrémenter une variable enum et de tomber directement sur la valeur valide suivante . Peut être dans une prochaine norme?

[foetus]

Ce qui serait classe, ça serait de pouvoir incrémenter une variable enum et de tomber directement sur la valeur valide suivante . Peut être dans une prochaine norme?

Il y a 2 choses à faire

La meilleure , un générateur ("generator" en anglais) (<- lien wiki en français) qui fait partie de certains langages (par exemple PHP) ... et vient d'arriver dans la norme 2020 du C++

Un exemple, avec un tableau fixe et un "yield" cyclique :

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
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
#include <string.h>
 
 
typedef struct s_generator {
    int tab_values[4];
 
    size_t nb_values;
    size_t current_value;
} t_generator;
 
 
void generator_add(t_generator* generator, int new_value) {
    if ((generator != NULL) && (generator->nb_values < 4)) {
        generator->tab_values[generator->nb_values] = new_value;
 
        ++generator->nb_values;
    }
}
 
 
void generator_init(t_generator* generator) {
    if (generator != NULL) {
        generator->nb_values     = 0;
        generator->current_value = 0;
 
        memset(generator->tab_values, 0, (4 * sizeof(int)));
    }
}
 
 
unsigned char generator_get_nb_values(t_generator* generator, size_t* nb_values) {
    unsigned char ret;
 
    if ((generator != NULL) && (nb_values != NULL)) {
        (*nb_values) = generator->nb_values;
 
        ret = 1;
    } else {
        ret = 0;
    }
 
    return ret;
}
 
 
void generator_reset(t_generator* generator) {
    if (generator != NULL) {
        generator->current_value = 0;
    }
}
 
 
unsigned char generator_yield(t_generator* generator, int* value) {
    unsigned char ret;
 
    if ((generator != NULL) && (value != NULL)) {
        generator->current_value = ((generator->current_value + 1) % 4);
 
        (*value) = generator->tab_values[generator->current_value];
 
        ret = 1;
    } else {
        ret = 0;
    }
 
    return ret;
}
 
 
int main(int argc, char** argv)
{
    t_generator generator;
    size_t i, nb_values;
    int value;
 
    generator_init(&generator);
 
    generator_add(&generator, 1);
    generator_add(&generator, 5);
    generator_add(&generator, 6);
    generator_add(&generator, 22);
 
    if ( generator_get_nb_values(&generator, &nb_values) ) {
        nb_values *= 2;
 
        printf("generator_get_nb_values, nb values : %lu\n", nb_values);
 
        for(i=0; i < nb_values; ++i) {
            if ( generator_yield(&generator, &value) ) {
                printf("%02lu : %02d\n", (i + 1), value);
            } else {
                printf("%02lu : error - generator_yield\n", (i + 1));
            }
        }
    } else {
        printf("main - error : generator_get_nb_values");
    }
 
 
    return EXIT_SUCCESS;
}

Ou bien utiliser la concaténation du préprocesseur ... mais ce n'est pas trop flexible
Édit : effectivement c'était la question initiale que je n'avais point compris. Je me suis troué

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
typedef enum e_pin {
    pin_ini1=1,
    pin_ini2=5,
    pin_ini3=6,
    pin_ini4=22,
} t_pin;
 
#define G_GET_PIN_VALUE(X) pin_ini##X
 
 
int main(int argc, char** argv)
{
    printf("1 : %02d\n", G_GET_PIN_VALUE(1));
    printf("2 : %02d\n", G_GET_PIN_VALUE(2));
    printf("3 : %02d\n", G_GET_PIN_VALUE(3));
    printf("4 : %02d\n", G_GET_PIN_VALUE(4));
 
 
    return EXIT_SUCCESS;
}

[tduverger]

Merci à tous pour vos réponses mais effectivement j'ai regardé enum sans tester mais on ne peux pas l'appeler dans une boucle de façon aussi simple qu'un tableau.
Je crois que je vais rester sur le tableau en local.
foetus, la concatenation du preproceseur ne m'aide pas car je ne pourrais pas appeler une valeur dans une boucle: G_GET_PIN_VALUE(i) ne sera pas interprété.

[Sve@r]

La meilleure , un générateur ("generator" en anglais) (<- lien wiki en français) qui fait partie de certains langages (par exemple PHP) ... et vient d'arriver dans la norme 2020 du C++

Hé oui, et qui existe depuis longtemps en Python, C# et php. Malheureusement ici on est en C

Ou bien utiliser la concaténation du préprocesseur ... mais ce n'est pas trop flexible

As-tu remarqué que c'était le point de départ de la discussion ?

Un exemple, avec un tableau fixe et un "yield" cyclique :

Joli exercice de style