Le pire bout de code que vous ayez vu

[publicStaticVoidMain]

Envoyé par fridobox

En java,

Je vois couramment des cast en classe fille pour appeler une méthode de la classe mère :

Code :

à l'appel :

Code :

Polymor-quoi???

JE vais peut etre dire une bourde mais je ne vois pas en quoi c'est un probleme?

[publicStaticVoidMain]

Envoyé par publicStaticVoidMain

JE vais peut etre dire une bourde mais je ne vois pas en quoi c'est un probleme?

Ah merde je vois pourquoi . J'avais pas bien lu le code

[deadalnix]

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
        perm[0] = 0;
        for (var l = 0; l <= 6; l++) {
            var n = 0;
            for (var p = 0; p < 5040; p++) {
                if (perm[p] == l) {
                    for (var m = 0; m < 3; m++) {
                        var q = p;
                        for (var c = 0; c < 3; c++) {
                            var q = permmv[q][m];
                            if (perm[q] == -1) {
                                perm[q] = l + 1;
                                n++;
                            }
                        }
                    }
                }
            }
        }

Du bon javascript comme on les aimes ! Miam !

[Alain Defrance]

Envoyé par deadalnix

Code :

Du bon javascript comme on les aimes ! Miam !

Huuuum de la bonne compléxité cyclomatique comme on les aiment.
Ca va être hyper cool à tester, ah oui c'est vrai ca se test pas le JS, ouf :p

[GanYoshi]

Envoyé par Alain Defrance

Huuuum de la bonne compléxité cyclomatique comme on les aiment.
Ca va être hyper cool à tester, ah oui c'est vrai ca se test pas le JS, ouf :p

[fridobox]

Envoyé par publicStaticVoidMain

Ah merde je vois pourquoi . J'avais pas bien lu le code

Ouf, j'ai zu peur.

[DaesD]

Pour ceux qui auront le courage, ca vaut le coup

En gros c'est une classe qui permet de calculer l'ecart en seconde entre deux date

Plutot que d'utiliser une simple différence entre deux time() on finit avec une classe qui vérifie qu'on est pas en année bissextile

Code c++ :

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
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
 
class CMemoTime //:// public CWnd
{
// Construction
public:
	CMemoTime()
   {} ;
 
// Attributes
protected :
   string m_pathMemoTime ;
 
 
// Implementation
public:
	~CMemoTime()
   {};
 
   void InitMemoTime(/// chemin du fichier de mémorisation
                     string _path)
   {  m_pathMemoTime = _path ; } ;
 
   void MemoTimeCreateRef() ;
 
   void GetCurDateTime(int & _year, int & _month, int & _day, int & _hour, int & _minutes, int & _seconds);
 
   bool GetMemoTime(int & _year, int & _month, int & _day, int & _hour, int & _minutes, int & _seconds);
 
   bool TestIfInTime(int _hoursMax, int _minutesMax, int _secondsMax) ;
 
   void CalcTimeInSec(int _hours, int _mn, int _s, int & _timeRes) ;
 
   void CalcEcart_TimeInSec(int _hoursA, int _mnA, int _sA,
                         int _hoursB, int _mnB, int _sB,int & _timeRes) ;
 
   void CalcEcart_DayTimeInSec(int _dayA, int _hoursA, int _mnA, int _sA,
                               int _dayB, int _hoursB, int _mnB, int _sB,
                               int & _timeRes) ;
 
   bool isYearBis(int _year);
 
   void CalcNbDayInMonth(int _year, int _month, int & _day);
 
   void CalcEcart_MonthDayTimeInSec(int _yearA, int _monthA, int _dayA, int _hoursA, int _mnA, int _sA,
                                    int _monthB, int _dayB, int _hoursB, int _mnB, int _sB,
                               int & _timeRes);
 
   void CalcEcart_YearMonthDayTimeInSec(int _yearA, int _monthA, int _dayA, int _hoursA, int _mnA, int _sA,
                                        int _yearB, int _monthB, int _dayB, int _hoursB, int _mnB, int _sB,
                                        int & _timeRes) ;
};
 
inline
void CMemoTime::MemoTimeCreateRef() 
{
   if (m_pathMemoTime.empty() != 0)
      return ;
 
   //--------------------------
   // mémorisation de l'heure
   ofstream fHorloge ;
   fHorloge.open(m_pathMemoTime.c_str()) ;
   if (fHorloge.is_open() != 0)
   {
      setlocale( LC_ALL, "" );
      CTime theTime = CTime::GetCurrentTime();
 
      fHorloge << theTime.GetDay() << " / " << theTime.GetMonth() << " / " << theTime.GetYear() << " - " << theTime.GetHour() << " : " << theTime.GetMinute() << " : " << theTime.GetSecond() << endl ;         
      fHorloge.close() ;
   }
}
 
inline 
void CMemoTime::GetCurDateTime(int & _year, int & _month, int & _day, int & _hour, int & _minutes, int & _seconds)
{
 
   setlocale( LC_ALL, "" );
   CTime theTime = CTime::GetCurrentTime();
   _year = theTime.GetYear() ;
   _month = theTime.GetMonth() ;
   _day = theTime.GetDay() ;
   _hour = theTime.GetHour() ;
   _minutes = theTime.GetMinute() ;
   _seconds = theTime.GetSecond() ;
}
 
inline
bool CMemoTime::GetMemoTime(int & _year, int & _month, int & _day, int & _hour, int & _minutes, int & _seconds)
{
   ifstream fHorloge ;
   fHorloge.open(m_pathMemoTime.c_str()) ;
   if (fHorloge.is_open() == 0)
      return false;
   while (!fHorloge.eof())
   {
      string line ;
      std::getline(fHorloge, line) ;
      if (line.empty() != true)
      {
         string tmp ;
         stringstream strLine ;
         strLine << line ;
         strLine >>_day >> tmp >> _month >> tmp >> _year >> tmp >> _hour >> tmp >> _minutes >> tmp >> _seconds ;
         break ;
      }
   }
   fHorloge.close() ;
   return true ;
}
 
inline
bool CMemoTime::TestIfInTime(int _hoursMax, int _minutesMax, int _secondsMax)
{
   int yearCur, monthCur, dayCur, hourCur, minutesCur, secondsCur ;
   int year, month, day, hour, minutes, seconds ;
 
   if (GetMemoTime(year, month, day, hour, minutes, seconds) != true)
      return false ;
 
   GetCurDateTime(yearCur, monthCur, dayCur,hourCur,minutesCur,secondsCur) ;
   int dt = 0 ;
   CalcEcart_YearMonthDayTimeInSec( year, month, day, hour, minutes, seconds,
                                    yearCur, monthCur, dayCur, hourCur, minutesCur, secondsCur, dt) ;
   int dtMax = 0 ;
   CalcTimeInSec(_hoursMax, _minutesMax, _secondsMax, dtMax) ;
   if (dt < dtMax)
      return true ;
 
   return false ;
}
 
inline
void CMemoTime::CalcTimeInSec(int _hours, int _mn, int _s, int & _timeRes)
{
   _timeRes = _hours *3600 + _mn * 60 + _s ;
} 
 
inline
void CMemoTime::CalcEcart_TimeInSec(int _hoursA, int _mnA, int _sA,
                         int _hoursB, int _mnB, int _sB,int & _timeRes)
{
   int tA, tB ;
   tA = tB = 0 ;
   CalcTimeInSec(_hoursA, _mnA, _sA, tA) ;
   CalcTimeInSec(_hoursB, _mnB, _sB, tB) ;
 
   _timeRes = abs(tB - tA) ;
}
 
inline
void CMemoTime::CalcEcart_DayTimeInSec(int _dayA, int _hoursA, int _mnA, int _sA,
                            int _dayB, int _hoursB, int _mnB, int _sB,
                            int & _timeRes)
{
   if (_dayA == _dayB)
   {
      CalcEcart_TimeInSec(_hoursA, _mnA, _sA,
                          _hoursB, _mnB, _sB, _timeRes) ;
      return ;
   }
   int dtA, dtB ;
   dtA = dtB = 0 ;
   CalcEcart_TimeInSec(_hoursA, _mnA, _sA,
                       24, 0, 0, dtA) ;
   CalcTimeInSec(_hoursB, _mnB, _sB, dtB) ;
 
   int dJ = 0 ;
   dJ = abs((_dayB - _dayA) - 1 );
   dJ *= 24 ;
   dJ *= 3600 ;
 
   _timeRes = dJ + dtA + dtB ;
}
 
inline
bool CMemoTime::isYearBis(int _year)
{
   int yearCur = 2000 ;
   while (yearCur < _year)
   {
      yearCur += 4 ;
   }
   if (yearCur == _year)
      return true ;
   return false ;
}
 
inline
void CMemoTime::CalcNbDayInMonth(int _year, int _month, int & _day)
{
   switch( _month)
   {
   case 2 :
      {
         if (!isYearBis(_year))
            _day = 28 ;
         else _day = 29 ;
         break ;
      }
   case 1 :
   case 3 :
   case 5 :
   case 7 :
   case 8 :
   case 10 :
   case 12 :
      {
         _day = 31 ;
         break ;
      }
   case 4 :
   case 6 :
   case 9 :
   case 11 :
      {
         _day = 30 ;
         break ;
      }
   default :
      {
         _day = 0 ;
         break ;
      }
   }
}
 
inline
void CMemoTime::CalcEcart_MonthDayTimeInSec(int _yearA, int _monthA, int _dayA, int _hoursA, int _mnA, int _sA,
                                 int _monthB, int _dayB, int _hoursB, int _mnB, int _sB,
                            int & _timeRes)
{
   if (_monthA == _monthB)
   {
      CalcEcart_DayTimeInSec(_dayA, _hoursA, _mnA, _sA,
                            _dayB, _hoursB, _mnB, _sB, _timeRes) ;
      return ;
   }
 
   int nbDayMonthA ;
   CalcNbDayInMonth(_yearA, _monthA, nbDayMonthA) ;
   int dtA, dtB ;
   dtA = dtB = 0 ;
   CalcEcart_DayTimeInSec(_dayA,_hoursA,_mnA,_sA,nbDayMonthA,24,0,0,dtA) ;
   CalcEcart_DayTimeInSec(1,0,0,0,_dayB,_hoursB, _mnB,_sB,dtB) ;
 
   int dJ = 0 ;
   dJ = abs(_monthB - _monthA) - 1 ;
   if (dJ >0)
   {
      dJ = 0 ;
      for (int count = (_monthA +1) ; count < (_monthB) ; count ++)
      {
         int nbJ = 0 ;
         CalcNbDayInMonth(_yearA,count,nbJ) ;
         dJ += nbJ ;
      }
   }
   else dJ = 0 ;
   dJ *= 24 ;
   dJ *= 3600 ;
   _timeRes = dJ + dtA + dtB ;
 
}
 
inline
void CMemoTime::CalcEcart_YearMonthDayTimeInSec(int _yearA, int _monthA, int _dayA, int _hoursA, int _mnA, int _sA,
                                     int _yearB, int _monthB, int _dayB, int _hoursB, int _mnB, int _sB,
                                     int & _timeRes)
{
   if (_yearA == _yearB)
   {
      CalcEcart_MonthDayTimeInSec(  _yearA, _monthA, _dayA, _hoursA, _mnA, _sA,
                                            _monthB, _dayB, _hoursB, _mnB, _sB,
                                            _timeRes) ;
      return ;
   }
   int dtA, dtB ;
   dtA = dtB = 0 ;
   CalcEcart_MonthDayTimeInSec(_yearA, _monthA, _dayA, _hoursA, _mnA, _sA,
                                       12, 31, 24,0,0, dtA) ;
   CalcEcart_MonthDayTimeInSec(_yearB, 1, 1, 0, 0,0,
                                       _monthB, _dayB, _hoursB, _mnB, _sB, dtB) ;
   int dY = 0 ;
   dY = abs(_yearA - _yearB) -1 ;
   if (dY >0)
   {
      dY = 0 ;
      for (int count = (_yearA +1) ; count < _yearB ; count ++)
      {
         int nbj ;
         if (!isYearBis(count))
            nbj = 365 ;
         else nbj = 366 ;
         dY += nbj ;
      }
   }
   dY *= 24 ;
   dY *= 3600 ;
 
   _timeRes = dtA + dtB + dY ;
}

[jabbounet]

je ne code pas en java et n'en fait pas, mais il m'arrive d'en lire de temps en temps et parfois certaines choses arrivent à me choquer

Exemple:

Code java :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
 
class A extends B { 
 
   private B monB = null;
 
 
   public A() {
      monB = new B();
 
   }
 
  public truc getTruc() {
    return this.monB.getTruc();
  }
 
  public void setTruc(unTruc x) {
    this.monB.setTruc(x);
 }
 
 ....
}

je ne compte pas toutes les méthodes qui utilisent monB plutôt que le mécanisme d'héritage
soit je n'ai rien compris à l'héritage en Java, soit j'ai peur....

[adiGuba]

Envoyé par jabbounet

je ne compte pas toutes les méthodes qui utilisent monB plutôt que le mécanisme d'héritage
soit je n'ai rien compris à l'héritage en Java, soit j'ai peur....

Ce n'est pas de l'héritage, mais de la composition, et cela a des avantages non-négligeables sur l'héritage !


Lorsqu'on utilise l'héritage, on est limité à une classe parente et à son implémentation.

La composition permet de rajouter une "fonctionnalité" sur un large type de classe, quelque soit leurs implémentations. Pour cela on utilise le type comme attribut en déléguant toutes les méthodes, puis en rajoutant notre fonctionnalité par dessus.

On retrouve souvent cela dans l'API standard, en particulier pour la gestion des flux (InputStream/Reader).


a++

tu as manque un truc adi je crois

Code :

class A extends B {

[adiGuba]

Non justement, c'est de l'héritage par composition.

L'intérêt étant de pouvoir utiliser A comme un type B de manière totalement transparent :

Code :

1
2
3
B b1 = new A( new B() );
B b2 = new A( new UneAutreClasseQuiEtendB() );
B b3 = new A ( uneMethodeQuiRetourneB() );

On ajoute les fonctionnalités de "A" à trois classe de type "B" quelconques, sans que l'on ai à connaitre leurs types précis.

Les deux dernières lignes sont impossible avec de l'héritage standard.


Comme je l'ai dit on trouve cela dans l'API standard :

Code :

1
2
3
4
5
6
	// Un flux compressé vers un fichier :
	OutputStream out = new GZIPOutputStream(new FileOutputStream("out"));
	// Un flux bufférisé vers un fichier :
	OutputStream out = new BufferedOutputStream(new FileOutputStream("out"));
	// Un flux compressé ET bufférisé vers un fichier :
	OutputStream out = new GZIPOutputStream(new BufferedOutputStream(new FileOutputStream("out")));

GZipOutputStream et BufferedOutputStream hérite tout deux d'OutputStream , indirectement via FilterOutputStream qui effectue l'héritage par composition...

Avec de l'héritage standard, il aurait fallu multiplier les classes pour avoir le même résultat : GZIPFileOutputStream, BufferedFileOutputStream, GZIPBufferedFileOutputStream, etc.

Ici il suffit d'empiler les instances pour rajouter des fonctionnalités, quelque soit la classe d'origine :

Code :

1
2
// Même chose avec une socket :
OutputStream out = new GZIPOutputStream(new BufferedOutputStream(socket.getOutputStream()));

Ce genre de chose est très présent dans l'API, même si c'est souvent "caché" dans une méthode :

Code :

List<String> list = Collections.synchronizedList(new ArrayList<String>());

Code :

1
2
3
4
5
    public static <T> List<T> synchronizedList(List<T> list) {
        return (list instanceof RandomAccess ?
                new SynchronizedRandomAccessList<T>(list) :
                new SynchronizedList<T>(list));
    }

a++

[GanYoshi]

En clair "héritage par composition" c'est c'est le pattern Strategy ?

En regardant le code initiale je pensais qu'il s'agissait du pattern Strategy, alors que tu semble dire d'après les exemples avec les streams qu'il s'agit d'un decorator.
Bref c'est encore un peu flou ^-^'
En tout cas merci pour ton explication !

[adiGuba]

Envoyé par Herve-Loiret

En clair "héritage par composition" c'est c'est le pattern Strategy ?

En regardant le code initiale je pensais qu'il s'agissait du pattern Strategy, alors que tu semble dire d'après les exemples avec les streams qu'il s'agit d'un decorator.

Oui c'est en effet le pattern Decorator. Je me mélange souvent dans les noms des patterns

a++

[pseudocode]

Envoyé par adiGuba

Non justement, c'est de l'héritage par composition.

Sauf que, en l'occurrence, l'unique constructeur de A crée une instance de la classe B, et pas d'une classe fille. Donc c'est pas super utile.

[adiGuba]

Envoyé par pseudocode

Sauf que, en l'occurrence, l'unique constructeur de A crée une instance de la classe B, et pas d'une classe fille. Donc c'est pas super utile.

Oui je n'avais pas fait attention à ce détail en me basant uniquement sur les appels de méthodes délégués...

a++

[jabbounet]

Envoyé par adiGuba

Ce n'est pas de l'héritage, mais de la composition, et cela a des avantages non-négligeables sur l'héritage !


Lorsqu'on utilise l'héritage, on est limité à une classe parente et à son implémentation.

La composition permet de rajouter une "fonctionnalité" sur un large type de classe, quelque soit leurs implémentations. Pour cela on utilise le type comme attribut en déléguant toutes les méthodes, puis en rajoutant notre fonctionnalité par dessus.

On retrouve souvent cela dans l'API standard, en particulier pour la gestion des flux (InputStream/Reader).


a++

Dans le code en question (réel que j'avais sous les yeux) il héritait et faisait son agrégation en même temps sans pour autant sembler tirer partie de l'un ou de l'autre, ça se voyait au code implémenté qu'il ne maitrisait pas vraiment ces concepts.

[jabbounet]

Envoyé par adiGuba

Oui je n'avais pas fait attention à ce détail en me basant uniquement sur les appels de méthodes délégués...

a++

effectivement c'était ici le problème, entre autre

[Gouyon]

Salut,

Ca ne tombe pas forcément dans cette rubrique cependant je me suis arraché les cheveux pendant pas mal de temps avec cette histoire. Donc j'utilise Visual studio 2005 et j'ai eu un problème avec la fonction sscanf. J'ai un code qui lit dans un fichier texte des heures au format HH:MM:SS et qui les traite ensuite. J'ai constaté que dans certains cas le résultat de mon traitement était faux. Après pas mal deJ'ai fait des tests et j'ai trouvé ceci

Code :

1
2
3
4
5
CString Str;
int H,M,S;
Str="05:02:24";
sscanf(Str,"%2i:%2i:%2i",&H,&M,&S);

Donne un résultat correcte à savoir H=5; M=2 et S=4
Par contre

Code :

1
2
3
4
5
CString Str;
int H,M,S;
Str="05:08:24";
sscanf(Str,"%2i:%2i:%2i",&H,&M,&S);

Donne un résultat faux à savoir H=5; M=0 et S=-858993460

Il semble que les chaine "08" et "09" pose problème.

Etonnant non

[Barsy]

C'est parce que la fonction sscanf (que je ne connais pas) doit faire la conversion en octal et non en décimal.

J'avais eu le même problème en JavaScript. Lorsque je faisais un parseInt(monString), ça marchait toujours sauf pour 8 et 9. En fait, il fallait préciser parseInt(monString, 10) pour que ça marche.

[adiGuba]

Envoyé par Barsy

C'est parce que la fonction sscanf (que je ne connais pas) doit faire la conversion en octal et non en décimal.

+1

Source : http://man.developpez.com/man3/scanf.3.php

i correspond à un entier éventuellement signé. Le pointeur suivant doit être du type int *. L'entier est en base 16 (héxadécimal) s'il commence par `0x' ou `0X', en base 8 (octal) s'il commence par un `0', et en base 10 sinon. Seuls les caractères correspondants à la base concernée sont utilisés.

En clair 08 est considéré comme de l'octal

%02d serait plus approprié

a++