Bonjour,
J'ai lu la FAQ sur la surcharge d'opérateurs ici:
http://cpp.developpez.com/faq/cpp/?p...GE_affectation
Néanmoins, j'ai beaucoup de mal à définir la surcharge de mon opérateur d'affectation.
Je travaille sur des matrices génériques, dans mon cas la ressource brute est:
T * representation;
et initialisée de la façon suivante:
representation = new T[nLignes*nColonnes];
ou nLignes et nColonnes sont deux entiers.
J'ai su faire la surcharge du constructeur de copie de la façon suivante:
J'ai donc fait mon destructeur et mon opérateur d'affectation de la façon suivante:
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 Matrice ( const Matrice<T> & other ) { this->nLignes = other.nLignes; this->nColonnes = other.nColonnes; if (other.representation) { this->representation = new T(nLignes*nColonnes); for(int i = 0; i<nLignes; ++i) { for(int j = 0; j<nColonnes; ++j) { this->representation[i*nColonnes + j] = other.representation[i*nColonnes + j]; //Si la matrice contient des pointeurs, on est morts !!! } } } else this->representation = NULL; };
Bon hier soir cela plantait (je faisais une somme de matrices) et j'ai fait des modifs aujourd'hui cela fonctionne, je ne sais pas trop d'ou venaient les problèmes car j'ai cherché dans plusieurs directions à la fois.
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 ~Matrice () { cout << "destructeur de\n" ; this->afficher(); delete this->representation; }; Matrice<T>& operator=( const Matrice<T> & other) { Matrice temp(other); // Réaffectation : on prend les nouvelles données dans Temp, et on lui // donne les données à détruire en échange swap(temp.representation, this->representation); return *this; };
Mes questions sont les suivantes:
- relativement à la FAQ, mes trois méthodes - constructeur de copie, opérateur d'affectation, destructeur - sont elles correctes ?
- Ceci devrait fonctionner dans que "representation" contient des objets et non des adresses: un entier, un float.... mais si un jour je me décide à coller des pointeurs d'entiers à l'intérieur je crois que je vais droit dans le mur.
Y'a t'il une bonne façon pour implémenter ceci ? Par exemple representation pourrait ne travailler QUE avec des adresses, même si l'utilisateur passe des int ?
Dans ce cas, comment dois-je gérer les constructeur de copie, destructeur, et opérateur d'affectation ?
- Question subsidiaire: je suis dans l'incapacité de surcharger l'opérateur << sans faire appel à des accesseurs, representation étant privé et ceci malgré cette déclaration:
friend ostream& operato<><<(ostream&, Matrice<T> & );
ou
friend ostream& operato<<<>(ostream&, Matrice<T> & );
qui génèrent toutes deux des erreurs de compilation, que dois-je faire exactement ?
Merci beaucoup !
Partager