Discussion :

[Zavonen]

Rebonjour !
Je poursuis mon travail en développant la classe 'polynome' classe 'template' basée sur la classe 'template' monome (voir discussion précédente).
L'objet 'monome' n'a en fait que deux données (qui sont maintenant 'private' grâce à vous...). Il est donc facile d'écrire des méthodes publiques d'accès en lecture écriture, mais ce n'est pas la solution que j'ai choisie.
Les méthodes privées ou publiques des polynomes doivent impérativement manipuler les monomes, il est donc souhaitable de leur donner un acces direct aux données protégées des monomes.
On fait cela habituellement en déclarant la classe polynome 'amie' de la classe 'monome'. Tout le monde sait faire cela avec des classes 'normales'.
Prédéclaration de la classe candidate à l'amitié, déclaration d'amitié dans la définition de la classe à manipuler.
J'ai essayé de transposer cela fort logiquement en utilisant des déclarations 'template' autant de fois que la logique de la chose y oblige, mais en vain...
Je n'ai pas trouvé la bonne syntaxe.
Je vous mets donc à nouveau à contribution s'il vous reste un peu de temps, sachant que j'ai déjà fureté sur le web mais que je n'ai pas trouvé la solution claire, simple et satisfaisante qui doit forcément exister.

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
template <typename T>
class monome
{
private:
    T coefficient;
    exposant_multiple exposant;
public:
    // constructeurs
    monome();
    monome(T,exposant_multiple&);
    virtual ~monome();
    monome& operator* (monome& other);
    monome& operator= (monome& other);
    bool est_nul();
    template <typename X>
    friend ostream& operator<< (ostream& os, monome<X>& M);
};

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
template <typename T>
class polynome
{
private:
    unsigned int nombre_de_termes;
    monome<T> * termes;
public:
    //constructeurs
    polynome(int );
    virtual ~polynome();
    monome<T>& operator[](unsigned int);
    // teste si aucun monome nul dans la somme
    bool est_propre();
    // enlève le monome de rang i
    void supprime(unsigned int );
    // supprime le premier monome nul
    void enleve_premier_nul();
    // supprime tous les monomes nuls
    void nettoie();
    template <typename X>
    friend ostream& operator<< (ostream& os, polynome<X>& );
};

PS: la classe polynome n'est qu'à l'état d'ébauche, il est trop tôt pour y apporter des critiques de fond (d'ailleurs monome n'est pas finie non plus, il manque pour les deux le degré, la somme des polynomes, le produit des polynomes, les puissances, etc...)

[Zavonen]

AVANT la déclaration de la classe monome
template <typename T>
class polynome; // sans paramètre

DANS la définition de monome:

friend class polynome <T>; // sans template préalable

La logique de tout cela ????

[coyotte507]

Salut,

dans ton cas, vu que T a déjà été déclaré comme le template de monome, il faut que ce T soit le même que pour ta classe polynome si tu veux qu'elles soient amies.
(une classe monome<int> sera amie avec une classe polynome<int>, une classe monome<float> avec une classe polynome<float>, etc.)

Code :

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

1
2
3
4
5
6
template <typename T>
class polynome
{
private:
    unsigned int nombre_de_termes;
    monome<T> * termes;

Il n'y a pas de problèmes, c'est le cas. C'est comme avec les itérateurs, on est obligés de dire de quel type il s'agit:

Code :

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

std::vector< TonType >::iterator it;

Le langage ne nous permet pas d'écrire

Code :

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

std::vector::iterator it;

C'est dommage que le compilateur aie besoin de tant de précisions mais bon...
On arrive quand même à faire ce qu'on veut.

[Zavonen]

@coyotte507
A ce propos, une question que je me pose et à laquelle j'aurai très vite la réponse avec mon programme (pas le temps maintenant) est la suivante:
Il y a entre les types prédéfinis des promotions automatiques, par exemple
int--> float-->double, elles peuvent se faire sans perte de précision
char-->short-->long
ou avec perte
int-->float
En cas de conversion avec perte, on s'en tire en général avec un warning à la compilation, et 'à Dieu Vat' à l'exécution.
Je peux avec mes classes construire des monômes à coefficients int, quand à mes polynômes à coefficients double, ils sont normalement fabriqués à partir de monômes à coefficients du même type.
Cependant, la promotion automatique des int en double, induit-elle le même comportement au niveau des monomes 'templates' ?
Bref, peut-on construire directo des polynomes double à partir de monomes (déclarés) int ?
Si ce n'est pas possible directement il y a peut être quelque chose à faire (par exemple une surcharge d'un opérateur de cast).
Dans la pratique le problème ne se pose guère, les coefficients entiers sont acceptés pour les monomes 'double' sans même un avertissement.
C'est juste la curiosité.

[Jean-Marc.Bourguet]

Cependant, la promotion automatique des int en double, induit-elle le même comportement au niveau des monomes 'templates' ?

Non.

Bref, peut-on construire directo des polynomes double à partir de monomes (déclarés) int ?
Si ce n'est pas possible directement il y a peut être quelque chose à faire (par exemple une surcharge d'un opérateur de cast).

Un constructeur avec un paramètre sans valeur par défaut et non déclaré explicit est une convertion implicite.