Un problème d'amitié

Version imprimable

Bonjour à tous !
Je suis en train d'implémenter une classe de polynômes à coefficients dans un ensemble de nombres appartenant à un type prédéfini quelconque et possédant un nombre de variables quelconque.
Tout marche à peu près bien, mais j'ai quand même un problème avec une classe 'intermédiaire', la classe monome qui est une classe 'template' réutilisée par 'polynome' elle-même template' donc.
J'ai besoin de faire des sorties sur écran ou sur fichier, et j'utilise pour cela une méthode classique consistant à surcharger l'opérateur <<.
Voici mon problème:
Tout d'abord, le code ci-joint fonctionne:
Code:

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 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 #ifndef MONOME_H #define MONOME_H #include "exposant_multiple.h" template <typename T> class monome { public: T coefficient; exposant_multiple exposant; public: // constructeurs monome(); monome(T,exposant_multiple&); virtual ~monome(); monome& operator* (monome& other); monome& operator= (monome& other); }; template <typename T> monome<T>::monome() { //ctor } template <typename T> monome<T>::monome(T c,exposant_multiple& m) { //ctor coefficient=c; exposant=m; } template <typename T> monome<T>::~monome() { //dtor } // sortie sur écran ou sur fichier texte template <typename T> ostream& operator<< (ostream& os, monome<T>& M) { if (M.coefficient>0) os<<"+"; os<<M.coefficient; os<<M.exposant; return os; } template <typename T> monome<T>& monome<T>::operator* (monome<T>& other) { T coef= coefficient*other.coefficient; exposant_multiple* expo =new exposant_multiple((*this).exposant+other.exposant); monome<T>* result=new monome(coef,*expo); return *result; } template <typename T> monome<T>& monome<T>::operator= (monome<T>& other) { coefficient=other.coefficient; exposant=other.exposant; return *this; } #endif // MONOME_H
Mais vous pouvez remarquer qu'il n'y a pas de protection des données, et pour cause, si je déclare les données membres privées, et que je fais une déclaration d'amitié pour l'opérateur surchargé. J'obtiens un warning et une erreur de linkage.
Voici une version du même fichier avec les passages incriminés en rouge et les messages d'erreur à la compilation.
Si quelqu'un peut m'expliquer ???
Code:

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 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 #ifndef MONOME_H #define MONOME_H #include "exposant_multiple.h" 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); friend ostream& operator<<(ostream&,monome&); }; template <typename T> monome<T>::monome() { //ctor } template <typename T> monome<T>::monome(T c,exposant_multiple& m) { //ctor coefficient=c; exposant=m; } template <typename T> monome<T>::~monome() { //dtor } // sortie sur écran ou sur fichier texte template <typename T> ostream& operator<< (ostream& os, monome<T>& M) { if (M.coefficient>0) os<<"+"; os<<M.coefficient; os<<M.exposant; return os; } template <typename T> monome<T>& monome<T>::operator* (monome<T>& other) { T coef= coefficient*other.coefficient; exposant_multiple* expo =new exposant_multiple((*this).exposant+other.exposant); monome<T>* result=new monome(coef,*expo); return *result; } template <typename T> monome<T>& monome<T>::operator= (monome<T>& other) { coefficient=other.coefficient; exposant=other.exposant; return *this; } #endif // MONOME_H
Citation:

taire\Mes documents\bidon\polynomes\monome.h:19: warning: friend declaration `std::ostream& operator<<(std::ostream&, monome<T>&)' declares a non-template function
taire\Mes documents\bidon\polynomes\monome.h:19: warning: (if this is not what you intended, make sure the function template has already been declared and add <> after the function name here) -Wno-non-template-friend disables this warning
)]+0x37):: undefined reference to `operator<<(std::ostream&, monome<float>&)'
)]+0x55):: undefined reference to `operator<<(std::ostream&, monome<float>&)'
:: === Build finished: 2 errors, 2 warnings ===

08/12/2007, 11h25
gelam
essaie de corriger la déclaration d'amitié
Code:

1 2 friend ostream& operator<<(ostream&,monome<T>&);
08/12/2007, 11h50
Zavonen

Merci, je viens d'essayer mais c'est toujours pareil.

Il s'agit d'un ami qui est aussi un patron (c'est possible ça? ;) ).
Il doit rester un patron avant d'être un ami !

Code:

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);
 
    template <typename X>
    friend ostream& operator<<(ostream&,monome<X>&);
};

Essaie ça et dis si ça marche.

08/12/2007, 13h53
Zavonen

J'ai essayé exactement la même chose avec T au lieu de X (sans succès).
08/12/2007, 14h30
Biozic

Non, pas avec T. Les paramètres template doivent être indépendants.
08/12/2007, 15h37
Zavonen

Désolé, mais cela non plus ne marche pas.
Il me signale qu'un des membres est privé et situe l'erreur sur la première déclaration de 'template' suivant la fin de la définition de la classe.
???????????????????????
08/12/2007, 16h20
Biozic

Bizarre. Le code compile chez moi, et fonctionne (aux fuites de mémoire près dans operator*). J'ai juste mis une classe exposant_multiple basique (j'ai pas le code original) et ajouté la correction que j'ai proposée.
08/12/2007, 16h55
Jean-Marc.Bourguet

J'ai pas tout lu, mais quand je vois template et amitié dans la même phrase plus le warning de g++, j'ai tendance à penser que http://www.developpez.net/forums/sho...34&postcount=9 est pertinent.
08/12/2007, 17h59
Zavonen

Citation:

Bizarre. Le code compile chez moi, et fonctionne (aux fuites de mémoire près dans operator*). J'ai juste mis une classe exposant_multiple basique (j'ai pas le code original) et ajouté la correction que j'ai proposée.

Avec quel environnement travailles-tu ?
Je peux poster ma classe exposant_multiple si tu veux mais je ne crois pas que ça vienne de là, c'est une classe ordinaire sans patron et également basique.
Pour info, je travaille en ce moment sous EDI code::blocks compilateur Mingw SE Windows XP. J'ai beaucoup d'autres environnements possibles.
L'article de J-M Bourquet contient sans doute la réponse à ma question mais je ne sais pas l'extraire (un peu compliqué pour mon niveau de compétence C++).
A vrai dire je n'arrive même pas à isoler mon cas.
J'avais dans un premier temps essayé de rajouter <> lors de l'appel comme le suggère le warning, mais l'appel de l'opérateur surchargé << suivi de cette décoration nous donne qqch comme <<<> (non ?), et alors là gcc n'est pas content du tout.

@Biozic
Si tu veux faire un essai avec ma classe exposant multiple
voici le header et l'implémentation

Code:

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
#ifndef EXPOSANT_MULTIPLE_H
#define EXPOSANT_MULTIPLE_H
#include <string>
#include <stdlib.h>
 
using namespace std;
 
class exposant_multiple
{
private:
    // comme son nom l'indique
    unsigned int nombre_de_variables;
    // le tableau des exposants pour X1,X2,....,Xn
    unsigned int * exposants;
public:
    // constructeurs
    exposant_multiple();
    exposant_multiple(int);
    // de copie
    exposant_multiple(exposant_multiple &other);
    //destructeur
    virtual ~exposant_multiple();
    //affectation
    exposant_multiple& operator= (exposant_multiple&);
    // test égalité
    bool operator==(exposant_multiple&);
    // accès aux exposants individuels
    unsigned int& operator[] (unsigned int i);
    // règle d'addition
    exposant_multiple& operator+ (exposant_multiple &other);
    // représentation comme chaîne pour affichage
    friend ostream& operator<< (ostream& os,exposant_multiple e);
    // affectation
protected:
 
};
 
 
 
#endif // EXPOSANT_MULTIPLE_H

implémentation:

Code:

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
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
#include "exposant_multiple.h"
 
unsigned int max(unsigned int i, unsigned int j)
{
    return (i>j)?i:j;
}
 
exposant_multiple::exposant_multiple()
{
    //ctor
    nombre_de_variables=0;
    exposants=NULL;
}
 
 
exposant_multiple& exposant_multiple::operator= (exposant_multiple& other)
{nombre_de_variables=other.nombre_de_variables;
 unsigned int * nouveaux_exposants=new unsigned int [nombre_de_variables];
 for (unsigned int i=0;i<nombre_de_variables;i++)
 nouveaux_exposants[i]=other.exposants[i];
 delete [] exposants;
 exposants=nouveaux_exposants;
 return *this;
}
exposant_multiple::exposant_multiple(int n)
{
    //ctor
    nombre_de_variables= n;
    if (!n)
        exposants=NULL;
    else
        exposants= new unsigned int [n];
}
 
exposant_multiple::exposant_multiple(exposant_multiple& other)
{
    //ctor
    nombre_de_variables= other.nombre_de_variables;
    if (!nombre_de_variables)
        exposants=NULL;
    else
        exposants = new unsigned int [nombre_de_variables];
    for (unsigned int i=1;i<=nombre_de_variables;i++)
        (*this)[i]=other[i];
}
 
exposant_multiple::~exposant_multiple()
{
    if(exposants)
    delete[] exposants;
}
 
 
bool exposant_multiple::operator==(exposant_multiple& other)
{
    if (nombre_de_variables!=other.nombre_de_variables)
        return false;
    else
        for (unsigned int i=1; i<=nombre_de_variables;i++)
            if ((*this)[i]!=other[i]) return false;
    return true;
}
 
unsigned int& exposant_multiple::operator[] (unsigned int i)
{
    static unsigned int zero=0;
    if (i<=nombre_de_variables)
        return exposants[i-1];
    else
        return zero;
}
 
exposant_multiple& exposant_multiple::operator+ (exposant_multiple &other)
{
    unsigned int n=max(nombre_de_variables,other.nombre_de_variables);
    exposant_multiple * result  =new exposant_multiple(n);
    if (n>0)
    {
        for (unsigned int i=1;i<=n;i++)
            (*result)[i]=(*this)[i]+other[i];
    }
    return *result;
}
 
ostream& operator<< (ostream& os, exposant_multiple e)
{
    char in[3];
    char exp[3];
    if (!e.nombre_de_variables)
        os<<string("1");
    else
    {
        for (unsigned i=1;i<=e.nombre_de_variables;i++)
        {
            if (e[i])
            {
                os<<string("X");
                sprintf(in,"%d",i);
                os<<string(in);
                if (e[i]>1)
                {
                    sprintf(exp,"%d",e[i]);
                    os<<string("^")<<string(exp);
                }
            }
        }
    }
    return os;
}

08/12/2007, 18h17
Biozic

J'utilise gcc 4.2.1 sous Ubuntu. Je ne pense pas non plus que le pb vienne de la classe exposant_multiple.
08/12/2007, 18h22
Biozic

Citation:

Je ne pense pas non plus que le pb vienne de la classe exposant_multiple.

Confirmé avec ton code.

ecrire le prototype de la fonction operator<< en template avant le template de la fonction, ça ne résoud pas le problème ?
Code:

1 2 3 4 5 6 7 8 9 10 template <typename T> ostream& operator<<(ostream&,monome<T>&); template <typename T> class monome { (...) template <typename X> friend ostream& operator<<(ostream&,monome<X>&); }

08/12/2007, 18h59
Zavonen

Citation:

ecrire le prototype de la fonction operator<< en template avant le template de la fonction, ça ne résout pas le problème ?

Non, parce que la classe monome n'est pas encore définie.
Et si par malheur tu essaies de placer avant:
class monome;
comme on fait quelquefois quand on définit récursivement deux classes en même temps, alors là, c'est carrément une faute à chaque ligne.
08/12/2007, 19h02
Jean-Marc.Bourguet

Citation:

Envoyé par Zavonen

Non, parce que la classe monome n'est pas encore définie.
Et si par malheur tu essaies de placer avant:
class monome;

C'est un template, donc

Code:

template <typename T> class monome;

(J'ai l'intention de revenir et de regarder ton code en détail, mais ceci était facile).
08/12/2007, 19h21
Zavonen

Apparemment le problème n'est pas nouveau:
http://www.developpez.net/forums/arc...p/t-22604.html
Laurent Gomila a proposé une solution que je n'ai pas pu transposer. En effet
l'auteur du post à un pb tout à fait similaire au mien, mais dans sa surcharge de << il retourne le membre de droite et non l'ostream, ce qui à mon avis n'est pas un bon choix parce qu'on ne peut pas enchainer les <<.
En tout le cas tout le monde semble d'accord pour constater que
classes templates + amies = danger !
@ J-M Bourquet
OK pour ta remarque, j'ai compris, mais pas encore essayé.
08/12/2007, 19h42
Biozic
Je ne sais pas si c'est un problème ou un danger... En tout cas, je n'ai rien changé d'autre à ton code que

Code:

friend ostream& operator<<(ostream&,monome&);

en
Code:

1 2 template <typename X> friend ostream& operator<<(ostream&,monome<X>&);
puis mon main est :
Code:

1 2 3 4 5 6 7 int main(int argc, char* argv[]) { exposant_multiple d; monome<float> m(1.0f, d); cout << m << endl; return 0; }
et ça marche sous g++ 4.2 et vc2005.
L'affichage donne "+11".

C'est à n'y rien comprendre !
Je viens de réessayer ta suggestion. Cette fois ça marche !
MERCI...

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
int main()
{
    exposant_multiple m(2);
    exposant_multiple n(3);
    m[1]=1;
    m[2]=1;
    n[1]=0;
    n[2]=1;
    n[3]=1;
    monome<float> M(4,m);
    monome<float> N(3,n);
    //polynome <float> P(2);
    cout<<M<<endl;
    cout<<N<<endl;
    //P.termes[0]=M;
    //P.termes[1]=N;
    //cout<<P<<endl;
    return 0;
}

08/12/2007, 20h23
Zavonen

Alles klar !

Merci à tous.
Cette fois ça fonctionne.
La solution la plus simple de Biozic semble couvrir ce cas.
La première fois j'ai dû me planter en recopiant son code.
Je viens de réitérer la construction de la surcharge de << pour les polynômes qui sont, grosso modo, des tableaux de monômes, laquelle surcharge fait appel à son homonyme pour les monômes. Tout fonctionne comme il doit.
Il n'est pas impossible que je fasse encore appel à vous un peu plus tard pour un problème d'une toute autre nature.