Discussion :

[kelly123]

Bonjour à tous !
J'ai actuellement un devoir consacrer sur les exceptions , je l'ai fais mais je voudrais avoir un avis sur vous ! merci beaucoup ! Je sais pas si l'exercice constitue bien à mon devoir et mon programme ! ^^

voiçi mon cours à faire :

Si une personne n'existe pas, on veut pourvoir afficher un message d'erreur et retourner à la demande du nom de la personne.Si elle existe,on veut pouvoir récupérer ses caractéristiques.Cela est vrai que la personne soit un enseignant, un étudiant ou un étudiant_enseignant.
Définir l'exception try/catch/throw permettant de gérer ces deux cas dans la classe Personne et modifier les fonctions membres des quatres classes afin que l'exception se propage correctement...

voiçi maintenant mon programme actuellement que j'ai fais :

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
101
102
103
104
105
106
107
108
109
110
111
 
#include <iostream>
#include <stdio.h>
using namespace std;
 
const int DefaultSize = 10;
 
class Personne
{
public:
	//constructeurs
	Personne(int itsSize = DefaultSize );
	Personne(const Personne &rns);
	~Personne() { delete [] pType;}
 
 
	//operateurs
	Personne& operator=(const Personne&);
	int& operator[] (int offSet);
	const int& operator[] (int offSet) const;
 
	//méthodes d'accès
	int GetitsSize() const { return itsSize; }
 
	//fonction amie
	friend ostream& operator<< (ostream&, const Personne&);
 
	//définit les classes d'exception
	class xEtudiant{};
	class xEnseignant{};
	class xEtudiant_Enseignant{};
	private:
		int *pType;
		int itsSize;
};
 
int& Personne::operator [] (int offSet)
{
	int size = GetitsSize();
	if (offSet >= 0 && offSet < GetitsSize())
	{
		return pType[offSet];
	}
	throw xEtudiant();
	{
		return pType[0]; //conforme MFC
	}
}
 
const int& Personne::operator [] (int offSet) const
{
	int mysize = GetitsSize();
	if(offSet >= 0 && offSet < GetitsSize())
	{
		return pType[offSet];
	}
	throw xEtudiant();
	{
		return pType[0]; //conforme MFC
	}
}
 
Personne::Personne(int size):
itsSize(size)
{
	if ( size == 0)
		throw xEnseignant();
	if ( size < 10)
		throw xEtudiant_Enseignant();
	if ( size > 30000)
		throw xEtudiant();
 
	pType = new int[size];
	for(int i = 0;i < size; i++)
	{
			pType[i] = 0;
	}
}
 
int main()
{
	try
	{
		Personne intPersonne(0);
		for (int j = 0; j < 100; j++)
		{
			intPersonne[j] = j;
			cout << "intPersonne[" <<j <<"] ok..."<< endl;
		}
	}
	catch ( Personne::xEtudiant)
	{
		cout << "Impossible de traiter votre entrée!" << endl;
	}
	catch ( Personne::xEnseignant)
	{
		cout << " cette personne n'existe pas..."<<endl;
	}
	catch (Personne::xEtudiant_Enseignant)
	{
//		<< " Cette personne existe vraiment..."<< endl;
	}
	catch (...)
	{
		cout << " une erreur s'est produit..." << endl;
	}
	cout << "FIN." << endl;
 
	return 0;
	getchar();
}

merci soyez compréhensif car je suis débutante !

[Bakura]

Salut

J'avoue que je connais assez mal les exceptions car je n'ai jamais eu l'occasion de les utiliser (ça ne saurait tarder ), mais voici quelques remarques :

//operateurs
Personne& operator=(const Personne&);

Tu pourrais écrire comment tu définis l'opérateur ? Parceque à tous les coups tu as fait une faute que j'ai fait il y a pas très longtemps (tu crée un objet sur la pile, et tu le renvoit en référence, mais hélas il ne sera plus dans la bonne portée. A moins que ce soit un pointeur et là j'ai rien dit :p.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
int& Personne::operator [] (int offSet)
{
	int size = GetitsSize();
	if (offSet >= 0 && offSet < GetitsSize())
	{
		return pType[offSet];
	}
	throw xEtudiant();
	{
		return pType[0]; //conforme MFC
	}
}

Je comprends pas ta ligne int size = GetitsSize (). C'est une fonction membre de ta classe Personne, tu as déjà accès à size, cet appel est inutile. Le fait que ta variable itsSize soit déclarée private n'empêche pas à la classe de l'utiliser directement.

Ensuite, tu fais un throw en dehors de tout bloc. Je comprends pas trop la démarche. Les exceptions c'est, à ma connaissance, pour signaler les erreurs (par exemple que offSet soit en dehors des limites, hors là que pType [offSet] existe ou non, tu lances une exceptions.

A moins qu'il y ait un truc que j'ai loupé,... mais je trouve ton code un peu bizarre . Ya sûrement un truc que j'ai pas du comprendre dans ton code.

[lun4t1k]

J'ai pour habitude de mettre dans les classes des exceptions une méthode message() qui renvoie un string et qui fait appel a what() de la classe exception.
Donc dans ton catch tu fais (Exception * e) pis std::cout<<e->message()...

Faudrait voir le code d'une exception que tu gères.

[loufoque]

La bonne pratique dicte de "catcher" les exceptions par référence constante.
Du coup, il faut mettre les blocs catch les plus spécifiques en premier.

[kelly123]

Bonjour à tous ( désoler du retard) j'ai bien lu ce que vous aviez écrit ! Mais la réponse que je voulais , n'était pas ça ! je voulais simplement savoir si cela est bien avec le devoir que je fais actuellement ? merci bien ^^
sinon quand j'exécute , tout marche bien !

[lun4t1k]

On te dit ce qui mériterait réflexion et amélioration...

[Aurelien.Regat-Barrel]

Code :

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

1
2
3
4
	throw xEtudiant();
	{
		return pType[0]; //conforme MFC
	}

une fois le throw exécuté, le code qui suit ne l'est pas, donc il sert a rien.

loufoque a fait une remarque pertinente:
http://c.developpez.com/faq/cpp/?pag...IONS_reference

et tant qu'on y est:
http://c.developpez.com/faq/cpp/?pag...ONS_type_perso
mais bon, dans ton cas c'est un devoir d'école, et mieux vaut faire comme dit le prof...

D'ailleurs il ne parle que d'une seule exception, et toi tu en définis 3. Je pense qu'une seule classe d'exception suffit, que tu instancies avec un message adapté. Le lien précédent est un bon exemple.