Aide pour realiser une classe de manipualtion de donnees

Bonjour,

Mais Triplet est abstraite, et je ne peux pas contruire un
std::vector<Triplet> à passer pour dessiner.
Je compte du coup re-écrire toutes les classes dans ce style :

class Triplet
{
public:
virtual double Value( int Index ) const { return this->values.at(
Index ); }
private:
std::vector<double> values;
};

Bonjour,
Ca parrait long, mais c'est vite lu :-)

J'ai un certain nombre de classes ABC, DEF, GHI, ... qui ont la
particularité d'avoir une certain nombre (presque tout le temps 3) de
"valeurs" toutes de type double. En fait, la seule chose qui différencies
ces classes est le nom de ces valeurs :

class ABC
{
public:
double A() const { return this->a; }
double B() const { return this->b; }
double C() const { return this->c; }

private:
double a;
double b;
double c;
};

Pourquoi ne pas garder ta première solution et utiliser un
vector<Triplet*>

au lieu de vector<Triplet> ?

Je propose une autre solution, qui évite de faire de l'héritage :

class ABC
{
public:
double A() const { return this->a; }
double B() const { return this->b; }
double C() const { return this->c; }

Ici, tu ajoutes :
double getVal(int i) const;

private:
double a;
double b;
double c;
};

Et ensuite, tu fait :

template<class Triplet> dessine(Triplet const &t)
{
cout << t.getVal(1);
}

ABC abc;
dessine(abc);

Pourquoi ne pas garder ta première solution et utiliser un

vector<Triplet*>

au lieu de vector<Triplet> ?

Merci pour ton aide.
C'est le delete qui m'embête... C'est assez contraignant de devoir appeler
delete sur chaque élément d'un vector reçu en paramètre :

Dans ce cas, soit ton vecteur ne possède pas les triplets, et pas besoin
de faire les delete, soit il les possède (soit de façon partagée ou
suite à une copie en profondeur), et un vecteur de pointeurs
intelligents (par exemple vector<boost::shared_ptr<Triplet> > pour de la
propriété partagée, à condition qu'il y ait des
boost::shared_ptr<Triplet> partout dans ton code) peut convenir.

Dans ce cas, soit ton vecteur ne possède pas les triplets, et pas besoin
de faire les delete, soit il les possède (soit de façon partagée ou
suite à une copie en profondeur), et un vecteur de pointeurs
intelligents (par exemple vector<boost::shared_ptr<Triplet> > pour de la
propriété partagée, à condition qu'il y ait des
boost::shared_ptr<Triplet> partout dans ton code) peut convenir.

J'y ai pensé (à std::auto_ptr).

Mais les pointeurs pour ça ça me gêne beaucoup.

Mais les pointeurs pour ça ça me gêne beaucoup.

Si tu n'expliques pas en quoi ça te gêne, on va a voir du mal à trouver
une solution qui te plaise.

Ca parrait long, mais c'est vite lu :-)

J'ai un certain nombre de classes ABC, DEF, GHI, ... qui ont la
particularité d'avoir une certain nombre (presque tout le temps 3) de
"valeurs" toutes de type double. En fait, la seule chose qui
différencies ces classes est le nom de ces valeurs :

class ABC
{
public:
double A() const { return this->a; }
double B() const { return this->b; }
double C() const { return this->c; }
private:
double a;
double b;
double c;
};

class DEF
{
public:
double D() const { return this->d; }
double E() const { return this->e; }
double F() const { return this->f; }
private:
double d;
double e;
double f;
};

etc...

C'est utile de les différencier, car ces valeurs n'ont pas la même
signification, et le typage est nécessaire. Jusque là tout va bien,
tout est calculé correctement.

Probleme :

Je veux dessiner ces valeurs dans un graphe, 1 valeur au choix sur
chaque axe. Par exemple, dessiner A() et B() sur mon graphe. Je
voudrais donc faire un truc générique, et pas XX fonctions pour chaque
type. J'ai voulu faire hériter toutes ces classes d'une même classe de
base : Triplet.

class Triplet
{
public:
virtual double Value( int Index ) const = 0;
};

Ainsi je file mon ABC ou DEF ou XYZ à mon graphe et je lui dit
"dessine moi la valeur 1 et 2 et il fait Value( 1 ) et Value ( 2 )
pour les récupérer.

class ABC : public Triplet
{
// idem que plus haut

public:
double Value( int Index )
{
switch ( Index )
{
case 0 : return this->A();
case 1 : return this->B();
case 2 : return this->C();
}
// exception
}
};

Mais Triplet est abstraite, et je ne peux pas contruire un
std::vector<Triplet> à passer pour dessiner.
Je compte du coup re-écrire toutes les classes dans ce style :

class Triplet
{
public:
virtual double Value( int Index ) const { return this->values.at(
Index ); }
private:
std::vector<double> values;
};

class ABC : public Triplet
{
public:
double A() const { return this->values[ 0 ]; }
double B() const { return this->values[ 1 ]; }
double C() const { return this->values[ 2 ]; }
};

Y'a-t-il une meilleure solution ?

Ça ne me semble pas mauvais.

Ceci dit, j'ai lu la reste de la discussion, où tu dis de ne pas aimer
les pointeurs. Or, en C++, qu'on les aime ou non, le polymorphisme
implique l'utilisation des pointeurs. Et un certain nombre d'autres
choses.

Si tes classes ABC et DEF sont réelement des valeurs, avec une
sémantique de valeur, c'est peut-être que le polymorphisme, même limité,
ne leur convient pas.

En plus de la solution template suggérer par Loïc, tu pourrais penser à
une conversion implicite -- tu définis une class Triplet uniquement pour
l'affichage, puis dans ABC, DEF, etc., tu définis un opérateur de
conversion :

operator Triplet() {
return ...
}

où tu construis un Triplet des valeurs dans la classe dérivée.