Discussion :

[clara1815]

Bonjour,
j'ai un TP en C++ ou je dois faire un programme sur les polynomes.
Il fallait donc que j'implemente la classe polynome definissant des polynomes a coeff constants, je fasse un constructeur et un destructeur, des operateurs, ==, !=, + et *. En fait mon probleme se trouve sur ces deux derniers, alors voila mon operateur+ , j'ai fait une fonction amie de la classe polynome :

Code :

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

1
2
3
4
5
6
7
8
9
polynome operator+(const polynome & P1,const polynome & P2)
{
        const polynome &S;
	for(int i=0;i<10;i++)
	{
		S.ptr[i]=P1.ptr[i]+P2.ptr[i];
	}
        return S;
}

Je pense que le soucis est au niveau du retour.
Merci d'avance pour votre aide

[Spout]

Je pense que le soucis est au niveau du retour

Ok, mais quel soucis?

De toute façon, ce n'est pas comme cela que l'on définit un opérateur pour une classe (je ne te demande même pas comment tu as fait le == et le !=). L'opérateur doit être membre de la classe auquel il réfère.
Une rapide recherche dans le forum ou dans la FAQ te permettra de trouver des exemples de définition d'opérateurs.

Bon courage.

[Alp]

Ce code-là pourrait t'aider : http://www.developpez.net/forums/d56...que-variables/

[Luc Hermitte]

Non spout.
Un opérateur est (généralement ; il y a des exceptions) libre et non ami ; pour des raisons de symétrie et de conversions implicites.
L'implémentation typique étant (généralement) basée sur une opération d'ajout.

Dans tous les cas son problème, simple à voir, est lié au fait qu'elle attaque les indices sans rien avoir réservé au préalable.

Dans son cas, on pourrait imaginer un :

Code :

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

1
2
3
4
5
Polynome operator+(Polynome const& lhs, Polynome const& rhs) {
    Polynome res (/*à copier*/lhs, /*pour forcer la taille max*/ max(lhs.size(), rhs.size());
    res += rhs;
    return res;
}

[JolyLoic]

L'opérateur doit être membre de la classe auquel il réfère.

Ca n'est pas obligatoire, et dans le cas de l'opérateur+, c'est même une bonne idée de le mettre en fonction libre. Il est prévu de détailler ça dans la prochaine version de la FAQ:

J'ai pour surcharger mon opérateur la possibilité d'utiliser une fonction membre ou une fonction libre, que choisir ?


Par exemple, pour définir un opérateur + dans une classe A, on peut écrire :
Version avec une fonction membre

Code :

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

1
2
3
4
class A
{
	A operator+(A const & second);
};

Version avec une fonction libre

Code :

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

1
2
3
4
5
6
 
class A
{
};
 
A operator+(A const &first, A const &second);

Quelle est la version préférable ? En général, pour un opérateur binaire, la fonction libre, car elle respecte la symétrie que l'on s'attend à trouver entre les opérandes d'un tel opérateur, alors que la fonction membre considère que l'élément sur lequel elle agit (le this) doit être exactement du type voulu.

En particulier, imaginons que l'on puisse convertir un entier en une variable de type A (par exemple si A possède un constructeur non explicite prenant uniquement un entier en paramètre). Alors, on a le comportement suivant :
Version avec une fonction membre

Code :

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

1
2
3
4
A a1, a2;
a1 + a2; // Ok
a1 + 42; // Ok
42 + a2; // Ne compile pas

Version avec une fonction libre

Code :

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

1
2
3
4
A a1, a2;
a1 + a2; // Ok
a1 + 42; // Ok
42 + a2; // Ok

Il y a par contre des opérateurs que l'on n'a le droit de surcharger que comme fonction membre : operator=, operator(), operator[] et operator->

[3DArchi]

Bonjour,

Code :

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

1
2
3
4
polynome operator+(const polynome & P1,const polynome & P2)
{
        const polynome &S;
}

Il doit y avoir une erreur de typo, parce que en général ça ne compile pas: une référence doit être initialisée. En plus, si c'est const, ça ne peut être modifié.

[le_duche]

Pourquoi avoir déclaré
const polynome &S;
et non
const polynome S;
???
L'objet doit de toutes façons être copié puisque celui créé dans la fonction sera détruit à sa sortie.

[Klaim]

D'ailleurs S ne devrait même pas être constant... sauf si S.ptr[i] est constant et passe par du mutable pour effectuer l'assignation...