Discussion :

[onap]

Bonjour,
J'ai une question pour laquelle je cherche une explication exacte:

Situation du problème (cas d'école):
J'ai deux classes, l'une "point "avec 2 données membres et un constructeur avec 2 paramètres, et l'autre "MapPoint" ayant un container MAP (Key=int et value=un objet point) et donc une fonction membre pour inserer un nouveau point à la cle Index.
J'ai donc comme argument de ma fonction InsertPoint un entier et un point.
Le probleme est le suivant:
si je ne définit pas un constructeur sans argument (ou argument par défaut) j'ai une erreur de compilation du sytle:

[C++ Error] _map.h(162): E2285 Could not find a match for 'point::point()'
[C++ Error] _map.h(162): E2285 Could not find a match for 'pair<const int,point>::pair(const int,undefined)'
[C++ Error] _map.h(162): E2285 Could not find a match for 'map<int,point,less<int>,allocator<pair<const int,point> > >::insert(_Rb_tree_iterator<pair<const int,point>,_Nonconst_traits<pair<const int,point> > >,undefined)'

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
 
class point{
        int x,y;
        public:
       // point(){};
        point(int,int);
        point(const point &);
        friend bool operator < (const point &,const point &);
};
class MapPoint{
        std::map<int,point> MapPt;
        public:
        void InsertPoint(int,point);
        point operator[](int);
};
 
//----------------------------------------------------
point::point(int abs,int ord){x=abs;y=ord;}
point::point(const point & pt)
{
x=pt.x;
y=pt.y;
}
bool operator < (const point & pt1,const point & pt2)
{
 return(pt1.x<pt2.x);
}
 
void MapPoint::InsertPoint(int Index,point Pt)
{
MapPt.insert(make_pair(Index, Pt));
}
point MapPoint::operator[](int Index)
{
return MapPt[Index];
}

Je suppose donc que lors d'une insertion d'un objet dans un container MAP, il se produit d'abord uns instanciation de la class point par l'appel au constructeur point::point() et puis recopie des valeurs grâce à l'opérateur = par défaut?? Est-ce juste?

Merci

[tut]

déclare ton constructeur avec des arguments par défaut :

Code :

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

1
2
 
point( int a=0, int b=0);

[Laurent Gomila]

Je pense que si tu n'utilises pas map::operator[], tu n'auras pas besoin de constructeur par défaut dans ton cas. En effet cet opérateur insère un objet par défaut si la clé n'existe pas, d'où sa nécessité. Tu peux remplacer ta fonction par celle-ci :

Code :

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

1
2
3
4
5
6
7
8
9
point MapPoint::operator[](int Index)
{
    std::map<int,point>::iterator It = MapPt.find(Index);
 
    if (It != MapPt.end())
        return It->second;
    else
        throw std::runtime_error("Clé inconnue");
}

[onap]

C'est bien vrai ca, j'avais oublié cette création de la pair <clé,objet> en cas de non-existance de la clé,ce qui.... évidement ne m'arrange pas .
Mais je me demandais pourquoi la nécessité de la présence de constructeur sans et/ou avec arguments par défaut: j'ai rajouté quelquez cout << "je passe par ici... dans les différentz constructeurz (sans arguments, avec argument par défaut et de recopie) et dans le destructeur, et je remarque que le code ne fais appel qu'au constructeur de recopie lors du passage par valeur de mon objet dans la fonction InsertPoint et lors de l'insertion dans le conteneur MapPt: Voici le petit bout de code:

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
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
 
using namespace std;
class point{
        int x,y;
        public:
        point(){cout<< "Appel du constructeur() (" << this <<")"<<endl;};
        point(int,int);
        point(const point &);
        ~point();
        friend bool operator < (const point &,const point &);
        point & operator = (const point &);
};
class MapPoint{
        std::map<int,point> MapPt;
        public:
        void InsertPoint(int,point);
        point ReturnPoint(int);
        point operator[](int);
};
 
//----------------------------------------------------
point::point(int abs,int ord){
   x=abs;
   y=ord;
   cout << "appel du constructeur point(int,int)(" << this << ")" << endl;
}
point::point(const point & pt)
{
x=pt.x;
y=pt.y;
cout << "Appel du constructeur de recopie de point("<< this << ") " << endl;
}
point::~point()
{
 cout<< "Appel du destructeur ("<<this<<")"<<endl;
}
bool operator < (const point & pt1,const point & pt2)
{
 return(pt1.x<pt2.x);
}
point &point::operator = (const point & pt)
{
 cout << "appel de l'operateur = pour point " << endl;
 this->x=pt.x;this->y=pt.y;
 return *this;
}
void MapPoint::InsertPoint(int Index,point Pt)
{
MapPt.insert(make_pair(Index, Pt));
}
point MapPoint::ReturnPoint(int Index)
{
return MapPt[Index];
}
point MapPoint::operator[](int Index)
{
return MapPt[Index];
}
 
//----------------------------------------------------
int main(int argc, char* argv[])
{
cout << "---Creation de point pt1 et pt2" << endl;
point *pt1 = new point(1,1);
point *pt2 = new point(2,2);
MapPoint PointMapping;
cout << "---Insertion pt1" << endl;
PointMapping.InsertPoint(1,*pt1);
cout << "---Insertion pt2 " << endl;
PointMapping.InsertPoint(2,*pt2);
cout << "---Recup pt de cle=2"<<endl;
point pt3=PointMapping.ReturnPoint(2);
cout << "---Recup pt de cle=1"<<endl;
point pt4=PointMapping.ReturnPoint(1);
cout <<"---Destruction des objet et fin programme" << endl;
delete pt1;
delete pt2;
        return 0;
 
}

et le résultat dans le terminal:

---Creation de point pt1 et pt2
appel du constructeur point(int,int)(9396908)
appel du constructeur point(int,int)(9396924)
---Insertion pt1
Appel du constructeur de recopie de point(1244944)
Appel du constructeur de recopie de point(1244920)
Appel du constructeur de recopie de point(1244908)
Appel du constructeur de recopie de point(9393636)
Appel du destructeur (1244908)
Appel du destructeur (1244920)
Appel du destructeur (1244944)
---Insertion pt2
Appel du constructeur de recopie de point(1244944)
Appel du constructeur de recopie de point(1244920)
Appel du constructeur de recopie de point(1244908)
Appel du constructeur de recopie de point(9393668)
Appel du destructeur (1244908)
Appel du destructeur (1244920)
Appel du destructeur (1244944)
---Recup pt de cle=2
Appel du constructeur de recopie de point(1245028)
---Recup pt de cle=1
Appel du constructeur de recopie de point(1245020)
---Destruction des objet et fin programme
Appel du destructeur (9396908)
Appel du destructeur (9396924)
Appel du destructeur (1245020)
Appel du destructeur (1245028)
Appel du destructeur (9393668)
Appel du destructeur (9393636)

[Laurent Gomila]

Le constructeur par défaut ne sera utilisé que si operator[] ne trouve pas la clé, ce qui n'est pas le cas dans ton exemple. Mais il le faut tout de même pour compiler la fonction, le compilo ne peux pas savoir s'il va être utilisé ou non.

Essaie un PointMapping.ReturnPoint(50);

[onap]

ben oui c'est évident, la sol était devant mes yeux (mais je ne sais pas ou était mes yeux à ce moment...... )
En tous cas un grand merci pour le coup de main.
Oli