Discussion :

[HanLee]

Salut,

J'ai un petit problème.
Pour simplifier des algorithmes, j'ai besoin d'utiliser des éléments d'un groupe cyclique.

Concrètement : symboliquement
( {1, e, e^2 } , * ) groupe cyclique.
1 est l'élément neutre, e est le générateur.
e^3 = 1
e^n = e*...*e (n fois)

Bien sûr en pratique j'utilise des int, et pas des 'e'.

Avant j'avais juste fait une classe template CyclicGroup, on instanciait un objet de cette classe, et on le construisait en injectant des éléments.

Après pour faire des opérations, j'passais des éléments en argument dans les méthodes de l'objet.

Seulement c'est chiant.

Exemple rédigé vite fait, commenté, puis discuté :

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
 
// J'mets pas les constructeurs
 
template <class T>
class CyclicGroup
{
    vector<T> set;
 
public:
    void Add(const T & t); // Ajoute un élément, le premier élément est l'élément neutre, le second le générateur
    int Card(); // Cardinal du groupe
};
 
template <class T>
class CyclicElmt
{
    CyclicGroup<T> & G;
    T val;
 
public:
    void Bind(const CyclicGroup<T> & G_)
    {
        G = G_;
    }
 
    CyclicElmt<T> operator==(const CyclicElmt & e);
    CyclicElmt<T> operator=(const CyclicElmt & e);
    CyclicElmt<T> operator=(T t);
    CyclicElmt<T> operator*(const CyclicElmt & e);
    CyclicElmt<T> operator^(int i); // Attention à la priorité
    operator T();
};
 
// Utilisation
 
CyclicGroup<int> G;
G.Add(1);
G.Add(2);
G.Add(3);
 
CyclicElmt<int> a, b;
 
a.Bind(G);
b.Bind(G);
 
a = 1;
b = 2;
 
a = b^2;

La vous voyez, le principal problème c'est qu'il faut bind chaque élément séparément à son groupe.
Moi j'aimerais bien que ça soit fait à la déclaration de a et b.

En fait le must ce serait de ne meme pas préciser le type int, mais de passer en argument G quelque part, sauf que c'est pas possible pour les templates, ils prennent des types et pas d'instances.

Si vous avez des constructions mystiques qui seraient plus cools à utiliser les boss de la méta-programmation, merci d'avance .

[JolyLoic]

En fait le must ce serait de ne meme pas préciser le type int, mais de passer en argument G quelque part, sauf que c'est pas possible pour les templates, ils prennent des types et pas d'instances.

Qu'est-ce qui te fais dire ça ?

Extrait de la norme :

14.3.2 Template nontype arguments [temp.arg.nontype]
1 A templateargument for a nontype, nontemplate templateparameter shall be one of:
— an integral constantexpression of integral or enumeration type; or
— the name of a nontype templateparameter; or
— the name of an object or function with external linkage, including function templates and function templateids but excluding nonstatic class members, expressed as idexpression; or
— the address of an object or function with external linkage, including function templates and function templateids but excluding nonstatic class members, expressed as & idexpression where the & is optional if the name refers to a function or array; or
— a pointer to member expressed as described in 5.3.1 .

[HanLee]

Ca veut dire qu'on peut faire ça ??

Code :

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

1
2
3
4
 
CyclicGroup<int> G;
 
CyclicElmt<G> a, b;

Mais comment on exploiterait ensuite l'argument G ?
En fait j'vois pas du tout.

[JolyLoic]

Le code suivant marche :

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
 
#include <iostream>
using namespace std;
 
template <class T> struct G
{
	typedef T type;
	G(int id) : typeId(sizeof(T)), instanceId(id) {}
	int typeId;
	int instanceId;
};
 
template <class T, G<T> *g> struct elem
{
	int instanceId;
	elem() : instanceId(g->instanceId) {}
 
};
 
G<int> globalG(42);
 
int main()
{
	elem<int, &globalG> myElem;
	cout << myElem.instanceId;
}

Il y a par contre une limitation : le G doit être déclaré en global.

Une alternative si l'ensemble des groupes cyclliques possibles est connu à la compilation pourrait être de passer un argument template de type énumération.

[Laurent Gomila]

Je ne suis pas sûr d'avoir tout suivi donc désolé si ma question est idiote, mais pourquoi vouloir passer G en paramètre template et non à un constructeur, par exemple ?

[JolyLoic]

Ca, je n'en sais rien...
Je pense que le principal intérêt en l'occurence est de pouvoir faire un typedef qui englobe les arguments templates et permet d'utiliser un élément comme s'il s'agissait d'un type de base. Il doit être plus clair d'écrire :

Code :

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

Racine12emeDeLUnite a;

Que d'écrire :

Code :

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

Element<double> a(GroupeDesRacines12emeDeLUnite);

[HanLee]

>JolyLoic : ah ouais, mais ça me gêne un peu que G soit global...

EDIT : oui voilà c'est ce que j'veux faire =)

> Loulou : parce qu'en fait j'voulais que chaque instantiation G de CyclicGroup représente un type différent à chaque fois.

Et que donc on ferait un truc du genre CyclicElmt<G> pour déclarer un élément de G.

Et comme ça pas besoin de préciser G à chaque fois que je déclare un élément de G, parce que faire ça serait un peu lourd pour moi :/ :

Code :

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

CyclicElmt<int> a(G), b(G)

[HanLee]

Je ne suis pas sûr d'avoir tout suivi donc désolé si ma question est idiote, mais pourquoi vouloir passer G en paramètre template et non à un constructeur, par exemple ?

En fait peut-être qu'à travers le constructeur, tu pensais à RAII.
Bah au pire j'vais faire ça.