Discussion :

[superspike23]

bonjour a tous.
J essaye de m intitier au c++ mais ca commence bien mal.
j ai ecrit un petit code source mais pleins d erreur que je ne comprends pas.
Si quelqu un peut m indiquer quelles erreurs je fais ca me fera progresser,merci d avance.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
#include "stdafx.h"
#include <iostream>
class equa2
{
public:
	equa2(float a,float b,float c);
	~equa2();
	float lire(float) const;
	float AfficherDelta() const;
	float CalculerDelta(float sonA,float sonB,float sonC);
	float CalculerS1(float sonA,float sonB,float sonC,float sonDelta);
	float CalculerS2(float sonA,float sonB,float sonC,float sonDelta);
	float AfficherS1() const;
	float AfficherS2() const;
private:
	float sonA,sonB,sonC,sonDelta,sonS1,sonS2;
}
;
 
equa2::equa2(float a,float b,float c) {
	sonA=a;
	sonB=b;
	sonC=c;
}
equa2::~equa2() {}
float equa2::CalculerDelta(float sonA,float sonB,float sonC )
{
	float sonDelta;
	sonDelta=(sonB*sonB)- (4*sonA*sonC);
return sonDelta;
}
float equa2::AfficherDelta()
{
	std::cout << "/ndelta=" << sonDelta << "/n";
}
equa2::AfficherS1()
{
	if(sonDelta>=0)
	{
 
	std::cout << "/,S1="<<sonS1<<"/n";
	};
	if(sonDelta<0)
	{
		std::cout << "/,S1="<<sonS1<<"i/n";
	};
 
}
equa2::AfficherS2()
{
if(sonDelta>=0)
	{
 
    std::cout << "/,S1="<<sonS2<<"/n";
};
if(sonDelta<0)
 
{
std::cout << "/,S1="<<sonS2<<"i/n";
};
}
sonDelta=CalculerDelta(); 
 
sonS1=CalculerS1(sonA,sonB,sonC,sonDelta);
 
sonS2=CalculerS2(sonA,sonB,sonC,sonDelta);
 
equa2::CalculerS1(float sonA,sonB,sonC,sonDelta)
{
	Float sonS1;
sonS1=(((-sonB)-(sqrt(sonDelta)))/(2*sonA));
return sonS1;
}
 
 
 
equa2::CalculerS2(float sonA,sonB,sonC,sonDelta)
{Float sonS2;
sonS2=(((-sonB)-sqrt(sonDelta))/(2*sonA));
return sonS2;
}
 
int _tmain(int argc, _TCHAR* argv[])
{
	return 0;
}

balises [code] rajoutées par r0d. Merci d'y penser la prochaine fois.

[r0d]

Bonjour,

-> Tu devrais séparer le .h et le .cpp. Dans le .h, tu ne met que la déclaration de la classe, dans le .cpp, tu met l'implémentation des fonctions
-> Vérifie bien que les signatures de tes fonctions sont identiques dans la déclaration et dans l'implémentation. Par exemple, ce n'est pas le cas pour la fonction AfficherS1()
-> Lorsque tu écris:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

float UneFonction();

ça signifie que cette fonction retourne une valeur. Un flottant en l'occurence. Il faut donc que, dans l'implémentation, ta fonction retourne un flottant.
-> Ensuite, je te conseille de séparer la classe que tu va utiliser, et la fonction main. Le mieux, c'est de mettre la définition de equa2 dans un en-tête (equa2.h par exemple) et son implémentation dans un fichier cpp (equa2.cpp). Ensuite tu fais un fichier main.cpp, dans lequel tu met ta fonction main.

Il y a encore pas mal de trucs, mais fais déjà ça, ce sera un bon début

[poukill]

il y a un ";" après un if de trop aussi !

[koala01]

Salut,

Enfin, et même si je n'ai regardé que la déclaration, les méthodes

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
float CalculerDelta(float sonA,float sonB,float sonC);
float CalculerS1(float sonA,float sonB,float sonC,float sonDelta);
float CalculerS2(float sonA,float sonB,float sonC,float sonDelta);

ont de quoi me surprendre assez bien, et sont clairement de nature à poser problème...

En effet, le but d'une classe, c'est, en définitive, de regrouper les différentes données - au même titre que ce qui se fait avec les struct du C - et les fonctions "qui vont bien" pour ces données.

Or, il faut savoir que, c'est un problème inhérent aux fonctions, quand tu fournit des arguments dont le nom est le même que celui d'un membre de la classe, l'argument va "cacher" le membre en créant une variable locale à la fonction.

Du coup, quand tu va implémenter ces fonctions, cela te donnera quelque chose sous la forme de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
float equa:: CalculerDelta(float sonA,float sonB,float sonC)
{
   /* parle-t-on de equa::sonA ou du sonA fournit en argument?
    * en fait, on parle du sonA fournit en argument, et on ne changera
    * rien à equa::sonA
    */
   sonA=/*...*/
}

Et je ne suis même pas sûr bien que je puisse me tromper là dessus, que this->sonA puisse faire la différence

En plus, pourquoi fournir des valeurs qui correspondent séparément, justement, aux membres de la classe, au lieu de fournir, carrément, un référence, éventuellement constante, sur la classe (ce qui permettrait d'éviter le problème soulevé plus haut)

[superspike23]

J'ai reecris tout le code en essayant de faire quelque chose de plus propre.
Voila ce que ca donne.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
#include <iostream>
#include <math.h>
 
class equa2
{
public:
	equa2(float a,float b,float c);
	~equa2();
	void AfficherSolution();
 
private:
	float mA,mB,mC,mDelta,mS1,mS2;
 
}
;
equa2::equa2(float a,float b, float c)
{
	mA=a;
	mB=b;
	mC=c;
}
equa2::~equa2() {}
 
void equa2::AfficherSolution()
{
	mDelta= (mB*mB)-(4*mA*mC);
	std::cout << "\n\tDelta="<<mDelta<<"\n";
 
	if (mDelta >=0) 
	{
		mS1= (-mB-(sqrt(mDelta)))/(2*mA);
	    mS2= (-mB+(sqrt(mDelta)))/(2*mA);
		std::cout<<"solution1="<<mS1<<"\tSolution2="<<mS2;
	}
	else 
	{
		mS1= (-mB-(sqrt(-mDelta)))/(2*mA);
	    mS2= (-mB+(sqrt(-mDelta)))/(2*mA);
		std::cout<<"solution1="<<mS1<<"i\tSolution2="<<mS2<<"i\n\n";
	}
 
}
 
 
 
int main()
{
	std::cout<<"Veuillez saisir des valeurs pour a,b et c\n";
	float a,b,c;
	std::cout<<"a= \t";
	std::cin>>a;
    std::cout<<"b= \t";
	std::cin>>b;
	std::cout<<"c= \t";
	std::cin>>c;
 
	equa2 monequa(a,b,c);
	monequa.AfficherSolution();
 
 
	return 0;
}

Maintenant je vais essayer de separer la partie interface utilisateur (cin/cout) de main comme ca je pourra essayer de l adapter a une interface graphique

[Médinoc]

Selon moi, AfficherSolution() devrait être const et ne modifier aucune variable de la classe (utiliser des variables locales aux fonctions).
...Ou alors, renommer la fonction en CalculerSolution().

[r0d]

Attention aux divisions par 0

[superspike23]

j ai essayer de réecrire tout en suivant vos conseil.
Jai notemment separer la desclaration du code source.
mais ca coince encore.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
 #include <iostream>
 
class polynome
{
public:
	double lireA() const {return *sonA;}
	double lireB() const {return *sonB;}
	double lireC() const {return *sonC;}
 
	void defA(double a) {*sonA = a;}
	void defB(double b) {*sonB = b;}
	void defC(double c) {*sonC = c;}
 
	void AfficherPolynome() const 
	{
		std::cout<<"\n\ty="<<sonA<<"X²+"<<sonB<<"X+"<<sonC;
	}
	//double CalculerDelta()
	//{
	//	return (((*sonB)*(*sonB))-(4*(*sonA*)*(*sonC)));
	//}
private:
	double *sonA,*sonB,*sonC,sonDelta,sonS1,sonS2;
}
;

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
    #include "equation2.h"
 
int main()
{
polynome *monpolynome =new polynome;
double a,b,c;
std::cout << "\nVeuillez saisir les valeurs de a,b et c.\n";
std::cout <<"a= ";
std::cin >>a;
std::cout<<"b= ";
std::cin >>b;
std::cout <<"c= \n\n";
std::cin>>c;
monpolynome->defA(a);
//monpolynome->defB(b);
//monpolynome->defC(c);
//monpolynome->AfficherPolynome();
 
 
 
	return 0;
}

J ai essayer de me servir de pointeur pour prendre de bonna habitude de suite .
Le programme ce compile mais il bug au moment ou je saisi la valeur pour c.
c pour cette raison que j ai mis en commentaire certaine ligne mais je n ai pas trouver le probleme.

[r0d]

Ca commence à prender forme

Mais ,tu te compliques la vie pour rien en mettant des pointeurs.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
public:
	double lireA() const {return sonA;}
//etc... 
	void defA(double a) {sonA = a;}
//etc...
 
private:
	double sonA,sonB,sonC,sonDelta,sonS1,sonS2;
};

Est bien mieux

[koala01]

De même, pourquoi déclarer monpolynome comme pointeur et l'allouer avec new

Le problème n'est pas d'allouer la mémoire dynamiquement pour un pointeur (c'est l'une des utilisations classiques des pointeurs ) le problème est qu'ici, une simple variable de type polynome suffit amplement:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
int main()
{
    polynome monpolynome;
    double a,b,c;
    std::cout << "\nVeuillez saisir les valeurs de a,b et c.\n";
    std::cout <<"a= ";
    std::cin >>a;
    std::cout<<"b= ";
    std::cin >>b;
    std::cout <<"c= \n\n";
    std::cin>>c;
    monpolynome.defA(a);
    monpolynome.defB(b);
    monpolynome.defC(c);
    monpolynome.AfficherPolynome();
    return 0;
}

Et les quelques remarques "purement esthétiques"...:

Evite de déclarer plusieurs variables sur une seule et même ligne... ici, il n'y en a que trois, mais il est tellement facile de "passer outre" d'une des variables dans ces conditions

Préfère déclarer chaque variable sur une ligne distincte, en séparant chaque déclaration par un point virgule

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
int a;
int b;
int c;

Ca ne prend pas beaucoup plus de temps à écrire, mais ca facilite la lecture ... et tu le lira souvent: un code est plus souvent lu qu'il n'est écrit

Ensuite, le C++ permet de faire les déclaration n'importe où, et il est préférable de déclarer la variable quand tu en a réellement besoin

Au choix, cela pourrait prendre une forme du genre de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
int main()
{
    std::cout << "\nVeuillez saisir les valeurs de a,b et c.\n";
    std::cout <<"a= ";
    double a;
    std::cin >>a;
    std::cout<<"b= ";
    double b;
    std::cin >>b;
    double c;
    std::cout <<"c= \n\n";
    std::cin>>c;
    polynome monpolynome;
    monpolynome.defA(a);
    monpolynome.defB(b);
    monpolynome.defC(c);
    monpolynome.AfficherPolynome();
    return 0;
}

Enfin, il faut savoir qu'il existe deux fonctions "particulières" qu'il est vraiment intéressant de créer: le constructeur et le destructeur (en fait, il y a plusieurs types de constructeurs et un type de destructeur )

Ce sont des fonctions qui sont automatiquement appelées lors... de la construction ou de la destruction des objets.

Ce sont les seules fonctions qui ne renvoient rien, le constructeur prend, tout simplement le nom de la classe (et les paramètres éventuels) et le destructeur prend le nom de la classe, précédé d'un tilde ~.
Pour ton polynome, j'en verrais bien un du genre de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
class polynome
{
    public:
        polynome(double a, double b, double c):sonA(a),sonB(b),sonC(c){}
        ~polynome(){}
    /* le reste de ta classe */
};

ce qui te permettrait d'écrire ta fonction main sous la forme de
[CODE]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
int main()
{
    std::cout << "\nVeuillez saisir les valeurs de a,b et c."<<std::endl
              <<"a= "<<std::endl;
    double a;
    std::cin >>a;
    std::cout<<"b= ";
    double b;
    std::cin >>b;
    double c;
    std::cout <<"c="<<std::endl<<std::endl;
    std::cin>>c;
    polynome monpolynome(a, b, c);
    monpolynome.AfficherPolynome();
    return 0;
}

[superspike23]

ca y est le code source fonctionne bien.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
#include <iostream>
#include <math.h>
 
class polynome
{
public:
	polynome(double a, double b, double c):sonA(a),sonB(b),sonC(c){}
    ~polynome(){}
 
	void AfficherPolynome() const 
	{
		std::cout<<"\n\ty="<<sonA<<"X²+"<<sonB<<"X+"<<sonC<<std::endl;
	}
 
	double CalculerDelta()
	{
		sonDelta= (((sonB)*(sonB))-(4*(sonA)*(sonC)));
		return sonDelta;
	}
 
	void AfficherDelta() const
	{
 
		std::cout<<"\n\tDelta= "<<sonDelta<<std::endl;
	}
	void CalculerSolution()
	{
		if (sonDelta >=0)
		{
			sonS1=(-sonB-sqrt(sonDelta))/2*sonA;
			sonS2=(-sonB+sqrt(sonDelta))/2*sonA;
		}
		else
		{
			sonpr1 = -sonB/2*sonA;
			sonpr2 = -sonB/2*sonA;
			sonpi1 = -sqrt(-sonDelta)/2*sonA;
			sonpi2 = sqrt(-sonDelta)/2*sonA;
		}
	}
 
	void AfficherSolution() const
	{
 
		if (sonDelta >=0)
		{
			std::cout<<"solution1= "<<sonS1<<
			"   Solution2= "<<sonS2<<std::endl;
		}
		else
		{
			std::cout<<"solution1= "<<sonpr1<<sonpi1<<
			"i  Solution2= "<<sonpr2<<"+"<<sonpi2<<"i"<<std::endl;
		}
	}
 
 
 
 
private:
	double sonA,sonB,sonC,sonDelta,sonS1,sonS2;
	double sonpr1,sonpi1,sonpr2,sonpi2;//partie reelle et 
	//imaginaire dans le cas ou 
	//sonDelta < 0.
 
}
;

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include "equation2.h"
 
 
int main()
{
    std::cout << "\nVeuillez saisir les valeurs de a,b et c."<<std::endl
              <<"a= ";
    double a;
    std::cin >>a;
    std::cout<<"b= ";
    double b;
    std::cin >>b;
    double c;
    std::cout <<"c= ";
    std::cin>>c;
    polynome monpolynome(a, b, c);
    monpolynome.AfficherPolynome();
	monpolynome.CalculerDelta();
	monpolynome.AfficherDelta();
	monpolynome.CalculerSolution();
	monpolynome.AfficherSolution();
    return 0;
}

Maintenant me reste a stocker les valeurs que prendront y pour x=-50 a +50
De cette facon je pourrai essayer de tracer la courbe.

[superspike23]

j ai avance dans mon projet,2 tableaux stock desormais les coordonnee x et y.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
#include <iostream>
#include <math.h>
 
class polynome
{
public:
	polynome(double a, double b, double c):sonA(a),sonB(b),sonC(c){}
    ~polynome(){}
 
	void AfficherPolynome() const 
	{
		std::cout<<"\n\ty="<<sonA<<"X²+"<<sonB<<"X+"<<sonC<<std::endl;
	}
 
	double CalculerDelta()
	{
		sonDelta= (((sonB)*(sonB))-(4*(sonA)*(sonC)));
		return sonDelta;
	}
 
	void AfficherDelta() const
	{
 
		std::cout<<"\n\tDelta= "<<sonDelta<<std::endl;
	}
	void CalculerSolution()
	{
		if (sonDelta >=0)
		{
			sonS1=((-sonB)-sqrt(sonDelta))/(2*sonA);
			sonS2=((-sonB)+sqrt(sonDelta))/(2*sonA);
		}
		else
		{
			sonpr1 = (-sonB)/(2*sonA);
			sonpr2 = (-sonB)/(2*sonA);
			sonpi1 = (-sqrt(-sonDelta))/(2*sonA);
			sonpi2 = sqrt(-sonDelta)/(2*sonA);
		}
	}
 
	void AfficherSolution() const
	{
 
		if (sonDelta >=0)
		{
			std::cout<<"solution1= "<<sonS1<<
			"   Solution2= "<<sonS2<<std::endl;
		}
		else
		{
			std::cout<<"solution1= "<<sonpr1<<sonpi1<<
			"i  Solution2= "<<sonpr2<<"+"<<sonpi2<<"i"<<std::endl;
		}
	}
 
 
	void CreerTableau() ;
	double LireCoordX(int indX) 
	{
		coordX=Tableaux[indX];	
		return coordX;
	}
 
	double LireCoordY(int indY)
	{ 
		coordY=Tableauy[indY];
		return coordY;
	}
 
 
 
private:
	double sonA,sonB,sonC,sonDelta,sonS1,sonS2;
	double sonpr1,sonpi1,sonpr2,sonpi2;//partie reelle et 
	//imaginaire dans le cas ou 
	//sonDelta < 0.
double Tableaux[100];
double Tableauy[100];
double coordX,coordY;
 
}
;
void polynome::CreerTableau()
{
	double x=-50;
	double y;
	int i;
 
	  for(i=0;i<100;i++)
	    {
		  y=sonA*x*x+sonB*x+sonC;
		Tableaux[i]=x;
		Tableauy[i]=y;
 
		  x++;
 
	    }
 
	}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
#include "equation2.h"
 
 
int main()
{
    std::cout << "\nVeuillez saisir les valeurs de a,b et c."<<std::endl
              <<"a= ";
    double a;
    std::cin >>a;
    std::cout<<"b= ";
    double b;
    std::cin >>b;
    double c;
    std::cout <<"c= ";
    std::cin>>c;
    polynome monpolynome(a, b, c);
    monpolynome.AfficherPolynome();
	monpolynome.CalculerDelta();
	monpolynome.AfficherDelta();
	monpolynome.CalculerSolution();
	monpolynome.AfficherSolution();
	monpolynome.CreerTableau();
	std::cout<<"\nPour qu'elle coordonnee x(compris entre -50 et 50)"
		<<"voullez vous afficher Y?"<<std::endl;
	char response ='o';
	for(;response=='o';)
	{
	std::cout<<"coordonnee x ";
	int x;
	std::cin>>x;
 
	std::cout<<"pour x= "<<monpolynome.LireCoordX((x+50))<<"\tY= "<<monpolynome.LireCoordY((x+50))<<std::endl;
	std::cout<<"Voulez vous saisir une autre coordonnee (o/n)?"<<std::endl;
	std::cin>>response;
	}
    return 0;
}

Le probleme c'est que le code devient de plus en plus fouilli.
Peutetre pouvez vous me donner quelques conseils pour le rendre plus claire.
Et ma deuxieme question,quel librarie devrais utiliser pour simplement afficher une courbe par rapport a mes coordonnees x et y mais sans creer toute une interface.

[JolyLoic]

Créer une courbe simpliste peut se faire avec n'importe quelle bibliothèque de dessin. La SDL est souvent citée.

Mais très rapidement, si on en veut un peu plus (afficher les axes, zoomer,...), ça peut vite devenir assez long. J'avais obtenu de bons résultats avec Qt + Qwt. Par contre, ça demande déjà une certaine connaissance du C++, je ne suis pas certain que ce soit un bon choix pour toi pour l'instant.