Discussion :

[lcardao]

Bonjour,

Suite a un TP en cours, je dois crée une classe ColorCell représentant un arbre binaire.

Cependant, après un certain nombre d'appelle du destructeur, une exception est levé sur le fameux :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
_CRT_SECURITYCRITICAL_ATTRIBUTE
void __CRTDECL operator delete(void* const block) noexcept
{
    #ifdef _DEBUG
    _free_dbg(block, _UNKNOWN_BLOCK);
    #else
    free(block);
    #endif
}

J'ai vue plein de solutions à ce problème mais aucune ne fonctionne pour moi. En effet, les solutions proposées (du moins celle que j'ai vue), propose de crée une classe et des fonctions de ce style :

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
 
Classe A{
   public:
     A();
     A(A const& copie);
     ~A();
 
   private:
     int *a;
}
 
A::A(){
   a = new int(5);
}
 
A::A(A const& copie){
   a = new int(5);
}
 
A::~A(){
   delete a;
}

Or ma classe est un arbre binaire (Le code arrive, merci d'avoir lu jusque là), et les seuls pointeurs présent sont des ColorCell (ColorCell *left, *right).
Je ne peut donc pas faire de new car il appèlerai un constructeur dans un constructeur et je suppose que c'est pas ce que je veux (en plus j'ai essayé a marche pas) ... Ah et je ne peux pas utilisé (et j'sais pas faire) les unique_ptr ou les shared_ptr ...

J'espère avoir été assez claire et je vous transmet mon code et ma classe en c++. Merci de votre aide et bonne journée.

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
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
 
class ColorCell
	{
		public:
			ColorCell *left;
			ColorCell *right;
 
			/***   Fonctions publiques   ***/
 
			//Constructeur
			//On laisse le choix a l'utilisateur de faire sa propre cellule, sinon utilisation des valeurs par défault
			ColorCell(unsigned int r = 125, unsigned int g = 255, unsigned int b = 123, ColorCell *le = NULL, ColorCell *ri = NULL);
 
			//Destructeur
			~ColorCell();
 
			//Opérateur de transtypage de ColorCell à string, utile dans GenTree.h
			operator string(void) const;
 
		private:
			/***   Variables privées   ***/
			unsigned int R, G, B; //R pour red, G pour green, B pour blue
 
 
			/***   Fonctions Privées   ***/
			//void destroy(ColorCell*& cell); //Fonction récursive pour la destruction de left et right, utile au destructeur
 
			/***   Opérateurs amis   ***/
			friend istream& operator >> (istream& in, ColorCell& cell);
			friend ColorCell operator + (ColorCell const& a, ColorCell const& b);
	};
 
//Constructeur
ColorCell::ColorCell(unsigned int r, unsigned int g, unsigned int b, ColorCell *le, ColorCell *ri)
{
	/***   Validation des paramètres   ***/
 
	//Paramètres par default : r = 0, g = 0, b = 0
	if (r > 255 || g > 255 || b > 255) {
		throw new exception("ERREUR : les nombres r, g, b doivent etre compris entre 0 et 255");
	}
 
	/***   Construction de la classe   ***/
	R = r;
	G = g;
	B = b;
	left = le;
	right = ri;
}
 
//Destructeur
ColorCell::~ColorCell()
{
	delete left;
	delete right;
}
 
//Opérateur de transtypage
ColorCell::operator string() const {
 
	/***   Création des varibales   ***/
	string res;
 
	/***   Opérations de convertion de la classe en string   ***/
	res += to_string(R);
	res += " ";
	res += to_string(G);
	res += " ";
	res += to_string(B);
 
	/***   Retour   ***/
	return res;
}
 
/*void ColorCell::destroy(ColorCell*& cell) {
 
	/***   Parcours suffix pour destruction des pointeurs   ***/
	/*if (cell != NULL) {
		destroy(cell->left);
		destroy(cell->right);
		delete cell;
	}
}*/
 
/***  Opérateurs amis   ***/
 
istream& operator >> (istream& in, ColorCell& cell)
{
	/***   Création des varibales   ***/
	string tmp, tmp1;
	size_t i, cmpt, cmptmp;
 
	/***   Initialisation des varibales   ***/
	tmp = "";
	cmpt = cmptmp = 0;
	in >> tmp1;
 
	/***   Début de la convertion   ***/
	for (i = 0; i < tmp1.length(); ++i) {
		if (tmp1[i] != ' ' && cmptmp < 3) { //Récupération des valeurs
			tmp += tmp1[i];
			++cmptmp;
		}
		else if (cmptmp == 3 && tmp1[i] != ' ') { //L'utilisateur à mal entrée ses données
			throw new exception("ERREUR : Entree sous forme \"255 255 255\"");
		}
		else { //Mise en place dans la classe
			switch (cmpt) {
				case 0:
					cell.R = stoi(tmp);
					break;
				case 1:
					cell.G = stoi(tmp);
					break;
				default:
					cell.B = stoi(tmp);
					break;
			}
			++cmpt;
			cmptmp = 0;
			tmp = "";
		}
	}
 
	cell.right = NULL;
	cell.left = NULL;
 
	/***   Retour   ***/
	return in;
}
 
ColorCell operator + (ColorCell const& a, ColorCell const& b) {
 
	/***   Creation des varibales   ***/
	ColorCell res;
 
	/***   Création de la classe après addition   ***/
	res.R = (a.R + b.R) / 2;
	res.G = (a.G + b.G) / 2;
	res.B = (a.B + b.B) / 2;
 
	res.left = (ColorCell *)&a;
	res.right = (ColorCell *)&b;
 
	/***   Retour   ***/
	return res;
}

[Bousk]

Pourquoi ne pas interdire copie/assignation/mouvement ?

[lcardao]

Je ne sais pas faire ... et je pense avoir besoin de la copie (j'avoue je ne suis pas sur du tout mais bon). Pouvez vous m'en dire plus a ce sujet ?

[koala01]

Salut,

C'est tout simple pour interdire les fonctions qui n'ont plus lieu d'être en C++11 et ultérieur : il suffit de les déclarer delete comme on déclare quelques fonctions constantes au sein d'une classe:

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 A{
public:
    /* la copie est interdite */
    A (A const &) = delete;
    /* l'assignatino est interdite */
    A & operator = (A const &) = delete;
    /* la copie par déplacement est interdite */
    A (A && ) = delete;
     /* l'assignation par déplacement est interdite */
     A & operator == (A &&) = delete;
     /* Quand tout cela est interdit, le destructeur de la classe 
      * est soit public et virtuel, soit protégé et non virtuel
      */
    virtual ~A();
     /* ... le reste de la classe  */
};

[Grool]

Bonjour

Ça me semble douteux de gérer la destruction des ColorCell voisines dans le destructeur de ColorCell. Ça fait un peu bombe à fragmentation.

Encore plus si tu souhaites que l'objet reste copiable.
Par exemple, dans ta redéfinition de l'opérateur + :
- tu crées un objet temporaire,
- tu le copies en sortie de la fonction,
- tu détruis l'objet temporaire
- tu libères les pointeurs
- tu te retrouves avec un objet qui possède deux pointeurs invalides => Crack boum.