Non, je vais encore plus loin. op+(T,T) marche et suffit pour T+A et A+T à condition qu'il y ait une conversion implicite de A vers T.
Maintenant, il peut s'avérer intéressant de proposer les surcharges pour des questions d'optimisation. Ainsi, ajouter directement un monôme de degré d à un polynôme économisera une allocation de mémoire et une boucle où l'on ajouterait plein de zéros (dans le cas des représentations vecteur) -- c'est aussi ce qui est fait dans le standard entre char const* et std::string.

PS:

Ok, Ok !!
Juste j'arrive pas/plus a trouver comment faire pour qu'il y est conversion implicite.

Faire un constructeur.

Polynome<T>::Polynome<T>(const& T A);

crée une conversion implicite de T vers Polynome<T>

J'étais pas loin j'avais juste oublié le const&, mais euh ... ça marche tjrs pas ! sniff !

EDIT :
J'ai lu quelque part que la conversion implicite ne fonctionnais pas pour les classes templates, et de fais dans mon test j'ai retransformer ma classe en non templates (sans modifié quoi que se soit d'autre) et ça fonctionne !!

Donc est-il vrai que la conversion implicite ne fonctionne pas en templates ??

non

Je me trompe où les exemples de divisions sur le wikipédia français sont complètement faux ?

En effet, celui-là est faux:

http://fr.wikipedia.org/wiki/Division_d'un_polynôme#Exemple_et_algorithme_2

EDIT: Pas faux en fait, mais n'est pas une division euclidienne...

Non ils sont les 2 justes relisez l'article correctement la deuxième n'est pas une division euclidienne. Et regardez les notes et références, je doute que le Laboratoire Jean Kuntzmann publie des démonstrations complétement faussés.

Pour le premier, j'avais mal recopié les polynômes de départ quand j'avais voulu jouer avec ^^'

Citation : Nanoc

Citation : pepetiti

Dites, je n'ai pas l'impression que ma réponse ait été prise en compte (pour le cryptage XOR), j'ai envoyé un mp à Reponse_Exercice mais le message est toujours en non lu, est-ce normal ?

Si si t'en fais pas. J'utilise lu/non-lu pour trier. Ton code faisait une lecture sur eof() -> pas OK.

EDIT: Plus de 1000 réponses !

D'accord, pardonnez mon ignorance c'est la première fois que j'ai posté une réponse alors je découvre un peut

Citation : guigui'

EDIT:
Bon, maintenant que j'ai ajouté la dérivée et les primitives j'ai plus trop d'idée d'ajout pour la classe ...
Donc a moins que quelqu'un est une idée d'ajout je vais pouvoir rendre ma copie !

Quelques idées rapidement (assez avancée théoriquement pour certaines):

1) Les polynomes peuvent être considérés comme des vecteurs d'un espace vectoriel. Pourquoi ne pas implémenter un produit scalaire et une norme ?

2) Les polynomes sont des fonctions, donc pourquoi ne pas implémenter une norme sur l'espace vectoriel des fonctions. http://fr.wikipedia.org/wiki/Norme_(mathématiques)#En_dimension_infinie

3) On peut implémenter une fonction solve(P,Q) qui résoud l'équation P(x) == Q(x).

Bien du plaisir...

Bon effectivement là ça peut donner un peu plus de boulo !

Ouh, ça devient trop dur pour moi (je suis en seconde)...

PS : Le TP de ton tuto a l'air sympa Nanoc, je le lis de suite .

Pour ce qui est de resoudre des équations type P(x) = 0 ou P(x) = Q(x) j'avoue ne pas trop voir comment s'y prendre !
Est-il possible d'avoir une petite indication pour ce mettre sur la piste ??

Niveau norme de l'espace vectoriel d'une fonction, j'ai pas compris de quoi il était question.

D'avance merci à ce qui m'aiderons dans ma quête de perfectionnement !

PS : Ton TP à l'air effectivement interesant, Nanoc !
PS 2 : j'ai tester ma classe polynome avec ta correction de la classe Fraction et je trouve le résultat assez géniale (de même avec complex<Fraction> ) !! Je crois que du coup je vais aussi essayer de la recréer (j'avais pas participer).

Citation : gymnopaul

Ouh, ça devient trop dur pour moi (je suis en seconde)...

C'est pour ceux qui veulent aller vraiment plus loin hein

Citation : guigui'

Pour ce qui est de resoudre des équations type P(x) = 0 ou P(x) = Q(x) j'avoue ne pas trop voir comment s'y prendre !
Est-il possible d'avoir une petite indication pour ce mettre sur la piste ??

Je ne vais pas donner un moyen de le faire (que je n'ai pas tester qui plus est), mais je peux donner deux pistes:
1) Algorithme de Newton.
2) Méthode de Horner.

Les deux ayant également besoin de la division euclidienne.

Pour l'espace vectoriel, laisse tomber si tu ne sais pas ce que c'est. Il faudrait un cours complet d'algèbre linéaire.

Ok, bas je vais suivre ces pistes on verra bien où ça va me mener !

Pour l'espace vectoriel je verrais après (ça doit correspondre à mes cours futur donc au pire c'est pas grave si je me documenter !^^)

bonjour , concernant les reponses qu'on t'envoie nanoc est ce normal que l'on a pas de retour(codes bien recu?,quelques commentaires?)

Oui. Les codes sont bien reçus, mais je ne les lis que quand la fin du mois arrive.

Ensuite, je ne cherche pas à corriger les codes reçus. Je n'ai malheureusement pas le temps pour ça. Si un code est bien et qu'il peut servir de correction, il est publié dans ce thread sinon, il ne se passe rien.

Citation : guigui'

J'étais pas loin j'avais juste oublié le const&, mais euh ... ça marche tjrs pas ! sniff !

EDIT :
J'ai lu quelque part que la conversion implicite ne fonctionnais pas pour les classes templates, et de fais dans mon test j'ai retransformer ma classe en non templates (sans modifié quoi que se soit d'autre) et ça fonctionne !!

Donc est-il vrai que la conversion implicite ne fonctionne pas en templates ??

Citation : lmghs

non

Je suis confronté au même problème et je n'arrive pas à le résoudre sans définir les opérateurs binaires (T,a) et (a,T) ..
Le problème est suffisamment décrit ici : http://bytes.com/groups/cpp/504602-com [...] erator-double

edit : <oups>j'aurais peut-être dû ouvrir un autre sujet..</oups>

Finalement, j'ai aussi observé le problème. Ce qui ma surpris. Il faudrait que je creuse pour voir ce qui cloche dans le cas template.

Bonjour, ma classe de polynômes avance bien cependant je fais face à une étrange difficulté.
J'ai défini la surcharge des opérateurs + entre 2 polynômes et << sur un flux mais lorsque je tente de faire :

cout << A + B << endl;

le compilateur m'insulte :

C:\Users\Fredos\Documents\Progz\C++\Polynomes\main.cpp||In function `int main(int, char**)':|
C:\Users\Fredos\Documents\Progz\C++\Polynomes\main.cpp|31|error: no match for 'operator<<' in 'std::cout << Polynome::operator+(const Polynome&)(((const Polynome&)((const Polynome*)(&B))))

alors que si je fais :

Polynome R = A + B;
cout << A << " + " << B << " = " << R << endl;

cela marche bien :

4x+3 + 2x-5 = 6x-2

J'ai beau tester plein de variantes, rien n'y fait... voyez-vous d'où peut venir le problème ?

Le prototype de mes fonctions :

class Polynome{
// ...
    Polynome operator+(const Polynome &);
// ...
    void affiche(std::ostream &) const;
// ...
}

std::ostream& operator<<(std::ostream &out, Polynome &Poly);

Tiens il me semble que j'avais le même problème !!!
Mais je suis en templates et bêtement je m'étais dis que ça devais avoir un lien apparemment pas !
Si quelqu'un à une idée qu'il hésite pas !

Dans un autre projet j'avais eu le même problème. Il me semble que j'avais posé la question sur le forum C++ et j'avais pu résoudre grâce au réponses données.

Vous êtes aller voir sur le forum ?

En épluchant tes anciens messages, j'ai trouvé le topic en question.

Il ne me reste plus qu'à comprendre ce que veux dire :

Citation : lmghs

Tu as pensé à _surcharger_ l'opérateur d'injection (<<()) pour les complexes (et de les recevoir par référence constante) ?

n'est-ce pas le même opérateur que << ?

edit : C'est bien le même opérateur, en effet j'avais oublié (... il me semble qu'il n'y est pas sur le tuto de Matéo) le 'const' dans :

std::ostream& operator<<(std::ostream &out, const Polynome &Poly);

Il est toujours mieux de déclarer ses opérateurs binaires A L'EXTERIEUR de la classe.

C'est pourtant le cas non ?

class Polynome{
// ...
    Polynome operator+(const Polynome &);
// ...
    void affiche(std::ostream &) const;
// ...
}

std::ostream& operator<<(std::ostream &out, const Polynome &Poly);

Et le operator+ ?

Oui en effet , mais dans ce cas il faudra lui coller l'attribut friend ?
En quoi cela est-il mieux de déclarer les opérateurs en dehors de la classe ?

Il doit y avoir au moins 25 posts dans ce forum à ce sujet et au moins 10 interventions dans ce thread. http://www.siteduzero.com/forum-83-392 [...] roisieme.html

Et ça résoudrait ton problème.

De plus le friend n'est pas obligatoire.

En effet, ça permet d'utiliser la conversion implicite pour symétriser les opérateurs et donc éviter du travail inutile.
Et si j'ai bien compris, le friend n'est pas obligatoire si l'on passe par operator+= qui lui n'est pas libre.

Merci beaucoup