Discussion :

[monsrhf]

Bonjour,
je travail sur un exercice en C++ où c'est demander de compléter une classe Point:

Code :

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

1
2
3
4
5
6
7
8
class point
{
int x, y ;
// .......
public :
point (int abs=0, int ord=0) // constructeur
// .....
} ;

de façon qu’elle dispose de deux fonctions membre permettant de connaître, à tout instant, le nombre total d’objets de type point, ainsi que le nombre d’objets dynamiques (c’est-à-dire créés par new) de ce même type.
ma proposition, qui compile sans erreur, de code est la 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
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
#include <iostream>
static int compteur_objet=0;
class point
{
int x, y ;
public :
point (int abs=0, int ord=0) // constructeur
{
    x=abs;
    y=ord;
    compteur_objet++;
}
~point()
{
    compteur_objet--;
}
// .....
static int fct()
{
    return compteur_objet;
}
} ;
using namespace std;
 
int main()
{
    point p(1,2);
    point *h;
    point* q=new point(2,4);
    int c=point::fct();
    cout<<"le nombre d'objet cree est "<<c<<endl;
    delete q;
 
    return 0;
}

je veux bien savoir, s'il vous plait, la différence entre mon code et l'intérêt de surdéfinir new et delete dans la correction proposée par le correcteur

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
#include <stddef.h> // pour size_t
#include <iostream>
using namespace std ;
class point
{ static int npt ; // nombre total de points
static int nptd ; // nombre de points dynamiques
int x, y ;
public :
point (int abs=0, int ord=0) // constructeur
{ x=abs ; y=ord ;
npt++ ;
}
~point () // destructeur
{ npt-- ;
}
void * operator new (size_t sz) // new surdéfini
{ nptd++ ;
return ::new char[sz] ; // appelle new prédéfini
}
void operator delete (void * dp)
{ nptd-- ;
::delete (dp) ; // appelle delete prédéfini
}
static int npt_tot ()
{ return npt ;
}
static int npt_dyn ()
{ return nptd ;
}
} ;
int point::npt = 0 ; // initialisation des membres statiques de point
int point::nptd = 0 ;
#include "point.h"
#include <iostream>
using namespace std ;
main()
{
point * ad1, * ad2 ;
point a(3,5) ;
cout << "A : " << point::npt_tot () << " " << point::npt_dyn () << "\n" ;
ad1 = new point (1,3) ;
point b ;
cout << "B : " << point::npt_tot () << " " << point::npt_dyn () << "\n" ;
ad2 = new point (2,0) ;
delete ad1 ;
cout << "C : " << point::npt_tot () << " " << point::npt_dyn () << "\n" ;
point c(2) ;
delete ad2 ;
cout << "D : " << point::npt_tot () << " " << point::npt_dyn () << "\n" ;
}

compilation :

A : 1 0
B : 3 1
C : 3 1
D : 3 0

merci !

[bacelar]

Les deux versions ont de grosses faiblesses au niveau thread-safe.
J'espère que c'est du code "jouet".

La version de la correction utilise 2 variables statiques de classes, c'est quand même mieux que la variable globale du premier code.
Il y a bien moins de risque de collisions de nom avec les variables statiques de classes qu'avec des variables globales, et en plus c'est plus "logique" vu que c'est des compteurs d'instance de cette classe (et pas des ours polaires sur la banquise).

Et le second code permet de distinguer les objets alloués dans le tas (via new) des objets alloués dans la pile.

[monsrhf]

merci, pourquoi surdéfinir les opérateurs new et delete dans la deuxième correction, alors le premier code répond bien à l'exercice??

[darkman19320]

Ton code ne permet pas de différencier les instances classiques de point les instances dynamiques. Tu ne connais que le nombre total d'instanciation.

[monsrhf]

Merci, j'ai bien compris

[Pyramidev]

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
class point
{
[...]
void * operator new (size_t sz) // new surdéfini
{ nptd++ ;
return ::new char[sz] ; // appelle new prédéfini
}
void operator delete (void * dp)
{ nptd-- ;
::delete (dp) ; // appelle delete prédéfini
}
[...]
} ;

Attention ! Cette "correction" est fausse !
Ce qui est alloué par new[] ne doit pas être désalloué par delete.
Sinon le comportement est indéfini. En pratique, cela se traduit soit par une corruption de la mémoire dynamique, soit par une fuite mémoire, selon l'implémentation du compilateur de new[] et delete[].

Pour ceux que ça intéresse, voici les deux implémentations les plus fréquentes de new[] et delete[] :
https://isocpp.org/wiki/faq/compiler...rray-overalloc
https://isocpp.org/wiki/faq/compiler...ray-assocarray

A part ça, voici une vraie correction :

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
class point
{
[...]
	void * operator new(size_t sz)
	{
		nptd++;
		return ::operator new(sz);
	}
	void operator delete(void * dp)
	{
		nptd--;
		::operator delete(dp);
		return;
	}
[...]
};

[monsrhf]

merci de tes lumières