double Complexe::GetMod()
{
if ( PolUtD)
return Mod;
else
return ( sqrt(Im*Im+Re*Re));
}

j´en peut plus, j´ai une procédure toute simple et là rien ne marche : même quand PolUtD ( qui est un bool) est faux le programme exécute quand même le return Mod;

je comprend pas pourquoi.
J´ai certainement fait une erreur stupide dans ma classe. Donc peut-être que quelqu´un a déjà fait se genre d´erreur et pourrait vois d´ou ça vient.
Parce que là, vraiment, je patauge.

Montre nous ta classe entière?

Au risque de dire une bêtise, pourquoi ne mettrais-tu pas if(!PolUtD) ?

C´est une classe pour compter avec les nombres complexes ?

oui c´est pou compter avec des nombre complexe

finalement c´était tout con, un problème stupide ou j´avais oublié de mettre des parenthèses dans une autre fonction qui appelait celle là. Mais comme c´étati dans une expression, il ne faisait pas d´erreur par contre je comprend quand même pas pourquoi il agissait comme ça. c´est bizarre.

si tu as retaper ici le code plutot que le paster depuis ton source, vérifies que t´as pas un ; apres le premier if
sinon, compiles en debug et traces l´execution

( sans les fautes, c´est mieux : -er +é -o +ô -e +é )

non c´est bon, c´est dans une autre fonction que j´avais oublié de mettre les parenthèse lors de l´appel de la fonction.

mais je ne comprend quand même pas pourquoi ça se passait comme ça.
j´ai bien fait une exécution pas à pas et ma fonction est appelé au bon endroit, mais elle agit n´importe comment.

enfin bon, le problème est résolu c´était tout bête, mais c´est souvent les problèmes les plus dur à retrouver ( enfin a pars dans les vraise projets très compliqué, mais ça me concerne pas encore).

ben moi j´ai abandonné ta classe, paske tout était très bien écrit et tout, mais ça beuguait à mort à l´exec...

c´est pour ça qu´il faut pas le faire en mode objet mais en programmation fonctionnelle, c´est beaucoup plus simple.

c.à.d?
Ne pas faire de classe? Juste surcharger les opérateurs, avec une structure?

non, ne pas surcharger les opérateur :

tu fait une struct
dans le genre :

struct Nombre
{
char chiffre[1000];
int PosDecimal;
};

et ensuite des fonction :

void add(Nombre*,Nombre*)
ou alors au pire
Nombre add(Nombre,Nombre)
mais la première méthode est mieux si elle écrit directement sur l´un des deux arguments.

et c´est que des fonction, pas de class, pas de surcharge d´opérateur et les trois quart des bug en moins.

vous avez vu ? bush est en train de gagner c´est terrible ( il a 57% des vois et 92% des grands électeur pour l´instant).

Bush ne vaincra pas ! En tout cas il n´a pas intêret

Tiens j´en profite pour vous poser une question, à quoi ça peut bien servir de surcharger les noms de fonction ?

c´est pour faire plus joli :

si t´as une fonction qui convertit les int en char* et une autre qui convertit les float en char* alors plutot que de faire :

char *itc(int);
char *ftc(float);

tu fait :
char *NombreToChar(int);
char *NombreToChar(float);

t´écrit le corps des deux fonctions comme tu le ferais normallement et ensuite dans ton code, tu ne te préoccupe plus que tes nombres soit des entier ou des flottant tu les pase juste à la fonction et tu récupère une chaine de caractère.

pour bush, ça à l´air d´être mal partit ( c´est a dire bien partit pour lui quoi) affaire à suivre.

Merci de ton aide