Discussion :

[Nadd]

Bonsoir,

J'ai crée une classe t_matrix dont certains opérateurs ont été surchargés, afin notamment de supporter l'addition, la soustration et la multiplication de deux objets t_matrix. Les données sont stockées dans un tableau float *. Voici les prototypes de ces surcharges :

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
 
        // operator=:
        //  defines operator =
        t_matrix & operator=(const t_matrix & toCopy);
 
        // operator+:
        //  computes this+arg
        t_matrix operator+(const t_matrix & arg);
 
        // operator-:
        //  computes this-arg
        t_matrix operator-(const t_matrix & arg);
 
        // operator*:
        //  computes this*arg
        t_matrix operator*(const t_matrix & arg);
 
        // operator*:
        //  computes this*arg
        t_matrix operator*(const double arg);
 
        // operator*:
        //  computes arg*_matrix
        friend t_matrix operator*(const double arg, const t_matrix & _matrix);

J'ai également défini un constructeur de copie :

Code :

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

1
2
3
4
 
        // t_matrix:
        //  constructor of copy
        t_matrix(const t_matrix & toCopy);

Prenons un exemple :

Code :

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

1
2
3
4
5
6
7
 
t_matrix A(3, 3, 1.0); // dim : m*n, valeur initiale = 1.0
t_matrix x(3, 3, 3.0);
t_matrix K = A*x;
t_matrix L = A;
t_matrix M(3, 3, 0.0);
M = A;

Lorsque j'effectue l'affectation via t_matrix L = A, le constructeur de copie est bien appelé et fait son travail. Lorsque j'effectue l'affection via M = A, il s'agit de l'opérateur d'affectation. Mais lorsque j'effectue A*x, qui retourne un objet de type t_matrix, ni le constructeur de copie ni l'opérateur d'affectation n'est appelé.

J'obtiens donc par la suite des erreurs de double free or corruption probablement à cause d'un double appel delete mat, où mat est de type float *.

Une subtilité (ou pas) doit probablement m'échapper... Help!

En vous remerciant d'avance,

Nicolas.

[Nadd]

Après recompilation, le tout semble fonctionner.

Le constructeur de copie est bien appelé pour t_matrix L = A*x.

EDIT:

Le fait d'utiliser t_matrix & t_matrix(const t_matrix & toCopy) ou t_matrix t_matrix(const t_matrix & toCopy) semble affecter le fonctionnement du problème : l'opérateur d'affectation est appelé dans tous les cas lorsque le retour s'effectue par référence alors que le constructeur de copie et l'opérateur d'affectation sont appelés tous les deux (reste à savoir dans quels cas) lorsqu'il n'y a pas de &.

Pourquoi ?

[Xtrem_Voyageur]

Code :

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

1
2
 
Le fait d'utiliser t_matrix & t_matrix(const t_matrix & toCopy) ou t_matrix t_matrix(const t_matrix & toCopy)

Je suppose qu'il s'agit d'une maladresse mais un contructeur ne retourne rien.

Quand tu fais

Code :

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

1
2
 
t_matrix L = A*x

Effectivement, la matrice L est déclarée et initialisée pour la première fois, c'est donc bien le constructeur par copie qui est appelé :

Code :

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

1
2
 
t_matrix(const t_matrix& toCopy)

Il se charge de construire et initialiser ta matrice L à partir d'un référence sur la matrice 'TEMP' retournée par A*x.

Quel est ton problème, qu'est ce qui ne fonctionne pas?

[Nadd]

Bonjour,

Je suppose qu'il s'agit d'une maladresse mais un contructeur ne retourne rien.

Effectivement. Heureusement, elle ne figure pas dans mon code.

Selon que j'utilise cette définition :

Code :

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

1
2
 
t_matrix operator=(const t_matrix & arg)

ou celle-ci :

Code :

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

1
2
 
t_matrix & operator=(const t_matrix & arg)

pour l'opérateur d'affectation, le comportement du programme n'est pas le même. Lorsque la première définition est utilisée, l'opérateur d'affectation et le constructeur de copie sont tous les deux utilisés durant le programme (il s'agit d'un algorithme de point intérieur). Lorsque la seconde définition est utilisée, seul l'opérateur d'affectation est utilisé. Or, le résultat retourné par le programme est identique (et correct) dans les deux cas.

Je cherche donc à comprendre pourquoi...

Bien à vous,

Nicolas.

[Joel F]

l'operator= renvoie *par définition* une reference vers l'objet modifié.
Si tu renvois une valeur, tu va la copier a chaque sortie de =.

[3DArchi]

Salut,

Une subtilité (ou pas) doit probablement m'échapper... Help!

Une erreur dans le constructeur de copie, l'opérateur d'affectation ou l'opérateur surchargé. En l'absence de leur code, difficile de répondre.

Ensuite, tu peux séparer la gestion du stockage de la classe matrice (SRP quand tu nous tiens). Cela clarifiera les différentes classes ne leur laissant qu'une seule responsabilité bien identifiée.

[oodini]

Ensuite, tu peux séparer la gestion du stockage de la classe matrice (SRP quand tu nous tiens). Cela clarifiera les différentes classes ne leur laissant qu'une seule responsabilité bien identifiée.

C'est ce que j'ai fait avec la mienne, mais du coup, je me demande quelle est la responsabilité de ma classe Matrix, complètement dépouillée... Il n'y reste que des opérateurs, en gros.
D'ailleurs, un commentaire sur le site d'Emmanuel Deloget fait mention d'un pattern "anémique". :-)

[Flob90]

C'est ce que j'ai fait avec la mienne, mais du coup, je me demande quelle est la responsabilité de ma classe Matrix, complètement dépouillée... Il n'y reste que des opérateurs, en gros.
D'ailleurs, un commentaire sur le site d'Emmanuel Deloget fait mention d'un pattern "anémique". :-)

Responsabilité d'une classe matrice ? Offrir la sémantique nécessaire pour représenter le concept mathématique d'une matrice (et rien d'autre) (*). C'est la première idée qui me vient et me semble suffisament fine (**), on remarque d'ailleurs qu'elle n'inclut aucune idée sur le stockage (par exemple).

(*) Par extension ca s'applique à n'importe quel élément des mathématiques qu'on voudrait introduire dans un architecture logiciel.

(**) Elle peut demander d'être préciser. Le concept mathématique de matrice est lié à suffisament d'autre concepts pour (au moins) se poser des questions (application linéaire sur un espace vectoriel par exemple). Ca peut aussi dépendre de ce qu'on va en faire et de la granularité qu'on désire.

[Nadd]

Bonsoir,

Voici le code du constructeur de copie :

Code :

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

1
2
3
4
5
6
 
    t_matrix::t_matrix(const t_matrix & toCopy) : m(toCopy.m), n(toCopy.n)
    {
        mat = new double[m*n];   
        cblas_dcopy(m*n, toCopy.mat, 1, mat, 1);
    }

et celui de l'opérateur d'affectation :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
    t_matrix & t_matrix::operator=(const t_matrix & toCopy)
    {
        m = toCopy.m, n = toCopy.n;
 
        mat = new double[m*n];
        cblas_dcopy(m*n, toCopy.mat, 1, mat, 1);
 
        return *this;
    }

Sous cette version, l'opérateur d'affection est le seul a être appelé, même pour ce genre d'instruction : t_matrix y = A*x.

Les données de la matrice sont stockées dans une variable double * afin de s'aligner sur les spécifications de CBLAS.

N'ayez crainte, l'absence de vérifications sur les paramètres est volontaire.

Le principe de responsabilité unique est intéressant. Néanmoins, je ne pense pas en avoir l'utilité pour le moment.

Bien à vous,

Nicolas.

[3DArchi]

Salut,

Le principe de responsabilité unique est intéressant. Néanmoins, je ne pense pas en avoir l'utilité pour le moment.

Très drôle ! Un principe de base de l'architecture logicielle ? Ne pas en avoir besoin. Cela revient à dire : "je pourrais bien coder, mais je n'en ai pas besoin. Alors je pense que je vais faire que du code spaghetti." Sérieusement, c'est très drôle. Évite de dire ça à ton client quand même.

L'opérateur = provoque une fuite mémoire.

Cf l'idiom copy&swap

Pourquoi ne pas utiliser un std::vector<double> ?

A quoi ressemblent :
=> le constructeur par défaut,
=> le destructeur,
=> l'opérateur *
?