Discussion :

[Ferghus]

Bonjour,

Je développe une classe Matrice, et après avoir cherché sur internet, je suis parvenu à avoir une classe qui marche bien. Néanmoins, dans un des exemples, j'ai noté que l'opérateur () était surchargé 2 fois, et j'aimerai comprendre pourquoi.

Voici la partie 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
17
 
template<typename T> 
class Matrix
{
public:
 
    T&  operator()(size_t r, size_t c) 		  { return(tableau[c + r*col]);  } 
    T   operator()(size_t r, size_t c)  const   {  return(tableau[c + r*col]);  } 
 
.....
 
private :
    size_t      row;   // nombre de lignes
    size_t      col;   // nombre de colonnes
    vector<T> 	tableau;
 
};

je vois bien la première surcharge. Mais la seconde ? et dans quel contexte ?

Merci bien

[ternel]

il y a une surcharge non constante, et une autre constante.

La premiere permet de prendre une référence (modifiante) sur un élément d'une matrice modifiable.
La seconde permet de prendre une copie d'un élément d'une matrice constante.

Exactement comme begin() ou end() ont deux surcharges dans std::vector.


Cela dit, le changement de taille d'une matrice n'a pas de sens concret. Tu devrais prendre la taille en parametre de template, et utiliser std::array<T, taille*taille> comme conteneur de cases.

[Jerome2568]

Les deux te permettent d'acceder a tes données.

Code :

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

T&  operator()(size_t r, size_t c)

Cette methode (1) te donne acces en mode lecture ecriture.

Code :

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

T   operator()(size_t r, size_t c)  const

Cette methode (2) te retourne une copie et tu en faire ce que tu veux.

Une suggestion est de l'écrire comme ça, l'implementation ne change pas.

Code :

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

const T&   operator()(size_t r, size_t c)  const

Ton compilateur choisira la methode appropriée.
Un example:

Code :

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

1
2
3
4
5
 
Matrix<std::string> stringMatrix;
 
const std::size_t sz = stringMatrix(1, 2).size(); // methode (2) est utilisée.
stringMatrix(1, 2).clear(); // methode (1) est utilisée.

[stendhal666]

Ton compilateur choisira la methode appropriée.
Un example:

Code :

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

1
2
3
4
5
 
Matrix<std::string> stringMatrix;
 
const std::size_t sz = stringMatrix(1, 2).size(); // methode (2) est utilisée.
stringMatrix(1, 2).clear(); // methode (1) est utilisée.

En l'occurrence la méthode non const sera appelée les deux fois, puisque l'objet stringMatrix n'est pas const.
Un meilleur exemple serait:

Code :

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

1
2
 
std::matrix<int> addMatrix(const Matrix<int>& a, const Matrix<int>& b); // garantit que a et b ne seront pas modifiées -> uniquement les méthodes const peuvent être utilisées

Il y a un autre intérêt à marquer une méthode const: si la méthode const modifie un des membres de l'objet, le compilateur générera une erreur (à mois que le membre en question ait été déclaré mutable).

[koala01]

Salut,

Pour faire simple : lorsque -- pour une raison quelconque -- on a déterminé que la matrice (parce que c'est ce dont on parle ici, mais nous pourrions parler de n'importe quel autre type de donnée) ne peut pas être modifié en précisant que c'était un "élément constant", le compilateur refusera systématiquement toute tentative d'appel à une fonction qui pourrait éventuellement risquer de modifier la donnée en question

Pour les fonctions libres, cela signifie que nous ne pourrons appeler que des fonctions qui reçoivent la donnée en question par valeur (parce que cela occasionne une copie et si modification il y a au niveau de la fonction appelée, elle a lieu sur... la copie et non sur la donnée d'origine) ou par référence constante (parce que le passage par référence n'occasionne pas de copie, mais le fait qu'on prévienne le compilateur que c'est un élément qui n'est pas susceptible d'être modifié lui suffit pour dire qu'il ne le sera pas)

Pour les fonctions membres de la classe, cela passe par le fait d'indiquer explicitement au compilateur que la fonction ne modifiera pas l'objet au départ duquel elle est appelée. Et cela se fait en ... ajoutant le mot clé const après la liste des paramètres.

De cette manière, le compilateur pourra "traquer" tous les cas où tu pourrais éventuellement en arriver à modifier une donnée dont tu as dit qu'elle ne pouvait pas l'être. Et, crois moi, il sera beaucoup plus buté que toi et beaucoup plus précis pour trouver les cas qui posent problème

Ainsi, la version const T& operator()(size_t r, size_t c) const de ton opérateur dit (plus ou moins textuellement) que "cet opérateur renvoi une référence qui ne pourra pas être modifiée" (ca, c'est le const T&) et que cet opérateur s'engage à ne pas modifier la donnée au départ de laquelle il a été appelé (ca, c'est le deuxième const). Si, au lieu de renvoyer un T const &, nous venions à renvoyer un simple T & (tu remarqueras l'absence du mot clé const ), le compilateur nous engueulerait sous une forme qui pourrait ressembler à

espèce d'imbécile!!! tu me dit que l'opérateur ne peut pas modifier l'objet courant, mais le fait que tu renvoie une référence constante permettrait à la fonction appelant cet opérateur de le faire... tu crois pas qu'il y a un malaise quelque part ?

(oui, je sais, j'anthropomorphise très fort )

Dés lors, on peut exprimer les choses sous cette forme : lorsque l'on a affaire à une donnée définie comme constante, on ne peut appeler que des fonctions libres qui recoivent cette donnée sous forme de valeur ou sous forme de référence constante et on ne peut appeler que les fonctions membres qui se sont explicitement engagées à ne pas la modifier.

Par contre, quand on a affaire à une donnée qui n'est pas définie comme constante, on peut faire appel à n'importe quelle fonction : les fonctions membres qui se sont engagées à ne pas la modifier comme n'importe quelle autre.

Ce principe est connu sous le terme de const-correctness et est particulièrement intéressant à garder à l'esprit (toute fonction ne devant pas modifier une donnée devrait manipulée cette donnée sous une forme constante), car cela te permettra souvent d'éviter bien des heures de débugage et d'arrachage de cheveux à te demander "mais où et pourquoi cette @#@@@ de donnée a été modifiée???"