Discussion :

[MrPchoun]

Bonjour,

J'ai trois structures :

Code :

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

1
2
3
struct Cat { const static unsigned mask = 1; };
struct Dog { const static unsigned mask = 2; };
struct Cow { const static unsigned mask = 4; };

J'aimerais créer une macro qui prendrait des types en argument et qui :
- en ferait un enum
- créerait un tableau avec les maks des types

Rien compris ? X) Un petit exemple sera plus parlant. J'aimerais pouvoir écrire :

Code :

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

macro(Dog,Cow,Cat)

Ceci me créerait une structure :

Code :

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

1
2
3
4
5
struct
{
    enum {Dog,Cow,Cat};
    unsigned tab[3] = {2,4,1};
} test;

Pour l'instant j'ai écrit la macro suivante :

Code :

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

1
2
3
4
5
6
#define macro(Ts...)                    \
struct                                  \
{                                       \
    enum { Ts,count };                  \
    unsigned tab[count] = {Ts::mask};   \
} test;

C'est bon pour l'enum, mais pour tab c'est pas encore ça il doit y avoir un problème d'expanded pack quelque part, mais je ne sais pas comment résoudre ça !

Des suggestions ?

[ternel]

Proposition au pif (car n'aimant pas les macros, je ne connais pas ce niveau de détails):
As-tu essayé Ts...::mask et Ts::mask... et aucun des deux ne marchent?

Par ailleurs, que génère ta macro actuelle?

[MrPchoun]

As-tu essayé Ts...::mask et Ts::mask...

Oui, dans les deux cas le compilateur me dit "Pack expansion does not contain any unexpanded parameter packs"

Par ailleurs, que génère ta macro actuelle ?

Eh bien par exemple,

Code :

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

1
2
3
4
5
6
7
macro(Dog,Cow,Cat);
std::cout << test.Dog << std::endl;
std::cout << test.Cow << std::endl;
std::cout << test.Cat << std::endl;
std::cout << test.tab[0] << std::endl;
std::cout << test.tab[1] << std::endl;
std::cout << test.tab[2] << std::endl;

Affiche ceci :

0
1
2
0
1
1

Les trois premiers correspondent à l'enum, nikel, par contre les trois derniers, c'était pas franchement attendu comme résultat, moi jvoulais 2 4 1

[ternel]

C'est le code généré par la macro qui est intéressant.
Tu peux l'obtenir avec certains réglages de compilation.
Pour gcc, c'est -E, qui produit le code après le passage du préprocesseur (donc les macros) mais avant compilation.

[bacelar]

L'équivalent du -E de gcc pour Visual Studio, c'est /P.
https://msdn.microsoft.com/en-us/lib...or=-2147217396

[ternel]

au passage, la macro devrait prendre le nom de la variable générée en argument. ici, "test" semble vraiment sortir du chapeau.

[MrPchoun]

Hum.. Voui mais moi je suis sur XCode, avec clang comment qu'on fait ?

Sinon j'ai trouvé une solution. Je passe par une fonction template :

Code :

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

1
2
3
4
5
6
template <typename...Ts>
std::vector<unsigned> createTab()
{
    std::vector<unsigned> tmp = {Ts::mask...};
    return tmp;
}

Et j'encapsule mon enum dans une struct. Allez savoir pourquoi, si je ne le fais pas, ça marche pas. Sans doute parce qu'une fois que j'ai utilisé Ts dans une enum, le compilo considère que Ts ne peuvent être que des membres de l'enum, du coup je peux plus utiliser Ts pour autre chose.. Ça donne :

Code :

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

1
2
3
4
5
6
7
#define macro(Ts...)                \
struct A                            \
{                                   \
    struct { enum { Ts }; } index;  \
    std::vector<unsigned> tab;      \
    A() { tab = createTab<Ts>(); }  \
} test;

C'est pas très très propre mais ça marche

Code :

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

1
2
3
4
5
6
7
macro(Dog,Cow,Cat);
std::cout << test.index.Dog << std::endl;
std::cout << test.index.Cow << std::endl;
std::cout << test.index.Cat << std::endl;
std::cout << test.tab[0] << std::endl;
std::cout << test.tab[1] << std::endl;
std::cout << test.tab[2] << std::endl;

print :
0
1
2
2
4
1

Du coup, pour générer le code de la macro, ça se passe comment ? (Je suis quand même preneur d'une solution plus propre)

[ternel]

d'après cette documentation, c'est -E aussi

[jo_link_noir]

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
template<class... Ts> 
struct array_mask {
  static unsigned constexpr tab[] = {Ts::mask...};
};
template<class... Ts>
constexpr unsigned array_mask<Ts...>::tab[sizeof...(Ts)];
 
#define macro(...)               \
struct : array_mask<__VA_ARGS__> \
{                                \
  enum { __VA_ARGS__, count };   \
}

[MrPchoun]

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
template<class... Ts> 
struct array_mask {
  static unsigned constexpr tab[] = {Ts::mask...};
};
template<class... Ts>
constexpr unsigned array_mask<Ts...>::tab[sizeof...(Ts)];
 
#define macro(...)               \
struct : array_mask<__VA_ARGS__> \
{                                \
  enum { __VA_ARGS__, count };   \
}

Vous m'épaterez toujours, les gars.. C'est propre, clair, et efficace. Fallait juste ça, en fait. Chapeau, Merci !

[ternel]

Mais une macro est-elle nécessaire ou utile pour obtenir ce résultat?
une template ne suffirait-elle pas?

[jo_link_noir]

Cela oblige de dupliquer l'information. Une fois pour l'enum, une autre fois dans la template.
Après, il est possible de faire en sorte que le type soit une clef convertible en un identifiant. Ceci permet également de générer la valeur mask automatiquement. Mais au prix d'un code plus verbeux.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
int main(){
  type_enum_mask<Dog, Cow, Cat>
    animals{};
 
  std::cout
    << animals.index<Dog>() << '\n'
    << animals.index<Cow>() << '\n'
    << animals.index<Cat>() << '\n'
    << animals.masks[0] << '\n'
    << animals.masks[1] << '\n'
    << animals.masks[2] << '\n'
  ;
}

(Si vous le voulez, je peux faire le code pour arriver au résultat).

[MrPchoun]

Cela oblige de dupliquer l'information. Une fois pour l'enum, une autre fois dans la template.
Après, il est possible de faire en sorte que le type soit une clef convertible en un identifiant. Ceci permet également de générer la valeur mask automatiquement. Mais au prix d'un code plus verbeux.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
int main(){
  type_enum_mask<Dog, Cow, Cat>
    animals{};
 
  std::cout
    << animals.index<Dog>() << '\n'
    << animals.index<Cow>() << '\n'
    << animals.index<Cat>() << '\n'
    << animals.masks[0] << '\n'
    << animals.masks[1] << '\n'
    << animals.masks[2] << '\n'
  ;
}

(Si vous le voulez, je peux faire le code pour arriver au résultat).

Mais une macro est-elle nécessaire ou utile pour obtenir ce résultat?
une template ne suffirait-elle pas?

Moi, je veux bien voir, par curiosité Même si, pour être tout à fait franc, je me demande toujours pourquoi il faudrait chercher à faire compliqué quand on peut faire simple. Je veux dire, avec une macro, le code est torché en 5 lignes

[Bousk]

Mais une macro est-elle nécessaire ou utile pour obtenir ce résultat?
une template ne suffirait-elle pas?

Je ne vois aucun moyen de générer un enum simplement avec un template seul.
Il s'agit bien de le générer => macro