Discussion :

[Bestiol]

Bonjour à tous !

J'ai un petit problème avec C++ et les constructeurs de copie... j'avoue être un peu perdu, et là j'ai une erreur dont je ne comprends pas l'origine, ni la manière de la résoudre, du coup.

Le contexte est le suivant :
J'ai une classe TMatrix qui gère une matrice de TComplex (qui est une autre classe perso pour laquelle je n'ai pas de souci). Elle possède un constructeur permettant de spécifier le nombre de lignes et de colonnes à la création, et un constructeur de copie.

Mon problème se situe je pense au niveau de ce constructeur de copie. Si on considère le code suivant :

Code :

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

1
2
3
4
TMatrix m1(2,2), m2(2,2), m3(2,2);
// ... assignation des valeurs de m1 et m2, aucun pb ici ...
 
m3 = m1 + m2;

La dernière ligne me génère une erreur à la compilation (j'utilise gcc) :

error: no matching function for call to ‘TMatrix::TMatrix(TMatrix)’

Pour moi cette erreur m'indique que le compilateur ne trouve pas de constructeur adéquat pour une assignation du résultat de l'addition à m3.
J'ai bien sûr surchargé l'opérateur +, et si je supprime "m3 =" de la ligne incriminée je n'ai plus d'erreur.

Ma classe est définie ainsi :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
class TMatrix {
	private:
		TComplex **fMatrix;
		int fRows, fCols;
 
		//Procédure d'initialisation du tableau de TComplex
		void InitializeMatrix(TComplex ***m, int rows, int cols);
	public:
		TMatrix(const int rows, const int cols);	//Constructeur
		TMatrix(TMatrix &m); 						//Constructeur de copie
                ....

Et voici l'implémentation de mon constructeur de copie :

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
TMatrix::TMatrix(TMatrix &m)
{
	fRows = m.fRows;
	fCols = m.fCols;
 
	//Initialization de la nouvelle matrice
	InitializeMatrix(&fMatrix, fRows, fCols);
 
	//Copie des valeurs
	for(int i = 0; i < fRows; i++)
	{
		for(int j = 0; j < fCols; j++)
			fMatrix[i][j] = m.GetComplex(i, j);	
	}
}

Vue l'erreur j'imagine que le corps en lui-même du constructeur n'est pas à mettre en cause, du moins dans un premier temps....

Si besoin, voici ce qui concerne la surcharge de mon opérateur + :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
TMatrix TMatrix::operator+(const TMatrix m) const
{
	TMatrix sum(fRows, fCols);	
 
	for(int i = 0; i < fRows; i++)
		for(int j = 0; j < fCols; j++)
		{
			sum.GetComplex(i, j).SetRealPart(GetComplex(i, j).GetRealPart() + m.GetComplex(i, j).GetRealPart());
			sum.GetComplex(i, j).SetImagPart(GetComplex(i, j).GetImagPart() + m.GetComplex(i, j).GetImagPart());
		}
 
	return sum;
}

J'ai utilisé la syntaxe donnée dans ce cours :
ftp://ftp2.developpez.be/developps/c/PolyCpp.pdf

Ca a très bien fonctionné pour ma classe TComplex (qui gère la partie réelle/imaginaire d'un nombre complexe et les opérations de base entre deux TComplex), et je ne comprends vraiment pas ce qui bloque ici

Est-ce que quelqu'un pourrait m'éclairer ?


Bestiol.

ps: excusez tous les noms en Anglais, je n'ai pas le choix

[Luc Hermitte]

Manque le const qui permet d'accepter des temporaires non nommés.
Si ton cours a oublié cela et si jamais il te pousse vers les tests anti auto-affectation, tu peux en changer.


Le bon squelette type pour ce genre de classes

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
struct M
{
    M(size_t ligs, size_t cols) 
        : ligs_(ligs), cols_(cols), buffer( new...)
    { voir faq pour ce qui manque }
 
    M(M const& rhs) // ref constante
        : ligs_(rhs.ligs_), cols_(rhs.cols_), buffer( new...)
    { std::copy(....) }
 
    M & operator=(M const& rhs) {
        // pas de test contre contre l'auto-affectation
        M temp(rhs); // copie
        temp . swap(*this); // + echange
        return *this;
    } // + libération => affectation atomique vue de l'extérieur
 
    void swap(M & other) {
        std::swap(ligs_, other.ligs_);
        std::swap(cols_, other.cols_);
        std::swap(buffer_, other.buffer_);
    }
 
    // membre
    M & operator+=(M const& rhs) {
        .....
        return *this;
    }
....
};
 
// function libre (i.e. non membre) et non ami. Oui oui.
M operator+(M const& lhs, M const& rhs) {
    return M(lhs)+=rhs;
}

Exos suivants:
- compléter
- définir un proxy agissant comme une vue sur un ligne
- définir un proxy agissant comme une vue sur une colonne
- rendre générique
- éliminer les temporaires
- exploiter les pipelines
- ...


EDIT: si ce n'est pas pour un exo, tu arrêtes tout de suite les dégats et explique à tes chefs que le NIH va vous faire perdre beaucoup de temps, et donc d'argent. Blitz++, boost.uBLAS, MTL, newMat, etc. sont vos précieux amis. De même que std::complex.
Sinon, c'est un excellent exercice pour tous niveaux.

[JolyLoic]

2/3 trucs en vrac vite fait :

Code :

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

1
2
T a, b;
b = a;

On appelle là l'opérateur=, pas le constructeur par recopie.

Code :

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

1
2
T a;
T b = a;

On appelle là le constructeur par recopie.

Ensuite, ton constructeur par recopie ne modifie pas son argument, il devrait le prendre par référence constante.

L'opérateur + défini dans la classe est en général une mauvaise idée (car plus symétrique...)

Pour ce qui est du cours utilisé, j'en avais fait une critique à une époque, qui indique quelques erreurs. Suite à des manips techniques que je n'ai pas trop suivies de mon hébergeur, elle n'est plus en ligne pour l'instant, mais je l'ai jointe à cette réponse.
langageCpp_HenriGaretta.html

[Bestiol]

Merci JolyLoic j'y vois un peu plus clair sur certaines choses

Luc merci aussi pour ta réponse, cependant ton post me rappelle un peu pourquoi je n'aime pas le C++...
Pour moi qui ne suis qu'un autodidacte réticent avec ce langage, ton message est presque incompréhensible

Je vais quand même essayer de partir de ce que vous me dites tous les deux pour chercher un peu plus loin et régler mon problème...



edit: jcommence à mieux piger ^^

[Bestiol]

ayé, ça marche !!

En me concentrant comme il faut j'ai fini par comprendre le fonctionnement de ton code Luc, et du coup j'ai pu l'adapter à mon cas.
Une question toutefois : tu utilises swap pour l'opérateur =. Une simple copie des valeurs n'aurait-elle pas suffi ?

Sinon, il va falloir que je voie sérieusement un cours suffisamment complet sur les références et le mot-clef const car j'avoue que j'utilise un peu au pif jusqu'à ce que ça fonctionne

Encore à vous deux !!!!


et vive delphi
(qui ne permet pas la surcharge des opérateurs )

[Luc Hermitte]

En interne tu as très certainement un buffer que tu as alloué.
Tu ne peux pas te permette une copie superficielle sinon deux destructeurs chercheront à détruire le même buffer.

Ensuite, l'astuce du swap permet de s'assurer simplement une affectation exception-safe (si une exception est levée lors d'une allocation, alors rien n'est perdu, rien n'est invalidé). Bref, une affectation atomique. Et en plus, cela est résistant aux drôle de situations qui n'arrivent jamais en pratique du genre: "m = m;".
Je crois bien que la FAQ en parle.

Sinon, désolé pour le code concis d'hier soir. Je n'ai pas toujours le temps de donner tous les commentaires ce qui pourrait s'apparenter à un TD complet.

[Bestiol]

Merci pour ces précisions

Sinon, désolé pour le code concis d'hier soir. Je n'ai pas toujours le temps de donner tous les commentaires ce qui pourrait s'apparenter à un TD complet.

C'est po grave... c'est surtout moi qui ai été un peu "désagréable" en voyant un code censé fonctionner qui m'était illisible au premier abord après avoir passé quelques heures sur mon propre code, qui y ressemblait beaucoup !
(et puis il était 1h du mat', pour toi comme pour moi c'est pas forcément l'heure où on est le plus opé )