Un problème d'amitié

**Zavonen** · 08/12/2007, 09h27

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 :

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
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 :

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
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

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 ===

**gelam** · 08/12/2007, 11h25

essaie de corriger la déclaration d'amitié

Code :

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

1
2
    
friend ostream& operator<<(ostream&,monome<T>&);

**Zavonen** · 08/12/2007, 11h50

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

**Biozic** · 08/12/2007, 12h40

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 :

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

Essaie ça et dis si ça marche.

**Zavonen** · 08/12/2007, 13h53

J'ai essayé exactement la même chose avec T au lieu de X (sans succès).

**Biozic** · 08/12/2007, 14h30

Non, pas avec T. Les paramètres template doivent être indépendants.

**Zavonen** · 08/12/2007, 15h37

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.
???????????????????????

**Biozic** · 08/12/2007, 16h20

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.

**Jean-Marc.Bourguet** · 08/12/2007, 16h55

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.

**Zavonen** · 08/12/2007, 17h59

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.

**Zavonen** · 08/12/2007, 18h13

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

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
#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 :

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
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;
}

**Biozic** · 08/12/2007, 18h17

J'utilise gcc 4.2.1 sous Ubuntu. Je ne pense pas non plus que le pb vienne de la classe exposant_multiple.

**Biozic** · 08/12/2007, 18h22

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

Confirmé avec ton code.

**Pacorabanix** · 08/12/2007, 18h32

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

Code :

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

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>&);
}

**Zavonen** · 08/12/2007, 18h59

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.

**Jean-Marc.Bourguet** · 08/12/2007, 19h02

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 :

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

template <typename T> class monome;

(J'ai l'intention de revenir et de regarder ton code en détail, mais ceci était facile).

**Zavonen** · 08/12/2007, 19h21

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é.

**Biozic** · 08/12/2007, 19h42

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 :

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

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

en

Code :

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

1
2
template <typename X>
friend ostream& operator<<(ostream&,monome<X>&);

puis mon main est :

Code :

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

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".

**Zavonen** · 08/12/2007, 20h03

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

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
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;
}

**Zavonen** · 08/12/2007, 20h23

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.

Un problème d'amitié

C++

Discussions similaires

Partager

Partager