création et utilisation de classes

Bonjour,

je ne suis pas très doué dans la création de classes.
j'essaye de créer une petite classe avec une methode :

Code:

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
#include <iostream>
using namespace std;
 
class MeasuringTemperature{
	public :
		//MeasuringTemperature();
		double averageTemperature(int measuredValues[]);
	private :
		int measuredValues[];
}
 
double MeasuringTemperature::averageTemperature(int measuredValues[], int size_mesuredValues)
{
// une instruction quelconque
 
return -300;
}
 
int main()
{
	int T[]={-273,-274,-273,-273},size_mesuredValues;
	MeasuringTemperature MT;
	double averageTemp;
	size_mesuredValues=sizeof(T)/sizeof(int);
	averageTemp=MT.averageTemperature(T[],size_mesuredValues);
	cout<<"averageTemp = "<<averageTemp<<endl;
	return 0;
}

a la compilation j'ai une foule d'erreur sur la ligne 12 :

Code:

double MeasuringTemperature::averageTemperature(int measuredValues[], int size_mesuredValues)

voila ce que dit le compilateur

Code:

1
2
3
4
5
6
7
ubuntu@ubuntu:~/exercice1$ g++ -o MeasuringTemperature MeasuringTemperature.cpp
MeasuringTemperature.cpp:12: error: new types may not be defined in a return type
MeasuringTemperature.cpp:12: note: (perhaps a semicolon is missing after the definition of ‘MeasuringTemperature’)
MeasuringTemperature.cpp:12: error: two or more data types in declaration of ‘averageTemperature’
MeasuringTemperature.cpp:12: error: prototype for ‘MeasuringTemperature MeasuringTemperature::averageTemperature(int*, int)’ does not match any in class ‘MeasuringTemperature’
MeasuringTemperature.cpp:7: error: candidate is: double MeasuringTemperature::averageTemperature(int*)
MeasuringTemperature.cpp: In member function ‘MeasuringTemperature MeasuringTemperature::averageTemperature(int*, int)’:

Est ce que quelqu'un a une solution, j'ai vraiment du mal avec les classes

merci

désolé !!

j'avais oublié le ";" a la fin de ma classe, désolé !!

Salut,

Ceci dit, il faudrait tout doucement commencer à penser "orienté objet"...

En effet, la méthode averageTemperature correspond à deux comportements particuliers, qu'il serait fortement conseillé de séparer:

D'un coté, on trouve le comportement qui consiste à rajouter une température, et, de l'autre, on trouve le comportement qui consiste à calculer (ou à renvoyer) la moyenne de ces températures.

Or, ici, ta méthode averageTemperature, elle a deux responsabilités, ce qui en est une de trop :P

En plus, l'un de premiers commandement du C++, c'est

Citation:

Envoyé par le troisième commandement du C++

ne jamais utiliser une particularité du C si une classe C++ permet de faire pareil, en évitant les problèmes

A ton niveau, cela signifie qu'il serait opportun de préférer la classe vector, disponible dans l'espace de nommage std en incluant le fichier d'en-tête <vector> en lieu et place d'un tableau "C style", qui présente d'énormes inconvénients pour tout ce qui a trait à la gestion dynamique de la mémoire (voir la classe list, disponible également dans l'espace de nommage std, mais en incluant cette fois le fichier d'en-tête <list>, si tu es sur d'avoir principalement des accès itératifs aux températures fournies).

Enfin, on peut se poser la question de savoir pourquoi tu veux fournir les températures sous forme d'entiers, et non sous forme de réels...

Les conversions entiers <==>réels posent d'elles mêmes déjà énormément de problème du fait de la perte de précision que cela occasionne, et, tout compte fait, même pour les températures importantes (qu'elles soient positives ou négatives), il ne semble pas exclu que tu veuille pouvoir fournir une température avec une certaine précision après la virgule ;)

Au final, tu obtiendrais donc une classe pouvant fort ressembler à
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 #include <vector> // pour pouvoir utiliser la classe "vector" ;) class MeasuringTemperature { public: MeasuringTemperature(){}//de prime abord, aucune température n'est // insérée lors de la construction ;) ~MeasuringTemperature(){}//rien de particulier à faire non plus dans le // destructeur void addTemperature(double temp);// ajouter une température const double operator[](size_t ind) const;/* juste pour te permettre de * travailler comme si c'était carrément * un tableau de températures ;) */ double average() const;// permet de récupérer la température moyenne private: std::vector<double> alltemps;//le tableau des températures double aver;//(I) };
(I)Il faut bien se rendre compte que, calculer la moyenne prendra d'autant plus de temps que le nombre de températures déjà introduites sera important...

Dés lors, il s'agit de se poser la question de savoir le comportement que l'on préfère privilégier:
Soit, on prévoit de faire, principalement, des ajouts de températures, et, de temps en temps, de demander la moyenne, soit on prévoit de demander régulièrement la moyenne, sans forcément faire des ajouts de températures entre deux demandes.

Dans le premier cas, on préférera calculer la moyenne "à la demande", de manière à ne pas perdre trop de temps lors de l'insertion.

Dans le deuxième, on peut préférer calculer la moyenne à chaque insertion de température, et stocker cette valeur pour qu'elle soit plus rapidement accessible.

Si cette deuxième optique est suivie, il faudra, bien évidemment, disposer d'une variable qui permette de garder cette moyenne en mémoire le temps nécessaire :D

L'implémentation prendrait la forme de
Code:

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 void MeasuringTemperature::addTemperature(double temp) { alltemps.push_back(temp); /* si on décide de calculer la moyenne à chaque insertion, décommenter le * code qui suit */ /* aver=0.0; * for(size_t i=0;i<alltemps.size();i++) * aver+=alltemps[i]; * aver/=alltemps.size(); */ } double MeasuringTemperature::average() const { /* si on décide de ne calculer la moyenne que quand on la demande, * aver n'est pas membre de la classe, et on le déclare donc comme * variable temporaire. * Il faut alors décommenter le code qui suit */ /* double aver=0.0; * for(size_t i=0;i<alltemps.size();i++) * aver+=alltemps[i]; * aver/=alltemps.size(); */ return aver; } const double MeasuringTemperature::operator[](size_t ind) const { return alltemps[ind]; }
Nota: j'ai considéré que l'on ne faisait jamais que rajouter des températures...

Si le besoin s'en fait sentir, il reste possible de rajouter des comportements visant à en supprimer, voire, à carrément supprimer toutes les températures introduites...

Cependant, il y a alors lieu de réfléchir à la manière dont la moyenne réagit à cette/ces suppression(s)

On pourrait aussi envisager de rajouter un comportement qui indique le nombre de températures déjà introduites ;)

L'utilisation de cette classe deviendrait, typiquement, quelque chose prenant la forme de
Code:

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 #include <iostream> //pour gérer les entrées/sorties standards #include <string> //pour disposer des chaines de caractères int main() { MeasuringTemperature obj; std::string encore=""; do { float temp; std::cout<<"introduisez la température :"; while(!(std::cin>>temp)) { std::cout<<"veuillez introduire une valeur correcte s'il vous plait" <<std::endl; } obj.addTemperature(temp); do { std::cout<<"voulez vous continuer (O/N) :"; std::cin>>encore; /* pour les gens vraiment distraits */ if(encore !="o" && encore !="O" && encore !="n" && encore !="N") { std::cout<<"veuillez choisir uniquement O ou N"<< std::endl; } }while(encore !="o" && encore !="O" && encore !="n" && encore !="N"); }while(encore =="o" || encore =="O"); std::cout<<"la moyenne est de "<<obj.average(); return 0; }