3 questions sur une classe
Bonjour,
Un exemple tiré du livre Le langage C++ est à l'origine des 3 questions de ce message. Voici tout d'abord le code de la déclaration de la classe concernée:
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
const int TailleDefaut = 10;
class Array
{
public:
Array(int taille = TailleDefaut);
Array(const Array &rhs);
~Array(){delete[] pType;}
Array& operator=(const Array&);
int& operator[](int indice);
cont int& operator[](int indice) const;
int getTaille() const{return saTaille;}
friend ostream& operator<<(ostream&, const Array&);
class xLimits {};
private:
int* pType;
int saTaille;
}; |
1er question:
Concernant la fonction amie operator<<(...), vu qu'elle n'a besoin d'accéder qu'aux données privées de la classe Array, n'est-il pas plus judicieux d'en faire une fonction membre de la classe ? Je croyais que les fonctions amies étaient surtout utiles lorsqu'une classes avait besoin d'accéder aux données privées d'une autre classe, comme le ferait une classe matrice et une classe vecteur pour faire le produit d'une matrice par un vecteur.
2ème question:
Concernant le fonction
Code:
const int& operator[](int indice)
, pourquoi ne pas renvoyer un int plus simplement ? Il est vrai que dans le livre d'où est tiré cet exemple, l'auteur avait créé auparavant une classe générique ainsi:
Code:
1
2
|
template <class T> class Array{...} |
La même fonction pour le type T au lieu du type int avait pour prototype:
Code:
const int& operator[](int indice)
Je comprends alors mieux le type retourné par cette fonction qui évite une copie de l'objet T en renvoyant une référence sur le type T, le qualificatif const empêchant de modifier la valeur référencée.
Mais dans le cas d'un int, comment expliquer cette valeur de retour ?
3ème question:
Voici la définition partielle de la fonction membre operator[] de la classe Array:
Code:
1
2
3
4
5
6
7
8
9
|
int& Array::operator[](int indice)
{
...
throw xLimits();
return pType[0]; // pour MFC
} |
Cette fonction membre va-t'-elle effectivement renvoyer pType[0] si l'exception xLimits est renvoyée ? Cela supposerait qu'après l'envoi de l'exception xLimits, la fonction operator[] reprenne la main. Or, il me semblait que c'était le bloc catch() correspondant à cette exception qui reprenait la main immédiatement après l'envoi de l'exception.
Le commentaire "pour MFC" qui fait référence aux Microsoft Fondation Class est peut-être une partie de la réponse à mon questionnement.
Merci de m'éclairer sur ces questions de débutant qui ne remettent pas en cause la qualité de l'ouvrage cité.
