Discussion :

[falcoman33]

Bonjour,
je dipose d une classe courbe sur laquel j ai cree une surcharge d operateur comme presenté ci dessous:

fichier .h

Code :

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

1
2
3
4
5
    class Courbe
    {
        public:
             Courbe* operator/ ( Courbe *a);
    }

fichier .c

Code :

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

1
2
3
4
    Courbe* Courbe::operator/ (Courbe *b)
   {
       return this->divise(b);
   }

dans une autre classe, j essaye de faire:

Code :

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

1
2
3
        Courbe *toto;
        Courbe *titi;
        resultat=toto/ titi;

Cela marche si toto et titi ne sont pas des pointeurs . Avec des pointeurs, j ai un message comme quoi je ,ne peux pas realsier cela sur des pointeurs. Un ami m a dit d essayer en mettant friend... je dois mal l appliquer cela ne marche pas non plus..

Quelqu un peut il m aider?

merci encore

[darkman19320]

Salut,

Première question: pourquoi utilises-tu des pointeurs? En as-tu vraiment l'utilité?

Ensuite, as-tu été sur la FAQ?

Comprends-tu pourquoi tu as une erreur?

L'utilisation de friend ici ne sert strictement à rien.

[falcoman33]

bonjour,

si je met :

Code :

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

1
2
3
4
5
 
         Courbe *toti;
        Courbe *tutu;
        Courbe *tata;
         tata=toti/tutu;

j ai l erreur suivante:
C:\Qt\ll\sans_titre9\mainwindow.cpp:719: erreur : C2296: '/' : illegal, left operand has type 'Courbe *'

si je ne met pas de pointeur ca marche....

sniif

[darkman19320]

Tu ne peux pas avoir 2 pointeurs sur un opérateur.
Lit la FAQ, ça te permettra d'apprendre comment effectuer une surcharge d'opérateur.

[jblecanard]

Tu ne peux pas utiliser des pointeurs et tant mieux car tu n'en as pas besoin : il faut utiliser des références constantes.

[ternel]

Et des fonctions libres pour les opérateurs mathématiques.

J'entends par là:

Code :

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

1
2
3
4
5
6
7
8
class Bidule {
public:
    Bidule(Bidule const&);
    Bidule& operator+=(Bidule const&);
};
inline Bidule operator+(Bidule const& a, Bidule const& b) {
    return Bidule(a)+=b;
}

[falcoman33]

Et des fonctions libres pour les opérateurs mathématiques.

J'entends par là:

Code :

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

1
2
3
4
5
6
7
8
class Bidule {
public:
    Bidule(Bidule const&);
    Bidule& operator+=(Bidule const&);
};
inline Bidule operator+(Bidule const& a, Bidule const& b) {
    return Bidule(a)+=b;
}

désolé de faire mon lourd... mais j ai essayé ce que tu m as dit..; et je ne m en sors pas.. avec mon pointeur même résultat... évidemment sans ca marche.


J'ai besoin de pointeur car je définie de manière dynamique mes courbes d'où le nom de la classe lol. Cet objet classe contient aussi d autres informations que les xy classiques d une courbe.

Bref je ne vois pas comment je peux m en sertir sans pointeur et j ai limpression que vous dites que ce ne st pas possible sans..

Au pire, je vais rester sans les surcharges d'operateur...

[jo_link_noir]

désolé de faire mon lourd... mais j ai essayé ce que tu m as dit..; et je ne m en sors pas.. avec mon pointeur même résultat... évidemment sans ca marche.

Diagnostique de l'erreur ? Et code reproductible stp.

[ternel]

La fonction n'a pas besoin d'un pointeur.
Par contre, si l'utilisateur a un pointeur, il peut tout à fait l'étoiler pour nourrir la référence.

je complète mon exemple:

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
class Bidule {
private:
    int v;
public:
    Bidule(int value) : v(value) {}
 
    Bidule(Bidule const&) = default;
    Bidule& operator=(Bidule const&) = default;
 
    Bidule& operator+=(Bidule const& v) {v+= other.v; return *this;}
    int value() const {return v;}
};
 
int value(Bidule const& b) {return b.value();}
 
inline Bidule operator+(Bidule const& a, Bidule const& b) {
    return Bidule(a)+=b;
}
 
int main() {
    Bidule a(1);
    Bidule b(2);
    Bidule c = a+b;
    Bidule *d = new Bidule(4);
    *d += c;
 
    const int v = value(*d+*d);
 
    delete d;
    return v;
}

PS: je n'utilise tellement plus delete qu'il a fallut que j'aille vérifier s'il y a besoin de parenthèses.

[jblecanard]

On ne l'a pas dit explicitement, mais pour que ça fonctionne correctement, il faut que tes courbes aient une sémantique d'entité. Et idéalement qu'elle respecte la règle du big five. Si tu ne respectes pas ça, tu t'exposes à des problèmes. L'implémentation de la sémantique de déplacement manque à l'exemple de leternel, même si ce ça ne représente pas un gain dans son exemple.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Bidule {
private:
    int v;
public:
    Bidule(int value) : v(value) {}
 
    Bidule(Bidule const&) = default;
    Bidule(Bidule&&) = default;  // Ici
    Bidule& operator=(Bidule const&) = default;
    Bidule& operator=(Bidule&&) = default;  // Ici
 
    Bidule& operator+=(Bidule const& other) {v+= other.v; return *this;}
    int value() const {return v;}
};

Si tu veux écrire du code tout dynamique, il faudrait, en reprenant le code de leternel, écrire comme ceci:

Code :

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

1
2
3
4
5
6
7
int main() {
  std::unique_ptr<Bidule> b1(new Bidule(1));
  std::unique_ptr<Bidule> b2(new Bidule(2));
  std::unique_ptr<Bidule> b3(new Bidule(*b1 + *b2));
  std::cout << b3->value() << std::endl;
  return 0;
}

[ternel]

Certes, mais j'exposais explicitement la manipulation de pointeurs nus.
Et toutes les variables n'ont pas forcément à être des pointeurs.

En pratique, un opérateur ne peut être définit que si l'un des arguments (au moins) est un "user defined type", c'est à dire une structure, une classe ou une union.
Note qu'au sens de la norme, les classes définies dans la STL sont des "user defined types".

Sauf si le sens est extrèmenent important, je suggère de ne jamais concevoir une fonction membre avec des pointeurs.
Entre les surcharges, les références et optional (boost::optional ou optional-lite, en attendant std::optional), il y a largement de quoi s'en passer.
La seule exception notable étant const char*.

Jamais restant synonyme de "tant que je n'ai pas une excellente raison, preuve à l'appui"

[Médinoc]

J'ai besoin de pointeur car je définie de manière dynamique mes courbes d'où le nom de la classe lol. Cet objet classe contient aussi d autres informations que les xy classiques d une courbe.

Bref je ne vois pas comment je peux m en sertir sans pointeur et j ai limpression que vous dites que ce ne st pas possible sans..

Au pire, je vais rester sans les surcharges d'operateur...

Plutôt que faire tout avec des pointeurs nus, écris-toi une classe qui contient le pointeur et gère sa durée de vie (et implémente (ou interdit) les constructeurs de copie, déplacement, etc.) et donne-lui les opérateurs.

[falcoman33]

apres un long moment d 'absence.. je me remet à mon probleme...

Je viens d essayer ce que tu mas ecrit mais... il ne connait pas default... je l ai donc enleve...

j utilise qt Creator... normal?

sur la ligne :
Bidule c = aa+bb;

j ai le message :
C:\Qt\ll\sans_titre14\main.cpp:12: erreur : C2512: 'Bidule' : no appropriate default constructor available
et ce message:
C:\Qt\ll\sans_titre14\main.cpp:12: erreur : C2678: binary '+' : no operator found which takes a left-hand operand of type 'Bidule' (or there is no acceptable conversion)
e:\Langage_Programmation\qt-4.8.6-x64-msvc2010\include\QtCore/qbytearray.h(564): could be 'const QByteArray operator +(const QByteArray &,const QByteArray &)'
e:\Langage_Programmation\qt-4.8.6-x64-msvc2010\include\QtCore/qbytearray.h(566): or 'const QByteArray operator +(const QByteArray &,const char *)'
e:\Langage_Programmation\qt-4.8.6-x64-msvc2010\include\QtCore/qbytearray.h(568): or 'const QByteArray operator +(const QByteArray &,char)'
e:\Langage_Programmation\qt-4.8.6-x64-msvc2010\include\QtCore/qbytearray.h(570): or 'const QByteArray operator +(const char *,const QByteArray &)'
e:\Langage_Programmation\qt-4.8.6-x64-msvc2010\include\QtCore/qbytearray.h(572): or 'const QByteArray operator +(char,const QByteArray &)'
e:\Langage_Programmation\qt-4.8.6-x64-msvc2010\include\QtCore/qstring.h(1021): or 'const QString operator +(const QString &,const QString &)'
e:\Langage_Programmation\qt-4.8.6-x64-msvc2010\include\QtCore/qstring.h(1023): or 'const QString operator +(const QString &,QChar)'
e:\Langage_Programmation\qt-4.8.6-x64-msvc2010\include\QtCore/qstring.h(1025): or 'const QString operator +(QChar,const QString &)'
e:\Langage_Programmation\qt-4.8.6-x64-msvc2010\include\QtCore/qstring.h(1028): or 'const QString operator +(const QString &,const char *)'
e:\Langage_Programmation\qt-4.8.6-x64-msvc2010\include\QtCore/qstring.h(1030): or 'const QString operator +(const char *,const QString &)'
e:\Langage_Programmation\qt-4.8.6-x64-msvc2010\include\QtCore/qstring.h(1032): or 'const QString operator +(char,const QString &)'
e:\Langage_Programmation\qt-4.8.6-x64-msvc2010\include\QtCore/qstring.h(1034): or 'const QString operator +(const QString &,char)'
e:\Langage_Programmation\qt-4.8.6-x64-msvc2010\include\QtCore/qstring.h(1036): or 'const QString operator +(const QByteArray &,const QString &)'
e:\Langage_Programmation\qt-4.8.6-x64-msvc2010\include\QtCore/qstring.h(1038): or 'const QString operator +(const QString &,const QByteArray &)'
e:\Langage_Programmation\qt-4.8.6-x64-msvc2010\include\QtCore/qsize.h(85): or 'const QSize operator +(const QSize &,const QSize &)'
e:\Langage_Programmation\qt-4.8.6-x64-msvc2010\include\QtCore/qsize.h(235): or 'const QSizeF operator +(const QSizeF &,const QSizeF &)'
e:\Langage_Programmation\qt-4.8.6-x64-msvc2010\include\QtCore/qpoint.h(82): or 'const QPoint operator +(const QPoint &,const QPoint &)'
e:\Langage_Programmation\qt-4.8.6-x64-msvc2010\include\QtCore/qpoint.h(240): or 'const QPointF operator +(const QPointF &,const QPointF &)'
e:\Langage_Programmation\qt-4.8.6-x64-msvc2010\include\QtGui/qtransform.h(386): or 'QTransform operator +(const QTransform &,qreal)'
while trying to match the argument list '(Bidule, Bidule)'

normal?

merci

La fonction n'a pas besoin d'un pointeur.
Par contre, si l'utilisateur a un pointeur, il peut tout à fait l'étoiler pour nourrir la référence.

je complète mon exemple:

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
class Bidule {
private:
    int v;
public:
    Bidule(int value) : v(value) {}
 
    Bidule(Bidule const&) = default;
    Bidule& operator=(Bidule const&) = default;
 
    Bidule& operator+=(Bidule const& v) {v+= other.v; return *this;}
    int value() const {return v;}
};
 
int value(Bidule const& b) {return b.value();}
 
inline Bidule operator+(Bidule const& a, Bidule const& b) {
    return Bidule(a)+=b;
}
 
int main() {
    Bidule a(1);
    Bidule b(2);
    Bidule c = a+b;
    Bidule *d = new Bidule(4);
    *d += c;
 
    const int v = value(*d+*d);
 
    delete d;
    return v;
}

PS: je n'utilise tellement plus delete qu'il a fallut que j'aille vérifier s'il y a besoin de parenthèses.

[Médinoc]

Ah, Visual 2010 est trop vieux pour C++11, ce qui veut dire pas de default, pas de move semantics.

[falcoman33]

ce qui veut dire que je suis coincé..

[ternel]

Non, juste que tu codes en C++03, et que pour utiliser les fonctions "= default", c'est-à-dire telle que générées par le compilateur, tu ne les déclares simplement pas.
Ce sont les seules choses qui changent dans mon code.

A moins que tu ne trouves une option "C++0x", mais je ne sais pas ce que ca vaut vraiment.