Discussion :

[Zangdaarr]

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:

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;
    };

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
 
    ~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;
 
    };

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.

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 !

[Goten]

Ton opérateur d'affectation il copie pas toute les données :
this->nLignes = other.nLignes;
this->nColonnes = other.nColonnes;

Et ton swap il a quel tête? (std ? fonction membre de la classe?)

Sinon ton opérateur d'affectation pourrait avoir cette signature :

Matrice<T>& operator=(Matrice<T> other)

dans certain cas ça sera plus rapide que l'autre (et jamais plus lent).

Pour l'op << montre le code entier.

[N i h i l]

Code :

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

1
2
3
4
5
6
7
8
9
10
Matrice ( const Matrice<T> & other )
    {
// ...
       if (other.representation)
        {
            this->representation = new T(nLignes*nColonnes);

// Ici tu crées un T initialisé avec le résultat de nbLignes*nColonnes ; ce que tu veux c'est 
new T[nbLignes*nColonnes];

Mes questions sont les suivantes:

- relativement à la FAQ, mes trois méthodes - constructeur de copie, opérateur d'affectation, destructeur - sont elles correctes ?

Je n'ai pas lu la FAQ :-) Je n'ai pas vu d'erreur.

- 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 ?

Tu te poses trop de questions. Tu as le même problème avec un std::vector<> et il est résolu avec des pointeurs « intelligents ».

- 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 ?

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
// Forward déclarations
template< typename T >                                                                                                                                                               
struct Matrix;
 
template< typename T >                                                                                                                                                               
std::ostream &                                                                                                                                                                       
operator<<(std::ostream &, Matrix< T > const &);
 
// La classe Matrix
template< typename T >                                                                                                                                                               
class Matrix {                                                                                                                                                                      
 
 // ...
 
 friend std::ostream &                                                                                                                                                               
 operator<< <>(std::ostream &, Matrix< T > const &);                                                                                                                    
 
};

[Zangdaarr]

Le swap est celui de STD, conformément à la FAQ qui est écrite sur ce site

Quelles données sont oubliées ?

L'opérateur d'affectation pour l'instant je le fais ainsi:

Méthode publique:

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
    /** -- SURCHARGE DE << -- **/
    ostream& afficher(ostream &out)
    {
        int n = this->nLignes; //Nombre de lignes matrice de gauche
        int p = this->nColonnes; //Nombre de colones matrice de droite
 
        for(int i = 0; i<n; ++i)
        {
            for(int j = 0; j<p; ++j)
            {
                out << this->representation[i*nColonnes +j] << "  ";
                //Il a été prouvé ici par un matrice temp = *this; que le constructeur de copie ne marchait pas. En effet ceci appelle l'opérateur d'affecation qui appele le constructeur de copie.
            }
            out << "\n";
        }
        return out;
    };

Hors de la classe:

Code :

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

1
2
3
4
5
6
7
 
template <class T>
ostream & operator<<(ostream& out,Matrice<T> & m)
{
 
    return m.afficher(out);
}

La surcharge ne me pose en soit aucun problème, c'est juste le friend que je n'arrive pas à faire.
Dans une classe template il faut rajouter <>, mais ça plante quand même.
Du coup je suis obligé soit de passer par des accesseurs, soit par cette méthode affiche, et bien sur, je ne souhaite ni l'un ni l'autre.

NiHi:

Merci pour les crochets Effectivement cela fonctionne bien mieux ainsi, j'ai pu faire ma surcharge de + sans crasher désormais et je ne détruis plus d'instances contenant des valeurs irréelles à la fin du programme.

Pour la surcharge de <<, c'est précisement ce que j'essaie de faire, j'obtiens:

error: template-id 'operator<< <>' for 'std::ostream& operator<<(std::ostream&, const Matrice<int>&)' does not match any template declaration|

Pour les pointeurs: donc je laisse couler en fait ? Est-ce que je peux prémunir ma classe d'utilisations illicites ?

[N i h i l]

Code :

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

1
2
    /** -- SURCHARGE DE << -- **/
    ostream& afficher(ostream &out)

devrait être

Code :

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

ostream& afficher(ostream &out) const

Hors de la classe:

Code :

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

1
2
3
 
template <class T>
ostream & operator<<(ostream& out,Matrice<T> & m)

devrait être

Code :

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

1
2
template <class T>
ostream & operator<<(ostream& out,Matrice<T> const & m)

Pour la surcharge de <<, c'est précisement ce que j'essaie de faire, j'obtiens:

error: template-id 'operator<< <>' for 'std::ostream& operator<<(std::ostream&, const Matrice<int>&)' does not match any template declaration|

Avec les const qui vont bien, le compilateur devrait être content.

Pour les pointeurs: donc je laisse couler en fait ? Est-ce que je peux prémunir ma classe d'utilisations illicites ?

Tu fais ce que tu veux, mais je ne vois pas l'interêt de compliquer du code pour une une hypothétique (et improbable) utilisation (qu'est-ce que la somme, le produit, ... de matrices de pointeurs ?).

Si tu veux te prémunir de l'utilisation de ta classe avec des pointeurs, tu déclares une spécialisation que tu n'implémentes pas :

Code :

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

1
2
3
4
5
 
// Not implemented
template<>
template< typename T >
class Matrix< T *>;

[Arzar]

Bonjour,

Il y a deux trois choses qui me font tiquer dans le code donné dans le premier post.
D'abord deux bugs manifestes :

Code :

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

1
2
3
4
5
6
~Matrice ()
{
    cout << "destructeur de\n" ;
    this->afficher();
    delete this->representation;
};

Il faut remplacer "delete this->representation;" par "delete[] this->representation;" (la règle est un new -> un delete, un new[] -> un delete[])
Je pense que ça explique les comportements un peu aléatoires que tu as observé.

Code :

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

1
2
3
4
5
6
7
8
9
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;
};

Comme dit par Goten il faut aussi swapper le nombre de ligne et nombre de colonne.

Ensuite, il me semble qu'on peut améliorer un peu l'implémentation du constructeur par copie.
Déjà remplacer :

Code :

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

1
2
3
4
5
6
7
8
 
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 !!!
   }
}

par

Code :

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

1
2
 
std::copy(other.representation, other.representation + nLignes*nColonnes, representation);

C'est plus court, plus clair et probablement plus efficace dans certain cas, car par exemple si T est un int alors std::copy appellera memcpy.

Autre chose pour le constructeur par copie, j'aurais tendance à blinder un peu plus le code, on ne se sait jamais ce que les fourbes d'utilisateur iront inventer.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
Matrice ( const Matrice<T> & other ) :
nLignes (0),
nColonnes (0),
representation(NULL)
{
   if(other.nLignes > 0 && other.nColonnes > 0 && other.representation != NULL)
   {
      nLignes = other.nLignes;
      nColonnes = other.nColonnes;
      representation = new T(nLignes*nColonnes);
      std::copy(other.representation, other.representation + nLignes*nColonnes, representation);
   }
};

[Zangdaarr]

Merci pour ces réponses,

J'avais un peu délaissé le sujet car désormais le code fonctionne bien et sans aucun crash.
Je vais prendre en compte ces dernières remarques pour l'améliorer.

Je n'ai pas trop compris le coup du copy mais je vais regarder ça plus en détails.

Par rapport aux pointeurs, je n'entendais pas multilpier des pointeurs entre eux évidement, mais multiplier les valeurs pointées par ces pointeurs. Quand je défini une classe et que j'ai besoin de plusieurs instances de cette classe j'utilise rarement une variable de cette classe mais plutôt un pointeur vers une instance de cette classe.

Il est possible de définir des lois d'addition et de multiplication pour une classe donnée et dans ce cas la matrice que j'aurais faite ne fonctionnera pas, sauf si je lui donne l'objet et non l'adresse de l'objet.

[Zangdaarr]

J'ai une question supplémentaire,

Je dois faire une surcharge de () pour cette classe.
Je souhaite la sécuriser pour ne pas que l'utilisateur puisse dépasser les limites de la taille de la matrice. Or je me suis rendu compte que l'usage de mon tableau:

return this->representation[i*nColonnes +j];

Ne renvoyait aucune exception out of bound

Au contraire il se contente de renvoyer et/ou d'écrire la valeur fournie à l'endroit ou on le lui demande .... (par chance ça ne crashe pas pour le moment quand je fais cela).

J'ai donc développé moi même une exception mais je souhaite ne pas avoir à faire un bloc try/catch à chaque fois que j'appelle () ...

Donc j'ai fait qq chose dans le genre:

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
 
    /** -- SURCHARGE DE () -- **/
    T & operator ()(unsigned int i, unsigned int j)
    /** CET OPERATEUR TRAVAILLE EN BASE 1 **/
    {
        try
        {
            this->ValidRange(i,j);
            --i;
        --j; //Recalage sur la base 0
return this->representation[i*nColonnes +j];
 
        }
        catch(string param)
        {
            cout << param;
        }
 
    };
 
    void ValidRange(unsigned int i, unsigned int j)
    {
        if (i<1 || i>this->nLignes || j<1 || j>this->nColonnes)
        {
            ostringstream oss;
            oss << "i doit etre compris entre 1 et " << nLignes << " et j doit etre compris entre 1 et " << nColonnes << endl;
            throw  oss.str();
        }
    };

Le soucis c'est qu'il faut absolument renvoyer qq chose en sortie dans le catch, et je ne vois pas quoi renvoyer. Sachant qu'en plus l'appel de () peut être combiné à un cout.

Deux questions subsidaires en plus sur ce point:

- Lorsque je fais matrice(1,1) = -10, cela fonctionne. -10 est affecté à representation[0]. Je ne vois pas comment cela se produit.

- Lorsque je j'appelle () dans le corps de ma classe, cela fonctionne plutôt mal, la surcharge de << elle fonctionne très bien dans le corps de ma classe. Comment cela se fait- il ?

Merci pour l'Aide

Autre point, maintenant par rapport à l'opérateur d'affectation:

Je réalise bien le swap des lignes et des colonnes désormais, mais si cela donne satisfaction dans le cas ou la matrice qui prend la nouvelle valeur a ses deux côtés plus grands que la matrice que l'on affecte, ce n'est pas le cas si l'un des deux côtés est plus petit.

Exemple:

Code :

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

1
2
3
4
5
    //Affectation
    Matrice<int> mat7(1,1,"matrice 7");
    cout<< "\nMatrice 7 a l'initialisation\n" << mat7 << " : c'est une 1x1 \n";
    mat4 = mat1;
    cout<< "\nMatrice 7 par affectation de mat 1\n"<< mat7 << " : c'est devenu une 3x2 !\n";

Donne:

Matrice 7 a l'initialisation
0
: c'est une 1x1
destructeur de copie de matrice1
1 2
3 4
5 6


Matrice 7 par affectation de mat 1
0
: c'est devenu une 3x2 !

Pourquoi n'est-il pas possible de renvoyer temp au lieu de *this ?
Cela simplifierait les choses.Je comprends que temp est détruit au terme de l'appel mais pourtant je me suis déjà retrouvé dans ce cas ici :

Code :

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

1
2
3
4
5
6
7
8
compte AjoutSomme(const compte& c, int v)
{
    cout << "Debut ajout " << endl;
    compte temp(c);
    temp.solde = temp.solde+v;
    cout << "Fin ajout " << endl;
    return temp;
}

Il s'agissait de compte bancaires et de faire un ajout sur un compte c, le prof insistait pour que c soit constant et ce fût donc la seule solution: et elle marche ! Temp étant ensuite envoyé vers .... l'opérateur d'affectation (l'appel se faisant ainsi : c3 = AjoutSomme(c3,2000)

Autrement: comment puis-je traiter ce cas ?

[3DArchi]

Le soucis c'est qu'il faut absolument renvoyer qq chose en sortie dans le catch, et je ne vois pas quoi renvoyer.

Ben, si les paramètres sont invalides, l'exception est à retourner à l'appelant et pas à traiter par ta fonction. Ca n'a pas trop de sens.
Sinon,

- Lorsque je fais matrice(1,1) = -10, cela fonctionne. -10 est affecté à representation[0]. Je ne vois pas comment cela se produit.

Ta fonctions () renvoi une référence sur la case du tableau. C'est pour ça que tu peux la modifier. Si tu ne souhaites pas alors il faut renvoyer une référence constante :

Code :

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

1
2
T & operator ()(unsigned int i, unsigned int j);
T const & operator ()(unsigned int i, unsigned int j)const; // ou par valeur : T const operator ()(unsigned int i, unsigned int j)const

- Lorsque je j'appelle () dans le corps de ma classe, cela fonctionne plutôt mal, la surcharge de << elle fonctionne très bien dans le corps de ma classe. Comment cela se fait- il ?

il doit y a voir une erreur dans ta classe

Autre point, maintenant par rapport à l'opérateur d'affectation:

Je réalise bien le swap des lignes et des colonnes désormais, mais si cela donne satisfaction dans le cas ou la matrice qui prend la nouvelle valeur a ses deux côtés plus grands que la matrice que l'on affecte, ce n'est pas le cas si l'un des deux côtés est plus petit.

Il doit rester des erreurs. Remontre les opérateurs d'affectation et le constructeur par copie

Pourquoi n'est-il pas possible de renvoyer temp au lieu de *this ?
Cela simplifierait les choses.Je comprends que temp est détruit au terme de l'appel mais pourtant je me suis déjà retrouvé dans ce cas ici :

Code :

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

1
2
3
4
5
6
7
8
compte AjoutSomme(const compte& c, int v)
{
    cout << "Debut ajout " << endl;
    compte temp(c);
    temp.solde = temp.solde+v;
    cout << "Fin ajout " << endl;
    return temp;
}

Ici tu ne retourne pas temp ... mais la valeur retour est une copie de temp. Si tu retourne une référence sur temp, alors ce n'est plus une copie. C'est une référence sur un objet détruit à la sortie de la fonction. Donc c'est une référence invalide.

[Zangdaarr]

Le constructeur de copie et la surcharge de = sont ainsi désormais (je n'ai pas encore utilisé copy):

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
36
37
38
39
40
41
42
43
 
    /** -- CONSTRUCTEUR DE COPIE-- **/
    Matrice( const Matrice<T> & other )
    {
        this->nom = "copie de " + other.nom;
        this->nLignes = other.nLignes;
        this->nColonnes = other.nColonnes;
        if (other.representation)
        {
            this->representation = new T[nLignes*nColonnes];
            for(unsigned int i = 0; i<nLignes; ++i)
            {
                for(unsigned 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;
    };
 
    //matrice ( const UnString &  );//format “nl,nc,val1,val2,..,valnl*nc”
 
    /** -- DESTRUCTEUR -- **/
    ~Matrice ()
    {
        cout << "destructeur de " << this->nom << "\n"<< *this<< endl;
        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.nLignes, this->nLignes);
        swap(temp.nColonnes, this->nColonnes);
        swap(temp.representation, this->representation);
 
        return *this;
 
    };