Attributs privés et surcharge d'opérateurs

Version imprimable

Bonjour,

Voici ma classe Dvector.h :

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
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
/**
 * @class Dvector
 *
 * @brief Représentation d'un vecteur de réels, de dimension quelconque
 *
 */
class Dvector {
 private:
  int dim;
  double * v;  
 
 public:
 
  /**
   * @brief Constructeur par défaut
   *
   * Construit un vecteur de dimension nulle
   */
  Dvector();
 
  /**
   * @brief Constructeur paramétré
   *
   * @param size dimension du vecteur
   * @param init optionnel : valeur d'initialisation (par défaut 0)
   *
   * Construit un vecteur de dimension dim, et initialise ses composantes à init
   */
  Dvector(int size, double init = 0);
 
  /**
   * @brief Constructeur par copie
   * @param Vect le vecteur source
   * Construit un nouveau vecteur par recopie de Vect
   *
   */
  Dvector(const Dvector & Vect);
 
  /**
   * @brief Constructeur à partir d'un fichier
   *
   * @param filename nom du fichier d'entree
   * 
   * Construit un vecteur à partir du fichier d'entree
   */
  Dvector(const char * filename);
 
  /**
   * @brief Destructeur
   */
  ~Dvector();
 
  /**
   * @brief Redéfinition de l'opérateur (), accès à une composante
   * @param i indice de la composante (de O a size() - 1)
   * @return la i-ème composante du vecteur (indices débutanst à 0)
   */
  double & operator()(int i);
 
  Dvector & operator+= (const Dvector & vect);
 
  /**
   * @brief Accesseur
   *
   * @return tableau des composantes
   *
   * Accède au tableau des composantes
   */
 
  double * getV();
 
   /**
   * @brief Accesseur
   * 
   * @return dimension du vecteur
   * 
   * Accède à la dimension du vecteur
   */
  int size();
 
  /**
   * @brief fonction d'affichage
   * 
   * Affiche le vecteur
   **/
  void print();
 
};

J'ai déjà surcharger l'opérateur ( ) pour accéder à une composante du vecteur.

Je cherche à surcharger l'opérateur += dont voici mon implémentation ;

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/* Surcharge d'opérateurs */
 
double & Dvector::operator()(int i){
  return v[i];
}
 
Dvector & Dvector::operator+= (const Dvector & vect) {
 
  assert(dim == vect.dim);
  Dvector & V = *this;
  for (int i = 0; i < dim ; i++) {
	  V(i) += vect.v[i];
  }
  return V ;
}

Quand je teste dans un main cela fonctionne mais déjà je ne comprends pas pourquoi ça compile puisque les attributs sont privés donc on est pas censé pouvoir accéder aux attributs de Vect ?

Autre curiosité, si j'écris vect(i) à la place de vect.v[i] là ça ne compile plus :

Code:

error: passing ‘const Dvector’ as ‘this’ argument of ‘double& Dvector::operator()(int)’ discards qualifiers

Merci de vos conseils.

12/02/2012, 15h42
Arzar

Bonjour,

L'opérateur += est une fonction membre de la classe Dvector. Et comme n'importe quelle fonction membre, il est possible dans le corps de la fonction d’accéder aux membre privés d'une instance quelconque de la classe.
12/02/2012, 15h49
Infophile

Bonjour,

D'accord! Je pensais que cela fonctionnait que pour l'objet sur lequel s'appliquait +=

Une idée pour le problème V(i) ?

Merci
12/02/2012, 15h55
Arzar
C'est parce que tu essayes d’appeler une fonction membre non-const de Dvector (l'opérateur ()) depuis vect qui est une référence constante.
Il faut que tu rajoutes une surcharge const de l'opérateur().
Code:

1 2 3 4 const double & Dvector::operator()(int i) const{ return v[i]; }
Faut s'y faire à ce message d'erreur ("passing blabla as ‘this’ argument of blabla discards qualifiers") car il revient souvent :mrgreen: (en gros dès qu'il y a un problème de constness)

Hum j'ai écrit :

Code:

1
2
3
4
 
const double & Dvector::operator()(int i) const{
  return v[i];
}

et dans .h :

Code:

const double & operator()(int i) const;

et j'ai l'erreur :

Code:

1
2
3
 
Dvector.cpp: In member function ‘Dvector& Dvector::operator+=(const Dvector&)’:
Dvector.cpp:99: error: assignment of read-only location ‘((Dvector*)V)->Dvector::operator()(i)’

12/02/2012, 15h57
Arzar
Il manque un const dans le .h ;)

Eidt : Et j'ai bien parlé d'une surcharge hein ? Il faut que les deux surcharges soit présentes pour que le compilateur choisisse la bonne en fonction de la constness de l'appelant.

Dans le .h
Code:

1 2 3 double & operator()(int i); const double & operator()(int i) const;
Dans le .cpp
Code:

1 2 3 4 5 6 7 double & Dvector::operator()(int i){ return v[i]; } const double & Dvector::operator()(int i) const{ return v[i]; }

.cpp :

Code:

1
2
3
4
5
6
7
const double & Dvector::operator()(int i) const{
  return v[i];
}
 
double & Dvector::operator()(int i) {
  return v[i];
}

.h :

Code:

1
2
3
 double & operator()(int i);
 
  Dvector & operator+= (const Dvector & vect);

erreur :

Code:

1
2
Dvector.cpp: In member function ‘Dvector& Dvector::operator+=(const Dvector&)’:
Dvector.cpp:101: error: assignment of read-only location ‘((Dvector*)V)->Dvector::operator()(i)’

à cause de V(i) += vect.v[i];

12/02/2012, 16h07
Infophile

OK l'ordre a une importance !! merci :)
12/02/2012, 19h30
JolyLoic

Non, l'ordre n'a pas d'importance...