Bonjour,

Je viens de développer une class Complexe qui a pour but de réaliser des opérations sur les nombres complexe tel que l´addition, soustraction, multiplication et division.
Elle dispose aussi de méthode comme pour récupérer l´argument et le module d´un nombre complexe.

Enfin trève de bavardage, je vous laisse examiner tout ceci .
Il risque surement d´y avoir de grosse grosse erreurs mais merci de me le faire parvenir :D.

ps : je n´ai pas vérifié le cas de la division par zèro, mais je pense le faire plus tard.

lien :
http://perso.orange.fr/leirbag/Complexe.zip

Fort sympathique !

bon debut ;

1/ la forme canonique n´est pas complete
2/ code non const-correct
3/ accesseurs non standard
4/ operateurs _= non standard
5/ utiliser les lists d´init
6/ utiliser le return value optim

pour etre tatillon :
- code peu efficace par endroit
- forcer l´alignement
- si temps critique, vectoriser les calculs

apres on peut regarder le detail ; c´est une critique globale, donc on prend ce qu´on veut

Perso, je trouve que de répartir l´implémenation sur plusieurs fichier n´améliore pas la clartée du code.

De plus, question qui me turlupine :
Ne faut il pas :
"return *new Complexe(m_nReel, -m_nImaginaire);"
ne fait il pas un trou de memoire si on ne fait pas de "delete" ?

LGV :

Merci pour ces critiques dont je tiendrais compte et dont je vais modifier le code en conséquence. Il y a juste un point que je comprends pas c´est :

- forcer l´alignement

KouicKouic :

En ce qui concerne l´implémentation de plusieurs fichiers, c´est une habitude que je commence à prendre afin de ne pas avoir un fichier qui tiend sur plus de 4 000 lignes de code, et c´est beaucoup plus pratique pour réaliser les Test Unitaire par la suite , enfin à mon avis c´est au gout de la personne, c´est vrai que ca peut être très moche pour certains et très bien pour d´autre .

Et en ce qui concerne le new, tu as tout à fait raison, c´est une erreur de ma part (j´avais prévenu et je vais en tenir compte lors des prochaines modifications.

en passant je ferai noter:
if(resultat.ModuleCarre() < 0.00000001)
return true;
Il existe dans la lib c++, une facon de récupérer la plus petite valeure stockable en flottant. Je pense qu´il s´agit également de la borne pour etre conforme à flottant(qui est de l´ordre de 10 -7)
Tu peux l´obtenir avec numeric_limits<float>::epsilon()
j´imagine qu´il est defini egalement sur les double.

Donc j´ai essaié d´arranger la class (je n´ai pas fini de modifier tout, en ce qui concerne les remarques tel que la forme canonique)

lien :
http://perso.orange.fr/leirbag/Complexe.zip

LGV :

- J´ai standardisé les accesseurs

- Code const-correct je pense maintenant

- J´utilise les listes d´initialisations, même si j´ai vu que c´était inutile pour les types de base (int, cehar, double ...etc) mais je préfére le faire par cohérence

- operator _= supprimé, par contre ils sont devenus standart je crois depuis la dernière norme de C++, enfin à vérifier

- Calcul vectoriser pour un gain de temps (je pense que j´en ai pas oublié)

Sinon le reste j´ai pas trop touché, je pense que la dernière chose que je ferais c´est la forme canonique

KouicKouic :

Rajoute des delete comme convenu

godrik :

Merci pour l´astuce, je ne connaissais pas du tout cette librairie , j´ai donc effectué le changement et effectivement il existe un epsilon pour les double.

Je n´ai pas vraiment regarder le code, mais lorsque je vois une ligne comme (tiré du main.cpp):
delete c3;
*c3 = c1 - c2;
je sais qu´il y a un probleme.

Pourquoi utiliser new dans tes surcharges d´opérateur ? Cela complique inutilement les choses.

Bonjour, je suis bien obligé car si je passerai pas par un new dans mes surcharges d´operator, mon objet serai détruit par la suite donc il me serait impossible de chainer mes surcharges.

Exemple sans new :

ob1 = ob2 + ob3; // Marche
ob1 = ob2 + ob3 + ob4; // Marche pas

Exemple avec new :

ob1 = ob2 + ob3; // Marche
ob1 = ob2 + ob3 + ob4; // Marche

Je te l´accorde la synthax est loin d´être belle mais si quelqu´un à une solution je suis totalement preneur

Hop, je rerépond en cause de ma faute , tu as tout à fait raison, même si ma technique est juste elle est loin d´être bien (appel de constructeur + allocation sur le tas), j´avais appris à éviter d´appeler le constructeur par recopie mais je viens de m´apercevoir que pour chainer des objets, on est obligé ! donc j´ai édité le lien avec le nouveau code source sans new et delete , et je m´en escuse encore ;)

En tous cas merci KouicKouic, d´avoir insister dessus, ca m´a permis de comprendre certaines choses

je penses que kufa nous a présenter (il y a un peu de temps) une technique pour eviter ces recopies en utilisant des fonctions template.
Mais c´est assez compliqué a comprendre.

pour reference, un article de gamedev expose cette technique d´optim du code de sortie par templates

Oui mon code est juste une implementation amelioree et etendue de cet article (je dois avoir mis le lien dans mon code de toute facon).
Je travaille sur une version sse (et xboite), mais ca optimise pas autant que je voudrait, j´y travaille! (pour info, il ne faut pas utiliser les const references avec les __m128 sinon il ya du load/save sur la stack)