Problème compilation

Bonjour,

Je passe du C au C++, et j'ai un petit probl=E8me avec un de mes
programmes.
A la compilation il n'y a pas d'erreur, mais le terminal s'ouvre s'en
rien afficher. Comme si il etait buger. Je ne peux que le fermer.
J'utiliser VS 2005.

D=E9sole pour la longeur du message. Merci d'avance a ceux qui auront le
courage de m'aider.

Cordialement P.

Voici les sortie de la compilation :

'FuzzyLib.exe' : Charg=E9 'C:\PowerDEVS\Atomics\MyModel\FuzzyLib\debug
\FuzzyLib.exe', Les symboles ont =E9t=E9 charg=E9s.
'FuzzyLib.exe' : Charg=E9 'C:\WINDOWS\system32\ntdll.dll', Aucun symbole
n'a =E9t=E9 charg=E9.
'FuzzyLib.exe' : Charg=E9 'C:\WINDOWS\system32\kernel32.dll', Aucun
symbole n'a =E9t=E9 charg=E9.
'FuzzyLib.exe' : Charg=E9 'C:\WINDOWS\WinSxS
\x86_Microsoft.VC80.DebugCRT_1fc8b3b9a1e18e3b_8.0.50727.42_x-
ww_f75eb16c\msvcp80d.dll', Les symboles ont =E9t=E9 charg=E9s.
'FuzzyLib.exe' : Charg=E9 'C:\WINDOWS\WinSxS
\x86_Microsoft.VC80.DebugCRT_1fc8b3b9a1e18e3b_8.0.50727.42_x-
ww_f75eb16c\msvcr80d.dll', Les symboles ont =E9t=E9 charg=E9s.
'FuzzyLib.exe' : Charg=E9 'C:\WINDOWS\system32\msvcrt.dll', Aucun
symbole n'a =E9t=E9 charg=E9.
Le programme '[1204] FuzzyLib.exe: Natif' s'est arr=EAt=E9 avec le code 0
(0x0).

La derni=E8re ligne c'est quand je ferme le terminal.

voici la pile d'apl :

FuzzyLib.exe!wmain(int argc=3D1, wchar_t * * argv=3D0x00355b30) Ligne 6 C+
+
FuzzyLib.exe!__tmainCRTStartup() Ligne 583 + 0x19 octets C
FuzzyLib.exe!wmainCRTStartup() Ligne 403 C
kernel32.dll!7c816fd7()
[Les frames ci-dessous sont peut-=EAtre incorrects et/ou manquants,
aucun symbole charg=E9 pour kernel32.dll]

Voici le code :

//prog de test :
/
***************************************************************************=
*****/
#include "FuzzyLib.h"

int _tmain(int argc, _TCHAR* argv[])
{
cout << "----- TEST -----" ;
FuzzyLib *A =3D new FuzzyLib(2,2,1,3);
FuzzyLib *B =3D new FuzzyLib(4,4,2,6);
FuzzyLib *res =3D new FuzzyLib();
cout << "affichage de A";
A->printFuzzyLib();
cout << "affichage de B";
B->printFuzzyLib();
*res =3D A->fuzzy_ADD(*B);
cout << "affichage de A+B";
res->printFuzzyLib();


system("PAUSE");
return 0;
}

/
***************************************************************************=
**/
// Classe :
/
***************************************************************************=
**/
#define WIN32_LEAN_AND_MEAN // Exclure les en-t=EAtes Windows rarement
utilis=E9s
#include <stdio.h>
#include <tchar.h>
#include <iostream>
using namespace std;
#pragma once

class FuzzyLib
{
private:
// Variables de classe
double lambda; // valeur en y de la courbe comprise entre 0 et 1
double a,b; // valeur les plus possiblee en x pour lambda =3D 1
double alpha, beta; // limite infereieur et superieur de la courbe
pour lambda =3D 0

public: // Fonctions
/
***************************************************************************=
*****/
/************************* get Set *****************************/
/
***************************************************************************=
*****/
inline double GetA(void) {return this->a;}
inline double SetA(double var) {this->a =3D var ;}
inline double GetB(void) {return this->b;}
inline double SetB(double var) {this->b =3D var ;}
inline double Get_alpha(void) {return this->alpha;}
inline double Set_alpha(double var) {this->alpha =3D var ;}
inline double Get_beta(void) {return this->beta;}
inline double Set_beta(double var) {this->beta =3D var ;}
/
***************************************************************************=
*****/
/****************** Constructeurs *****************************/
/
***************************************************************************=
*****/
FuzzyLib(void); // constructeur par defaut
FuzzyLib(double a, double b, double alpha, double beta); //
constructeur
FuzzyLib(double i); // constructeur simple
FuzzyLib(const FuzzyLib &I); // constructeur de copie
virtual ~FuzzyLib(void); // destructeur

/
***************************************************************************=
*****/
/************************* lambda *****************************/
/
***************************************************************************=
*****/
inline double left_part(double y) {return ( (a - alpha) * y +
alpha) ;}
inline double right_part(double y) {return ( beta - (beta - b) *
y) ;}

/
***************************************************************************=
*****/
/****************** manipulation *****************************/
/
***************************************************************************=
*****/
FuzzyLib& fuzzy_ADD( FuzzyLib &); // addition
FuzzyLib& fuzzy_SOUS( FuzzyLib &); // soustraction
FuzzyLib& fuzzy_MULT( FuzzyLib &); // multiplication
FuzzyLib& fuzzy_DIV( FuzzyLib &); // division

/
***************************************************************************=
*****/
/******************* surcharge *****************************/
/
***************************************************************************=
*****/
FuzzyLib& operator+ ( FuzzyLib &);
FuzzyLib& operator- ( FuzzyLib &);
FuzzyLib& operator* ( FuzzyLib &);
FuzzyLib& operator/ ( FuzzyLib &);
void operator=3D (FuzzyLib &);
ostream& operator<< (ostream& flux);

/
***************************************************************************=
*****/
/******************* affichage *****************************/
/
***************************************************************************=
*****/
void printFuzzyLib(FuzzyLib &); // affichage
void printFuzzyLib(void); // affichage
// tracer la fonction
};

/
***************************************************************************=
**************/
//Methode de classe
/
***************************************************************************=
***************/

#include "FuzzyLib.h"

/
***************************************************************************=
*****/
/****************** Constructeurs *****************************/
/
***************************************************************************=
*****/
FuzzyLib::FuzzyLib(void)
{
this->a =3D this->b =3D this->alpha =3D this->beta =3D 0 ;
}

FuzzyLib::~FuzzyLib(void)
{
delete this;
//this->a =3D NULL;
}

// Constructeur de copie
FuzzyLib::FuzzyLib(const FuzzyLib &I){
this->a =3D I.a;
this->b =3D I.b;
this->alpha =3D I.alpha;
this->beta =3D I.beta;
}

// construire un entier
FuzzyLib::FuzzyLib(double i){
this->a =3D this->b =3D i;
this->alpha =3D this->beta =3D 1;
}
// constructeur
FuzzyLib::FuzzyLib(double a, double b, double alpha, double beta){
this->a =3D a;
this->b =3D b;
this->alpha =3D alpha;
this->beta =3D beta;
}

/
***************************************************************************=
*****/
/****************** fcts de manipulation *********************/
/
***************************************************************************=
*****/
// fonction addition
FuzzyLib& FuzzyLib::fuzzy_ADD( FuzzyLib &M){
FuzzyLib *tmp =3D new FuzzyLib();
tmp->a =3D this->left_part(1) + M.left_part(1);
tmp->b =3D this->right_part(1) + M.right_part(1);
tmp->alpha =3D this->left_part(0) + M.left_part(0);
tmp->beta =3D this->right_part(0) + M.right_part(0);
return *tmp;
}
// fonction soustraction
FuzzyLib& FuzzyLib::fuzzy_SOUS( FuzzyLib &M){
FuzzyLib *tmp =3D new FuzzyLib();
tmp->a =3D this->left_part(1) - M.right_part(1);
tmp->b =3D this->right_part(1) - M.left_part(1);
tmp->alpha =3D this->left_part(0) - M.right_part(0);
tmp->beta =3D this->right_part(0) - M.left_part(0);
return *tmp;
}
// fonction multiplication
FuzzyLib& FuzzyLib::fuzzy_MULT( FuzzyLib &M){
FuzzyLib *tmp =3D new FuzzyLib();
tmp->a =3D min(this->left_part(1) * M.left_part(1),this->left_part(1) *
M=2Eright_part(1));
tmp->b =3D max(this->right_part(1) * M.left_part(1),this->right_part(1)
* M.right_part(1));
tmp->alpha =3D min(this->left_part(0) * M.left_part(0),this-
>left_part(0) * M.right_part(0));
tmp->beta =3D max(this->right_part(0) * M.left_part(0),this-
>right_part(0) * M.right_part(0));
return *tmp;
}
// fonction division
FuzzyLib& FuzzyLib::fuzzy_DIV( FuzzyLib &M){
FuzzyLib *tmp =3D new FuzzyLib();
tmp->a =3D min(this->left_part(1) / M.left_part(1),this->left_part(1) /
M=2Eright_part(1));
tmp->b =3D max(this->right_part(1) / M.left_part(1),this-
>right_part(1) / M.right_part(1));
tmp->alpha =3D min(this->left_part(0) / M.left_part(0),this-
>left_part(0) / M.right_part(0));
tmp->beta =3D max(this->right_part(0) / M.left_part(0),this-
>right_part(0) / M.right_part(0));
return *tmp;
}
// fonction addition +
FuzzyLib& FuzzyLib::operator +(FuzzyLib &M){
FuzzyLib *tmp =3D new FuzzyLib();
tmp->a =3D this->left_part(1) + M.left_part(1);
tmp->b =3D this->right_part(1) + M.right_part(1);
tmp->alpha =3D this->left_part(0) + M.left_part(0);
tmp->beta =3D this->right_part(0) + M.right_part(0);
return *tmp;
}
// fonction soustraction
FuzzyLib& FuzzyLib::operator -(FuzzyLib &M){
FuzzyLib *tmp =3D new FuzzyLib();
tmp->a =3D this->left_part(1) - M.right_part(1);
tmp->b =3D this->right_part(1) - M.left_part(1);
tmp->alpha =3D this->left_part(0) - M.right_part(0);
tmp->beta =3D this->right_part(0) - M.left_part(0);
return *tmp;
}
// fonction multiplication
FuzzyLib& FuzzyLib::operator *(FuzzyLib &M){
FuzzyLib *tmp =3D new FuzzyLib();
tmp->a =3D min(this->left_part(1) * M.left_part(1),this->left_part(1) *
M=2Eright_part(1));
tmp->b =3D max(this->right_part(1) * M.left_part(1),this->right_part(1)
* M.right_part(1));
tmp->alpha =3D min(this->left_part(0) * M.left_part(0),this-
>left_part(0) * M.right_part(0));
tmp->beta =3D max(this->right_part(0) * M.left_part(0),this-
>right_part(0) * M.right_part(0));
return *tmp;
}
// fonction division
FuzzyLib& FuzzyLib::operator /(FuzzyLib &M){
FuzzyLib *tmp =3D new FuzzyLib();
tmp->a =3D min(this->left_part(1) / M.left_part(1),this->left_part(1) /
M=2Eright_part(1));
tmp->b =3D max(this->right_part(1) / M.left_part(1),this-
>right_part(1) / M.right_part(1));
tmp->alpha =3D min(this->left_part(0) / M.left_part(0),this-
>left_part(0) / M.right_part(0));
tmp->beta =3D max(this->right_part(0) / M.left_part(0),this-
>right_part(0) / M.right_part(0));
return *tmp;
}
// fonction d'affectation
void FuzzyLib::operator =3D(FuzzyLib &M){
M.a=3D this->a;
M.b =3D this->b;
M.alpha =3D this->alpha;
M.beta =3D this->beta;
}

// fonction affichage
ostream& FuzzyLib::operator <<(std::ostream &flux)
{
flux << " [a =3D " << this->a
<< ", b =3D " << this->b
<< ", alpha =3D " << this->alpha
<< ", beta =3D " << this->beta
<< "]" ;
return flux;
}

void FuzzyLib::printFuzzyLib(void){
cout << " [a =3D " << this->a
<< ", b =3D " << this->b
<< ", alpha =3D " << this->alpha
<< ", beta =3D " << this->beta
<< "]" ;
}
void FuzzyLib::printFuzzyLib(FuzzyLib &M){
cout << " [a =3D " << M.a
<< ", b =3D " << M.b
<< ", alpha =3D " << M.alpha
<< ", beta =3D " << M.beta
<< "]";
}