Pattern classique ?

Fabien LE LEZ <gramster@gramster.com> writes:

Bonjour,

Supposons que je veuille créer une fonction qui renvoie plusieurs
valeurs, calculées conjointement et utilisées conjointement.

Typiquement, je vais créer une classe pour l'occasion, qui a priori ne
contient que des données, pas de fonctions.

Et tant qu'à faire, étant donné que la classe et la fonction n'ont
aucune utilité l'une sans l'autre, autant que la fonction en question
soit le constructeur de la classe.

Je me retrouve donc avec pas mal de classes ayant les caractéristiques
suivantes :
- un constructeur, qui initialise les membres en faisant pas mal
de calculs ;
- aucune autre fonction non-const ;
- plusieurs objets membres publics ;
- rien de privé ni de protégé ;
- Il n'y a a priori aucune raison de créer un objet de cette
classe qui ne soit pas const.

Est-ce quelque chose d'habituel, qui a un nom ? Ou, au contraire,
n'est-ce jamais utilisé car il y a une faille que je n'ai pas vue ?

c'est une struct :)

Merci d'avance...

de rien et bonne année

--
js

Je me retrouve donc avec pas mal de classes ayant les caractéristiques
suivantes :
- un constructeur, qui initialise les membres en faisant pas mal
de calculs ;
- aucune autre fonction non-const ;
- plusieurs objets membres publics ;
- rien de privé ni de protégé ;
- Il n'y a a priori aucune raison de créer un objet de cette
classe qui ne soit pas const.

Est-ce quelque chose d'habituel, qui a un nom ?

Un tuple? Par exemple http://www.boost.org/libs/tuple .
Les tuples sont déjà sur le chemin de la normalisation pour C++0x...
http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2005/n1836.pdf
Ça permettra peut-être des constructions sympas quand on aura aussi "auto".

Ceci dit, ce que tu cherches n'est a mon avis pas vraiment un tuple (!). Un
tuple est un conteneur alors que tu cherches de ton côté à représenter
seulement des "valeurs" (c'est à dire des éléments d'un ensemble donné), au
même titre par exemple que "int" ou "float". Je tombe moi aussi quelquefois
sur le même problème. Tuple peux effectivement faire l'affaire mais ce n'est
pas très propre. Faire une classe ad-hoc est mieux, mais c'est fastidieux...
et une struct reste encore un conteneur. En définitive je crois qu'il n'y a
pas de bonnes solutions en C++.

Pour essayer d'être plus clair, imaginons que tu veuilles représenter des
rationnels.

En C++ avec tuple, tu diras par exemple
---
typedef tuple<int, int> Rationnel;
Rationnel multiplie(const Rationnel& g, const Rationnel& d)
{
return make_tuple(g.get<0>()*d.get<0>(), g.get<1>()*d.get<1>());
}
---

En C++ avec classe ad-hoc...
---
class Rationnel {
// 20 lignes au moins
};
Rationnel multiplie(const Rationnel& g, const Rationnel& d)
{
// encode du code
}
---

En CAML (light?), tu peux (déjà) dire (ne fais pas attention a la syntaxe):
---
Type Rationnel_t = Rationnel of int * int
let multiplie (x, y) (Rationnel(num1, denom1), Rationnel(num2, denom2)) -> Rationnel(num1*num2,
denom1*denom2)
---

Les différences (j'en oublie certainement):
- En CAML un Rationnel a une vraie sémantique de valeur. Entre autres, un
Rationnel est immutable, en C++ non (on doit pouvoir rajouter des const qui
vont bien cependant).
- En CAML et en C++ classe ad-hoc, un Rationnel est un vrai type. En C++
tuple, par exemple on pourrait "multiplie"r n'importe quels tuple<int, int>
(pas que les Rationnels)!
- CAML est plus propre, plus court et plus lisible.

Donc pour finir en C++, tu devras te contenter de créer une classe ad-hoc
(plus propre, mais plus fastidieux et peut être moins lisible) ou d'utiliser
tuple (plus rapide, mais moins propre et pas encore officialisé)... Peut
être qu'un jour on aura en C++ le même concept de valeur que CAML? Sans
vouloir troller, C++ tend souvent à des constructions déjà présentes en CAML
entre autres. Peut être que CAML est un prototype de ce que pourrait
devenir C++ à très long terme...

Fabien LE LEZ wrote:

Supposons que je veuille créer une fonction qui renvoie
plusieurs valeurs, calculées conjointement et utilisées
conjointement.

Typiquement, je vais créer une classe pour l'occasion, qui a
priori ne contient que des données, pas de fonctions.

Et tant qu'à faire, étant donné que la classe et la fonction
n'ont aucune utilité l'une sans l'autre, autant que la
fonction en question soit le constructeur de la classe.

Je me retrouve donc avec pas mal de classes ayant les
caractéristiques suivantes :
- un constructeur, qui initialise les membres en faisant pas mal
de calculs ;
- aucune autre fonction non-const ;
- plusieurs objets membres publics ;
- rien de privé ni de protégé ;
- Il n'y a a priori aucune raison de créer un objet de cette
classe qui ne soit pas const.

Est-ce quelque chose d'habituel, qui a un nom ?

Je n'en connais pas de nom, mais je m'en sers assez souvent.
Typiquement, sans fonctions autre que le (ou les) constructeurs.
Et j'ai aussi des cas où ils ne sont pas const.

En gros, c'est un struct à la C, mais avec des constructeurs.
Mais je n'en connais pas d'autre nom.

Ou, au contraire, n'est-ce jamais utilisé car il y a une
faille que je n'ai pas vue ?

Je ne vois pas de faille particulière, autre que celles qu'ont
toutes les structs. Conceptuellement, c'est une struct à la C,
mais avec des facilites (et une garantie) d'initialisation. Et
on a beau dire, il y a des cas où une struct à la C, c'est ce
qui convient le mieux.

--
James Kanze GABI Software
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34