Discussion :

[oswalidos]

salut
j'ai ecrit un constructeur de copie et je veux que l'operateur = lui fait appel
je crois que : "par defaut l'operateur = fait une simple copie des attributs" . puisque ma classe contient des pointeurs , les affectations provoquent des violation memoire !
je pense que : "si l'opérateur = fait appel a mon constructeur de copie je peux eviter ces erreurs.
est ce que c'est faisable ce je suis entrain de raconter ? si oui comment ?
merci d'avance

[3DArchi]

Bonjour,
Un petit peu de recherche t'aurais fait découvrir cette merveilleuse discussion de la semaine dernière et qui doit répondre à ton problème.

[oswalidos]

je crois aussi que si je surcharge le = pour qu'il fait appel au constructeur de copie ,il doit au debut faire appel au destructeur pour libérer l'espace memoire allouer par l'objet a affecté(a gauche de =) puis je fait appel au constructeur de copie .
c'est realisable ou je dit du n'importe quoi ?

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
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
 
/***********main.cpp*************/
int main(){
/***********************1. Saisir deux expressions**************************/
Expression expr1;
Expression expr2;
    cout << "donner la premiere expression : " ;
    cin >> expr1;
    cout << "donner la deuxieme expression : " ;
    cin.sync();  //vider le flux entrant
    cin >> expr2;
 
/**********************2. Afficher les deux expressions.************************/
    cout << "la premiere expression : " << expr1 << endl;
    cout << "la deuxieme expression : " << expr2 << endl;
 
/******3. Trier les fractions des deux expressions selon l'un des modes de son choix (croissant ou décroissant):****/
Expression expr3;
char ch=0;
encore: cout << "Appuier sur \'c\' pour trier l'expression dans l'ordre croissant" << endl;
        cout << "Appuier sur \'d\' pour trier l'expression dans l'ordre decroissant" << endl;
 
    cin >> ch;
 
    switch (ch)
    {
    case 'c' :
    case 'C' :
        cout << "l'expression triee dans l'ordre croissant est : ";
        expr3=expr1.trier1();
        cout << expr3 << endl;
        break;
    case 'd' :
    case 'D' :
        cout << "l'expression triee dans l'ordre decroissant est : ";
        expr3=expr1.trier2();
        cout << expr3 << endl;
        break;
    default :
        goto encore;
    }
 
 
/***********************4. Evaluer la somme de la 1ère expression.**************************/
    Fraction frac_som;
    frac_som=expr1.somme();
    Expression expr_som;
    expr_som=expr_som.insert(frac_som);
    cout << "Evaluation de la 1ère expression : "<< expr_som << endl;
 
 
/**************************5. Echanger les deux expressions******************************/
    expr3=expr1;
    expr1=expr2;
    expr2=expr3;
 
    cout << "la premiere expression : " << expr1 << endl;
    cout << "la deuxieme expression : " << expr2 << endl;
 
    return 0;
}

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
 
/************Expression.h*************/
#ifndef DEF_EXPRESSION
#define DEF_EXPRESSION
 
#include <iostream>
#include "fraction.h"
#include "ElementListe.h"
 
using namespace std;
 
class Expression{
    public:
    Expression();
    Expression(const Expression& e);
    Expression& insert(Fraction val);
    ElementListe *getDebut();
    int getTaille();
    void affiche();
    Fraction& somme();
    Expression& trier1();
    Expression& trier2();
    ~Expression();
 
    private:
    int taille;
    ElementListe *debut;
    ElementListe *fin;
};
istream& operator>>(istream& is, Expression& expr);
ostream& operator<<(ostream& os, Expression& expr);
 
#endif

[3DArchi]

je crois aussi que si je surcharge le = pour qu'il fait appel au constructeur de copie ,il doit au debut faire appel au destructeur pour libérer l'espace memoire allouer par l'objet a affecté(a gauche de =) puis je fait appel au constructeur de copie .
c'est realisable ou je dit du n'importe quoi ?

C'est pour ça qu'il y a utilisation d'un swap et d'une variable temporaire (le paramètre par valeur):

Code :

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

1
2
3
4
5
6
7
8
9
10
MaClasse& MaClasse::operator=(MaClasse tmp) //par valeur
{
	Swap(tmp);
	return *this;
}// A la sortie tmp est détruit et les pointeurs ayant été échangés, le précédent sera détruit.
 
void MaClasse::Swap(MaClasse &other)
{
	std::swap(m_pointeur, other.m_pointeur);// On échange les pointeurs
}

[oswalidos]

merci
mon cas est un peu different ,les pointeurs pointent vers des objets qui pointent vers des autres etc , une liste chainé .
puisque j'ai pas bien saisi comment ce "swap" fonctionne, je suis encore bloqué !

[3DArchi]

Le swap se content d'échanger une valeur par une autre:

Code :

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

1
2
3
4
swap(a, b):
   tmp=b
   b=a
   a=tmp

Comme ce sont des pointeurs, tu auras juste un échange de pointeurs. Ton point critique est dans la construction par copie où il faut que toute ta chaîne de pointeur soit recopiée.
P.S.: pourquoi utilises-tu une telle chaine plutôt que des types std: std::list par exemple?

[Goten]

je me permet une petite aparté pour demandé pourquoi on passe par une méthode swap qui fait appel à std::swap plutôt que de passer directement par un std::swap? Il me semble avoir toujours vu l'idiome du copy and swap avec le std::swap ? (cf la faq)

[oswalidos]

je n'arrive pas a comprendre pourquoi si j'ignore le destructeur , le constructeur de copie , le surcharge de = , il n'ya plus d'erreur !
je crois que meme ça fonctionne sans probleme je doit les definir pour une meilleur gestion de memoire , n'est ce pas ?