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
148
149
150
|
#include "SetInteger.h" //OK, lui on en a besoin
/* mais tous ceux-là, il vaut mieux les éviter...
* Ils seront avantageusement remplacés par <iostream>
* Seul assert.h pourrait s'avérer intéressant, mais on lui préfèrerait alors <cassert>
* et encore, on se rend compte que l'on n'en a pas besoin
#include<stdio.h>
#include<malloc.h>
#include<string.h>
#include<assert.h>
*/
#include <iostream>
// constructeur par defaut de la classe
CSetInteger::CSetInteger()
: m_dTaille(0),
m_dTab(NULL), //tant qu'à faire, initialise le aussi :D
m_dCurPos(0)
{
}
/* nota: pour rendre l'utilisation du constructeur par défaut cohérente
* il serait sans doute intéressant de prévoir une méthode permettant
* de modifier la taille :D
*/
//destructeur de la classe
CSetInteger::~CSetInteger()
{
delete[] m_dTab; //utilisation de delete (ici delete[] parce que c'est un
// tableau au lieu de free
}
//constructeur d'initialisation de l'objet
CSetInteger::CSetInteger(int dTaille) //utilise les listes d'initilalisation
//pour tous les membres que tu peux ;)
m_dTaille(dTaille),
m_dCurPos(0)
{
/* m_dTaille = dTaille; n'est plus nécessaire: il est dans la liste d'initialisation :D */
m_dTab = new int[dTaille];//remplacement de malloc par new
/* Ce code est inutile: new lance une exception de type
* std::bad_alloc si l'allocation échoue...
* on pourrait éventuellement envisager de la récupérer dans la fonction
* qui déclare l'instance de notre classe, mais ici, le risque d'échec de
* l'allocation dynamique est suffisemment restreint pour que l'on
* puisse décider de ne pas le faire :D
if(m_dTab == NULL)
{
printf("Erreur allocation mémoire pour l'objet\n");
assert(0);
}
*/
}
// fonction pour verifier si l'element existe ou pas
void CSetInteger::Existe(int dNbr, int * pEx_RC)
{
/*je sais qu'on peut, mais je n'aime pas les déclarations successives
* je préfère mettre une déclaration par ligne :D
*/
bool dExiste;
bool dTrouve;
*pEx_RC = NO_EXISTE;
//dExiste = NON;
dTrouve = false;
/* cette boucle, bien que je ne l'ai pas modifiée, cette boucle
* va te poser problème: tu modifie la valeur de m_dCurPos sans
* garder la position du dernier élément inséré... (je croyais qu'il servait
* à ca, ce membre :D)... tu devrais utiliser une variable temporaire ;)
*/
while(dTrouve == false && m_dCurPos != m_dTaille)
{
if(m_dTab[m_dCurPos] == dNbr)
{
//dExiste = OUI;
dTrouve = OUI;
*pEx_RC = EXISTE_OK;
}
else
{
dTrouve = NON;
m_dCurPos++;
}
}
/* il est généralement mal vu de provoquer un retour de fonction
* alors qu'elle n'en demande pas... d'autant plus que,une fois que tu
* sors de ta boucle, la valeur de pEx_RC est correcte ;)
* ce code ne sert donc à rien... viré :D
if (*pEx_RC = EXISTE_OK);
return;
*/
}
// fonction d'ajout d'un nouvel element
void CSetInteger::IntegerAdd(int dNbr, int * pAd_RC)
{
*pAd_RC = OK_AD;
//---------------------------------------------
//Tant que l'on est dans l'ensemble
// si le nombr est + grand on passe au suivant
//sinon on l'insere à la position courantes
//---------------------------------------------
/*soit, mais que fais tu de l'élément qui se trouvait avant
* à l'emplacement choisi ???
*/
while(m_dCurPos != m_dTaille)
{
if(dNbr > m_dTab[m_dCurPos])
m_dCurPos++;
else
m_dTab[m_dCurPos] = dNbr;
/* te rend tu compte que tu quitte d'office la fonction avec
* ce return, dés que tu arrive en fin de boucle ???
* ce n'est surement pas ce que tu veux... viré :D
return;
*/
}
//-----------------------------------------
//traitement du cas ou l'ensemble est plein
//-----------------------------------------
/* ne trouve tu pas plus logique de faire le test avant d'essayer d'insérer
* un élément, et meme de n'entrer dans la boucle
* que s'il y a effectivement la place pour rajouter un élément ??? */
if(m_dCurPos > m_dTaille)
{
*pAd_RC = ENS_FULL;
return;
}
}
// fonction permettant d'avoir le cardinal de l'ensemble
int CSetInteger::CardinalEnsemble()
{
int dI;
dI = 0;
while(dI != m_dCurPos)
dI++;
return dI;
}
// fonction d'affichage de l'ensemble
void CSetInteger::Affiche()
{
for(int dI = 0; dI < m_dCurPos; dI++)
std::cout<< m_dTab[m_dCurPos]<<" "; //remplacer printf par cout ;)
} |
petit probleme à l'exécution
Répondre avec citation
en essayant d'introduire plus d'entiers que ce qu'il ne pouvait que tu ne dois pas donner la permission de voir quand même le contenu de ton objet (tu pourrais d'ailleurs même prévoir, pourquoi pas 
, la possibilité d'obtenir les informations dans la boucle d'encodage, de manière à ce que l'utilisateur puisse vérifier ce qu'il a fait 
A méditer: La solution la plus simple est toujours la moins compliquée
Envoyé par koala01
Cafuro est un outil SNMP dont le but est d'aider les administrateurs système et réseau à configurer leurs équipements SNMP réseau.
Partager