Problème compilation

Le
peracciu
Bonjour,

Je passe du C au C++, et j'ai un petit problème 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ésole 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é 'C:PowerDEVSAtomicsMyModelFuzzyLibdebug
FuzzyLib.exe', Les symboles ont été chargés.
'FuzzyLib.exe' : Chargé 'C:WINDOWSsystem32tdll.dll', Aucun symbole
n'a été chargé.
'FuzzyLib.exe' : Chargé 'C:WINDOWSsystem32kernel32.dll', Aucun
symbole n'a été chargé.
'FuzzyLib.exe' : Chargé 'C:WINDOWSWinSxS
x86_Microsoft.VC80.DebugCRT_1fc8b3b9a1e18e3b_8.0.50727.42_x-
ww_f75eb16cmsvcp80d.dll', Les symboles ont été chargés.
'FuzzyLib.exe' : Chargé 'C:WINDOWSWinSxS
x86_Microsoft.VC80.DebugCRT_1fc8b3b9a1e18e3b_8.0.50727.42_x-
ww_f75eb16cmsvcr80d.dll', Les symboles ont été chargés.
'FuzzyLib.exe' : Chargé 'C:WINDOWSsystem32msvcrt.dll', Aucun
symbole n'a été chargé.
Le programme '[1204] FuzzyLib.exe: Natif' s'est arrêté avec le code 0
(0x0).

La dernière ligne c'est quand je ferme le terminal.

voici la pile d'apl :

FuzzyLib.exe!wmain(int argc=1, wchar_t * * argv=0x00355b30) 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-être incorrects et/ou manquants,
aucun symbole chargé pour kernel32.dll]

Voici le code :

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

int _tmain(int argc, _TCHAR* argv[])
{
cout << "-- TEST --" ;
FuzzyLib *A = new FuzzyLib(2,2,1,3);
FuzzyLib *B = new FuzzyLib(4,4,2,6);
FuzzyLib *res = new FuzzyLib();
cout << "affichage de A";
A->printFuzzyLib();
cout << "affichage de B";
B->printFuzzyLib();
*res = 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êtes Windows rarement
utilisés
#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 = 1
double alpha, beta; // limite infereieur et superieur de la courbe
pour lambda = 0

public: // Fonctions
/
***************************************************************************=
*****/
/************************* get Set *****************************/
/
***************************************************************************=
*****/
inline double GetA(void) {return this->a;}
inline double SetA(double var) {this->a = var ;}
inline double GetB(void) {return this->b;}
inline double SetB(double var) {this->b = var ;}
inline double Get_alpha(void) {return this->alpha;}
inline double Set_alpha(double var) {this->alpha = var ;}
inline double Get_beta(void) {return this->beta;}
inline double Set_beta(double var) {this->beta = 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= (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 = this->b = this->alpha = this->beta = 0 ;
}

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

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

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

/
***************************************************************************=
*****/
/****************** fcts de manipulation *********************/
/
***************************************************************************=
*****/
// fonction addition
FuzzyLib& FuzzyLib::fuzzy_ADD( FuzzyLib &M){
FuzzyLib *tmp = new FuzzyLib();
tmp->a = this->left_part(1) + M.left_part(1);
tmp->b = this->right_part(1) + M.right_part(1);
tmp->alpha = this->left_part(0) + M.left_part(0);
tmp->beta = this->right_part(0) + M.right_part(0);
return *tmp;
}
// fonction soustraction
FuzzyLib& FuzzyLib::fuzzy_SOUS( FuzzyLib &M){
FuzzyLib *tmp = new FuzzyLib();
tmp->a = this->left_part(1) - M.right_part(1);
tmp->b = this->right_part(1) - M.left_part(1);
tmp->alpha = this->left_part(0) - M.right_part(0);
tmp->beta = this->right_part(0) - M.left_part(0);
return *tmp;
}
// fonction multiplication
FuzzyLib& FuzzyLib::fuzzy_MULT( FuzzyLib &M){
FuzzyLib *tmp = new FuzzyLib();
tmp->a = min(this->left_part(1) * M.left_part(1),this->left_part(1) *
M.right_part(1));
tmp->b = max(this->right_part(1) * M.left_part(1),this->right_part(1)
* M.right_part(1));
tmp->alpha = min(this->left_part(0) * M.left_part(0),this-
>left_part(0) * M.right_part(0));
tmp->beta = 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 = new FuzzyLib();
tmp->a = min(this->left_part(1) / M.left_part(1),this->left_part(1) /
M.right_part(1));
tmp->b = max(this->right_part(1) / M.left_part(1),this-
>right_part(1) / M.right_part(1));
tmp->alpha = min(this->left_part(0) / M.left_part(0),this-
>left_part(0) / M.right_part(0));
tmp->beta = 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 = new FuzzyLib();
tmp->a = this->left_part(1) + M.left_part(1);
tmp->b = this->right_part(1) + M.right_part(1);
tmp->alpha = this->left_part(0) + M.left_part(0);
tmp->beta = this->right_part(0) + M.right_part(0);
return *tmp;
}
// fonction soustraction
FuzzyLib& FuzzyLib::operator -(FuzzyLib &M){
FuzzyLib *tmp = new FuzzyLib();
tmp->a = this->left_part(1) - M.right_part(1);
tmp->b = this->right_part(1) - M.left_part(1);
tmp->alpha = this->left_part(0) - M.right_part(0);
tmp->beta = this->right_part(0) - M.left_part(0);
return *tmp;
}
// fonction multiplication
FuzzyLib& FuzzyLib::operator *(FuzzyLib &M){
FuzzyLib *tmp = new FuzzyLib();
tmp->a = min(this->left_part(1) * M.left_part(1),this->left_part(1) *
M.right_part(1));
tmp->b = max(this->right_part(1) * M.left_part(1),this->right_part(1)
* M.right_part(1));
tmp->alpha = min(this->left_part(0) * M.left_part(0),this-
>left_part(0) * M.right_part(0));
tmp->beta = 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 = new FuzzyLib();
tmp->a = min(this->left_part(1) / M.left_part(1),this->left_part(1) /
M.right_part(1));
tmp->b = max(this->right_part(1) / M.left_part(1),this-
>right_part(1) / M.right_part(1));
tmp->alpha = min(this->left_part(0) / M.left_part(0),this-
>left_part(0) / M.right_part(0));
tmp->beta = 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 =(FuzzyLib &M){
M.a= this->a;
M.b = this->b;
M.alpha = this->alpha;
M.beta = this->beta;
}

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

void FuzzyLib::printFuzzyLib(void){
cout << " [a = " << this->a
<< ", b = " << this->b
<< ", alpha = " << this->alpha
<< ", beta = " << this->beta
<< "]" ;
}
void FuzzyLib::printFuzzyLib(FuzzyLib &M){
cout << " [a = " << M.a
<< ", b = " << M.b
<< ", alpha = " << M.alpha
<< ", beta = " << M.beta
<< "]";
}
Vidéos High-Tech et Jeu Vidéo
Téléchargements
Vos réponses
Gagnez chaque mois un abonnement Premium avec GNT : Inscrivez-vous !
Trier par : date / pertinence
Cyrille
Le #304820
Bonjour,

Je passe du C au C++, et j'ai un petit problème 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ésole pour la longeur du message. Merci d'avance a ceux qui auront le
courage de m'aider.


Le programme compilé chez moi marche très bien: ça compile et affiche
quelque chose. Il n'y a aucun retour à la ligne par contre, je doute que
ça soit voulu.

L'output n'est cependant jamais flushé, je ne sais pas si ça a un
rapport, mais autant mettre "cout << flush;" ou "cout << endl;" à la
fin, juste avant l'appel à system, pour être sûr.

--
http://www.voteragauche.org/

peracciu
Le #304817
L'output n'est cependant jamais flushé, je ne sais pas si ça a un
rapport, mais autant mettre "cout << flush;" ou "cout << endl;" à la
fin, juste avant l'appel à system, pour être sûr.



Merci pour ta reponse, tu parles du cout (surchargé) ou du cout du
programme de test ?
Sinon je vais essayer, a quoi sert "flush" ?

Pour le retour a la ligne je peux ajouter un n dans les cout !!!
non ?

Encore merci, j'espère que ca va marcher chez moi.

peracciu
Le #304816
L'output n'est cependant jamais flushé, je ne sais pas si ça a un
rapport, mais autant mettre "cout << flush;" ou "cout << endl;" à la
fin, juste avant l'appel à system, pour être sûr.


Merci pour ta reponse, tu parles du cout (surchargé) ou du cout du
programme de test ?

Pour le retour a la ligne je peux ajouter un n dans les cout !!!
non ?

/******** Methode de Classe ***********/
cout << " [a = " << this->a
<< ", b = " << this->b
<< ", alpha = " << this->alpha
<< ", beta = " << this->beta
<< "]"
<< endl;
/********************************************/
/********* Prog de TEST ***************/
cout << "----- TEST -----n" << flush ;
FuzzyLib *A = new FuzzyLib(2,2,1,3);
FuzzyLib *B = new FuzzyLib(4,4,2,6);
FuzzyLib *res = new FuzzyLib();
cout << "affichage de An";
A->printFuzzyLib();
cout << "affichage de Bn";
B->printFuzzyLib();
*res = A->fuzzy_ADD(*B);
cout << "affichage de A+Bn";
res->printFuzzyLib();

system("PAUSE");
return 0;
/****************************************/

Encore merci pour ta réponse, mais chez moi ça marche pas.
Meme si je mets une partie du main en commentaire, ca compile, le
terminal se lance, mais rien ne s'affiche.
J'ai un retour sur VS avec un fleche jaune sur la première ligne du
code du prog de test, il y a marqué :
"Ceci est la prochaine instruction qui sera executée, pour changer
l'instruction a executer faites glisser la fleche. :) Les conséquence
de cette opération sont imprévisibles."

J'ai beau faire glisser la fleche rien de se passe !!!

peracciu
Le #304771
C'est bon ca marche, mais que sous DevC++.
Sinon si quelqu'un a le courage de regarder mon code et de me donner
des conseils je suis preneur, merci d'avance.
alexandre
Le #304727
"peracciu" news:
C'est bon ca marche, mais que sous DevC++.
Sinon si quelqu'un a le courage de regarder mon code et de me donner
des conseils je suis preneur, merci d'avance.


comme on te l'a suggéré, il faut vider le buffer de std::cout avant ton
sytem("pause') :

std::cout.flush();

ce dit, ce system("pause') est bien moche... A quoi sert-il ? A te laisser
regarder la sortie de la console ? Dans ce cas, autant mettre un point
d'arret (dans ton EDI) sru le return 0

peracciu
Le #305486
On 27 mar, 16:40, "alexandre"
"peracciu"
C'est bon ca marche, mais que sous DevC++.
Sinon si quelqu'un a le courage de regarder mon code et de me donner
des conseils je suis preneur, merci d'avance.


comme on te l'a suggéré, il faut vider le buffer de std::cout avant t on
sytem("pause') :

std::cout.flush();

ce dit, ce system("pause') est bien moche... A quoi sert-il ? A te laisser
regarder la sortie de la console ? Dans ce cas, autant mettre un point
d'arret (dans ton EDI) sru le return 0



Merci pour ta reponse, le systeme("pause"); en fait sert a garder le
terminal ouvert sinon il se ferme sans me laisser voir les sorties


Sylvain
Le #305379
peracciu wrote on 26/03/2007 10:49:

Encore merci pour ta réponse, mais chez moi ça marche pas.
Meme si je mets une partie du main en commentaire, ca compile, le
terminal se lance, mais rien ne s'affiche.


normal d'après ce que tu indiques après ton programme est stoppé, i.e.
ne s'exécute PAS.

J'ai un retour sur VS avec un fleche jaune sur la première ligne du
code du prog de test, il y a marqué :
"Ceci est la prochaine instruction qui sera executée, pour changer
l'instruction a executer faites glisser la fleche. :) Les conséquence
de cette opération sont imprévisibles."


oui, c'est une représentation graphique du pointeur d'instruction.
la panoplie du debuggeur symbolique comprend ce pointeur (que l'on peut
positionner à loisir -- en pétant la pile et l'exécution si c'est à un
mauvais endroit) et les points d'arrêts; lorsque l'on a positionné un
point d'arrêt (inconditionnel) l'exécution s'arrête sur la ligne de code
en question et on a alors loisir de "changer l'instruction à exécuter".

J'ai beau faire glisser la fleche rien de se passe !!!


et un petit "run", F9, ?...

btw, la lecture du user guide de VS n'est pas inutile lorsque l'on ne
connaît pas cet IDE.

Sylvain.

James Kanze
Le #305375
On Mar 27, 4:40 pm, "alexandre"
"peracciu" denews:

C'est bon ca marche, mais que sous DevC++.
Sinon si quelqu'un a le courage de regarder mon code et de me donner
des conseils je suis preneur, merci d'avance.


comme on te l'a suggéré, il faut vider le buffer de std::cout avant t on
sytem("pause') :

std::cout.flush();

ce dit, ce system("pause') est bien moche... A quoi sert-il ? A te laisser
regarder la sortie de la console ? Dans ce cas, autant mettre un point
d'arret (dans ton EDI) sru le return 0


Dans quel cas, il le lance d'une fenêtre terminal, non ? C'est
quand même la plus simple. Je sais qu'il y a cette manie chez
les windowsiens d'éviter les fenêtres terminal -- encouragée
par Microsoft --, mais c'est quand même ce qu'il y a de plus
souple, même sous Windows.

--
James Kanze (Gabi Software) email:
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34


peracciu
Le #305370
J'ai utlisé Dev C++ et ca marche très bien.

Donc je laisse VS de coté pour cette classe.

Sinon pour le problème de flèche, il n'y a aucun point d'arret. Je
n'en ai pas mis.

Merci pour vis réponses.

cdlt P.
Publicité
Poster une réponse
Anonyme