Форум программистов, компьютерный форум CyberForum.ru

Код. - C++

Восстановить пароль Регистрация
 
Maksim_27_10
1 / 1 / 0
Регистрация: 05.11.2009
Сообщений: 23
22.04.2011, 18:21     Код. #1
Ich gruesse euch!
Куда можно скинуть код? Целью является то, чтобы другие программисты им попользовались и выявили, по-возможности, ошибки, предложили улучшения.
Similar
Эксперт
41792 / 34177 / 6122
Регистрация: 12.04.2006
Сообщений: 57,940
22.04.2011, 18:21     Код.
Посмотрите здесь:

C++ В чем разница между exit(код возврата) и ExitProcess (код возврата)?
Нужно засунуть код инструкции в 4 char'a так, чтобы в памяти это был код инструкции. C++

Искать еще темы с ответами

Или воспользуйтесь поиском по форуму:
После регистрации реклама в сообщениях будет скрыта и будут доступны все возможности форума.
Chelioss
179 / 179 / 4
Регистрация: 08.01.2011
Сообщений: 1,131
22.04.2011, 19:48     Код. #2
Например, сюда http://pastie.org/
Maksim_27_10
1 / 1 / 0
Регистрация: 05.11.2009
Сообщений: 23
22.04.2011, 21:12  [ТС]     Код. #3
Я скинул. В поле скопировал адрес. А как мне узнать мнение о моём коде? Что нажать для этого?
AlexP11223
36 / 37 / 4
Регистрация: 20.04.2011
Сообщений: 288
22.04.2011, 21:34     Код. #4
Так вы хотели сервис, с помощью которого можно удобно\легко показать кому-то свой код, или именно мнение о коде? Если второе, то чем не устраивает например этот форум?)
А ориентированные именно на обсуждение кода новичков врядли существуют, разве что github.com , но наверно немного не то.
Maksim_27_10
1 / 1 / 0
Регистрация: 05.11.2009
Сообщений: 23
23.04.2011, 08:26  [ТС]     Код. #5
Я хотел обсудить код, следовательно второе. В программировании я не новичок, но любитель, а написал в раздел для новичков, так как счёл нужным, наиболее подходящим, соответствующим теме именно этот раздел.

Тогда скину сюда. У меня просьба: погоняйте и повылавливайте ошибки(я не нашёл ни одной) и скажите своё мнение. Здесь преобразованная мной немного концепция дескриптора C++.
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
// Beispiel.cpp
// Подключить шаблонный класс CT_Handle.
 
class C_Test
{ 
  public :
  C_Test( )                                    
  { 
    std::cout << "Create." << std::endl;
  }
 
  C_Test( const C_Test &a )                    
  { 
    std::cout << "Copy." << std::endl;
  }
 
  const C_Test& operator = ( const C_Test &b ) 
  {
    std::cout << "Appropriate." << std::endl;
  }
 
  virtual ~C_Test( )                           
  { 
    std::cout << "Destroy." << std::endl;
  }
 
  void Member_Of_C_Test_( ) { }
};
 
void Fn_1( CT_Handle< C_Test > handle )
{
  *handle;
  handle->Member_Of_C_Test_( );
}
 
void Beispiel( )
{
  CT_Handle< C_Test > handle_1( false ); // true. Разницы нет.
  CT_Handle< C_Test > handle_2;
 
  handle_2 = handle_1;
  Fn_1( handle_2 );
}
 
// CT_Handle.h
#ifndef __CT_HANDLE_22_04_2011_7eGI7I0M8u8D_mfgYBME10gGy82__
  #define __CT_HANDLE_22_04_2011_7eGI7I0M8u8D_mfgYBME10gGy82__
 
#include <iostream>
 
template< typename Type >
class CT_Pointer
{
  public :
    CT_Pointer( );
    //CT_Leader_Pointer( const CT_Leader_Pointer &a );
    //const CT_Leader_Pointer& operator = ( const CT_Leader_Pointer &b );
    ~CT_Pointer( );
 
  public :
    Type * Get_Pointer_( );
    void Addition_Reference_( );
    bool Release_Reference_( );
    unsigned int Get_Count_( );
 
  private :
    unsigned int count_;
    Type         *pointer_;
};
 
template < typename Type >
inline CT_Pointer< Type >::CT_Pointer( )
{
  this->pointer_ = new Type( );
  this->count_   = 1;
 
  std::cout << "CT_Pointer Create." << std::endl;
}
 
template < typename Type >
inline CT_Pointer< Type >::~CT_Pointer( )
{
  delete this->pointer_;
 
  std::cout << "CT_Pointer Destroy." << std::endl;
}
//=============================================================================
 
template < typename Type >
inline Type * CT_Pointer< Type >::Get_Pointer_( )
{
  return( this->pointer_ );
}
 
template < typename Type >
inline void CT_Pointer< Type >::Addition_Reference_( )
{
  ++this->count_;
}
 
template < typename Type >
inline bool CT_Pointer< Type >::Release_Reference_( )
{
  bool result = false;
 
  --this->count_;
 
  if( this->count_ == 0 )
  {
    delete this->pointer_;
    this->pointer_ = NULL;
    result         = true;
  }
 
  return( result );
}
 
template < typename Type >
inline unsigned int CT_Pointer< Type >::Get_Count_( )
{
  return( this->count_ );
}
/******************************************************************************
  *                                                                         *  
  *                                                                         *
  *                                                                         *
  *                                                                         *
  *                                                                         *
******************************************************************************/
template < typename Type >
class CT_Handle
{
  public :
    CT_Handle( );                                                              // Указатель вникуда.
    CT_Handle( bool b );                                                       // Создаёт объект.
    CT_Handle( const CT_Handle &a );                                           // Увеличивает количество ссылок.
    const CT_Handle& operator = ( const CT_Handle &b );                        // По ситуации.
    ~CT_Handle( );
 
  public :
    operator Type    * ( ) { return( this->pointer_->Get_Pointer_( ) ); }
    Type * operator -> ( ) { return( this->pointer_->Get_Pointer_( ) ); }
 
  public :
    int Get_Count_( );
 
  private :
    CT_Pointer< Type > *pointer_;
};
 
template < typename Type >
inline CT_Handle< Type >::CT_Handle( )
{
  this->pointer_ = NULL;
}
 
template < typename Type >
inline CT_Handle< Type >::CT_Handle( bool b )
{
  this->pointer_ = new CT_Pointer< Type >( );
}
 
template < typename Type >
inline CT_Handle< Type >::CT_Handle( const CT_Handle &a )
{
  this->pointer_ = a.pointer_;
 
  if( this->pointer_ != NULL )
    this->pointer_->Addition_Reference_( );
}
 
template < typename Type > inline const CT_Handle< Type >& 
CT_Handle< Type >::operator = ( const CT_Handle< Type > &b )
{
  if( this->pointer_ == NULL )
  {
    if( b.pointer_ != NULL )
      b.pointer_->Addition_Reference_( );
  }
  else
  {
    if( this->pointer_ != b.pointer_ )
    {
      if( b.pointer_ != NULL )
        b.pointer_->Addition_Reference_( );
      
      if( this->pointer_->Release_Reference_( ) )
        delete this->pointer_;
    }
  }
 
  this->pointer_ = b.pointer_;
 
  return( *this );
}
 
template < typename Type >
inline CT_Handle< Type >::~CT_Handle( )
{
  if( this->pointer_ != NULL )
    if( this->pointer_->Release_Reference_( ) )
      delete this->pointer_;   
}
//=============================================================================
 
template < typename Type >
inline int CT_Handle< Type >::Get_Count_( )
{
  if( this->pointer_ == NULL )
    return( -1 );
  else
    return( int(this->pointer_->Get_Count_( )) );
}
//=============================================================================
 
#endif
 
/*
ТЕСТОВАЯ ВЕРСИЯ.
 
Дата создания: 22.04.2011.
Дата исправлений: нет.
Описание исправлений: нет.
Автор: Максим Владимирович Ковалёв.
*/
Maksim_27_10
1 / 1 / 0
Регистрация: 05.11.2009
Сообщений: 23
24.04.2011, 18:45  [ТС]     Код. #6
Вот улучшенная реализация дескриптора(забыл добавить Release_ - куда же без неё!).

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
#ifndef __CT_HANDLE_22_04_2011_7eGI7I0M8u8D_mfgYBME10gGy82__
  #define __CT_HANDLE_22_04_2011_7eGI7I0M8u8D_mfgYBME10gGy82__
 
#include <iostream>
 
template< typename Type >
class CT_Pointer
{
  public :
    CT_Pointer( );
    //CT_Leader_Pointer( const CT_Leader_Pointer &a );
    //const CT_Leader_Pointer& operator = ( const CT_Leader_Pointer &b );
    ~CT_Pointer( );
 
  public :
    Type * Get_Pointer_( );
    void Addition_Reference_( );
    bool Release_Reference_( );
    unsigned int Get_Count_( );
 
  private :
    unsigned int count_;
    Type         *pointer_;
};
 
template < typename Type >
inline CT_Pointer< Type >::CT_Pointer( )
{
  this->pointer_ = new Type( );
  this->count_   = 1;
 
  std::cout << "CT_Pointer Create." << std::endl;
}
 
template < typename Type >
inline CT_Pointer< Type >::~CT_Pointer( )
{
  delete this->pointer_;
 
  std::cout << "CT_Pointer Destroy." << std::endl;
}
//=============================================================================
 
template < typename Type >
inline Type * CT_Pointer< Type >::Get_Pointer_( )
{
  return( this->pointer_ );
}
 
template < typename Type >
inline void CT_Pointer< Type >::Addition_Reference_( )
{
  ++this->count_;
}
 
template < typename Type >
inline bool CT_Pointer< Type >::Release_Reference_( )
{
  bool result = false;
 
  --this->count_;
 
  if( this->count_ == 0 )
  {
    delete this->pointer_;
    this->pointer_ = NULL;
    result         = true;
  }
 
  return( result );
}
 
template < typename Type >
inline unsigned int CT_Pointer< Type >::Get_Count_( )
{
  return( this->count_ );
}
/******************************************************************************
  *                                                                         *  
  *                                                                         *
  *                                                                         *
  *                                                                         *
  *                                                                         *
******************************************************************************/
template < typename Type >
class CT_Handle
{
  public :
    CT_Handle( );                                                              // Указатель вникуда.
    CT_Handle( bool b );                                                       // Создаёт объект.
    CT_Handle( const CT_Handle &a );                                           // Увеличивает количество ссылок.
    const CT_Handle& operator = ( const CT_Handle &b );                        // По ситуации.
    ~CT_Handle( );
 
  public :
    operator Type    * ( ) { return( this->pointer_->Get_Pointer_( ) ); }
    Type * operator -> ( ) { return( this->pointer_->Get_Pointer_( ) ); }
 
  public :
    unsigned int Get_Count_( );
    void Release_( );
 
  private :
    CT_Pointer< Type > *pointer_;
};
 
template < typename Type >
inline CT_Handle< Type >::CT_Handle( )
{
  this->pointer_ = NULL;
}
 
template < typename Type >
inline CT_Handle< Type >::CT_Handle( bool b )
{
  this->pointer_ = new CT_Pointer< Type >( );
}
 
template < typename Type >
inline CT_Handle< Type >::CT_Handle( const CT_Handle &a )
{
  this->pointer_ = a.pointer_;
 
  if( this->pointer_ != NULL )
    this->pointer_->Addition_Reference_( );
}
 
template < typename Type > inline const CT_Handle< Type >& 
CT_Handle< Type >::operator = ( const CT_Handle< Type > &b )
{
  if( this->pointer_ == NULL )
  {
    if( b.pointer_ != NULL )
      b.pointer_->Addition_Reference_( );
  }
  else
  {
    if( this->pointer_ != b.pointer_ )
    {
      if( b.pointer_ != NULL )
        b.pointer_->Addition_Reference_( );
      
      /*if( this->pointer_->Release_Reference_( ) )
        delete this->pointer_;*/
      this->Release_( );
    }
  }
 
  this->pointer_ = b.pointer_;
 
  return( *this );
}
 
template < typename Type >
inline CT_Handle< Type >::~CT_Handle( )
{
  //if( this->pointer_ != NULL )
  //  if( this->pointer_->Release_Reference_( ) )
  //    delete this->pointer_;   
  this->Release_( );
}
//=============================================================================
 
template < typename Type >
inline unsigned int CT_Handle< Type >::Get_Count_( )
{
  if( this->pointer_ == NULL )
    return( 0 );
  else
    return( int(this->pointer_->Get_Count_( )) );
}
 
template < typename Type >
inline void CT_Handle< Type >::Release_( )
{
  if( this->pointer_ != NULL )
    if( this->pointer_->Release_Reference_( ) )
    {
      delete this->pointer_;
      this->pointer_ = NULL;
    }
    else
    {
      this->pointer_ = NULL;
    }
}
//=============================================================================
 
#endif
 
/*
ТЕСТОВАЯ ВЕРСИЯ.
 
Дата создания: 22.04.2011.
Дата исправлений: 
1) 24.04.2011 года.
Описание исправлений: нет.
1. 
  1.1. Изменено возвращаемое значение функции CT_Handle< Type >::Get_Count_( ) 
       c int на unsigned int. Теперь при пустом дескрипторе эта функция 
       возвращает 0, а не -1, что является более правильным.
  1.2. Добавлена функция CT_Handle< Type >::Release_( ), которая делает 
       дескриптор пустым + автоматически удаляет объект, если количество ссылок
       равно нулю. 
       Для пустого дескриптора эта функция ничего не делает.
  1.3. Изменена реализация декрементации количества ссылок в операторе 
       присваивания и деструкторе. Теперь это делает Release_( ).
Автор: Максим Владимирович Ковалёв.
*/
Maksim_27_10
1 / 1 / 0
Регистрация: 05.11.2009
Сообщений: 23
28.04.2011, 20:16  [ТС]     Код. #7
Почему 87 просмотров и ни одного отзыва? Вот ещё одна улучшенная версия того же самого.
Я бы всё же, так фанатично желал бы услышать ваши отзывы. Улучшения здесь практически не добился, но я считаю, что эта версия лучше в силу философских причин ООП.

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
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
#ifndef __CT_HANDLE_22_04_2011_7eGI7I0M8u8D_mfgYBME10gGy82__
  #define __CT_HANDLE_22_04_2011_7eGI7I0M8u8D_mfgYBME10gGy82__
 
#include <iostream>
 
/******************************************************************************
  * Шаблонный класс описателя(дескриптора).
  * Предусловие: использовать только CT_Handle.
  *
  *              Класс-параметр должен иметь конструктор по умолчанию.
  * Применение: класс описателя предназначен для избежания ошибок при работе с
  *             динамической памятью, обладает большей гибкостью, чем ведущий
  *             указатель, избавлен от его недостатков, например, при передаче
  *             прав владения. Автоматически удаляет объект, когда счётчик 
  *             ссылок на него станет равным нулю.
  *
  *
  *
  *
  * 1. Базовые функции.
  *   1.1. Конструктор по умолчанию.
  *   Предусловие: нет.
  *   Постусловие: создан пустой описатель объекта(объект не создан).
  *   1.2. Конструктор с фиктивным параметром.
  *   Предусловие: вы можете передавать в качестве булева параметра всё что 
  *                угодно - этот параметр фиктивный.
  *   Постусловие: создану описатель объекта на только что созданный объект.
  *   1.3. Конструктор копирования.
  *   Предусловие: нет.
  *   Постусловие: создан новый описатель объекта, который описывает тот же
  *                объект, что и a.
  *   1.4. Оператор присваивания.
  *   Предусловие: нет.
  *   Постусловие: ведёт автоматический подсчёт ссылок, когда это значение
  *                равно нулю, объект автоматически удаляется, а описатель 
  *                становится пустым. Этот оператор ведёт себя точно 
  *                так же, как и обычный оператор присваивания.
  *   1.5. Деструктор.
  *   Предусловие: нет.
  *   Постусловие: уменьшает количество ссылок на описываемый объект, когда
  *                это число равно нулю, объект автоматически удаляется.
  * 2. Функции для того, чтобы описатель вёл себя точно так же как и указатель.
  *   2.1. Оператор разыменования.
  *   Предусловие: нельзя разыменовывать пустой описатель!
  *   Постусловие: получен указатель на описываемый объект, если 
  *                разыменовывается пустой описатель, то программа упадёт.
  *   2.2. Оператор разыменования и селлектор класса.
  *   Предусловие: нельзя разыменовывать пустой описатель!
  *   Постусловие: получен указатель на описываемый объект, если применено к
  *                пустому описателю, то программа упадёт.
  * 3. Функции для работы с классом.
  *   3.1. Получить количество описателей, которые описывают один и тот же
  *        объект(количество ссылок.)
  *   Предусловие: нет.
  *   Постусловие: возвращено количество ссылок на описываемый объект. 
  *                Если применено к пустому описателю, то возвращается нуль, 
  *                что не может быть в действительности.
  *   3.2. Отказаться от описываемого объекта.
  *   Предусловие: нет.
  *   Постусловие: описатель становится пустым, число ссылок уменьшается на 
  *                один, и если это число равняется нулю, то описываемый 
  *                объект удаляется.
******************************************************************************/
template< typename Type >
class CT_Pointer
{
  private : /*                    Запрещенно.                                */
    CT_Pointer( const CT_Pointer &a );
    const CT_Pointer& operator = ( const CT_Pointer &b );
 
  public :
    CT_Pointer( );
    ~CT_Pointer( );
 
  public :
    Type * Get_Pointer_( );
    void Addition_Reference_( );
    bool Release_Reference_( );
    unsigned int Get_Count_( );
 
  private :
    unsigned int count_;
    Type         *pointer_;
};
//=============================================================================
 
template < typename Type >
class CT_Handle_Base
{
  public :
    CT_Handle_Base( );
    CT_Handle_Base( bool b );
    CT_Handle_Base( const CT_Handle_Base &a );
    const CT_Handle_Base& operator = ( const CT_Handle_Base &b );
    ~CT_Handle_Base( );
 
  public :
    operator Type    * ( ) { return( this->pointer_->Get_Pointer_( ) ); }
    Type * operator -> ( ) { return( this->pointer_->Get_Pointer_( ) ); }
 
  public :
    unsigned int Get_Count_( );
    void         Release_( );
 
  private :
    CT_Pointer< Type > *pointer_;
};
//=============================================================================
 
template < typename Type >
class CT_Handle : private CT_Handle_Base< Type >
{
  public :                                                           /* 1    */
    CT_Handle( );                                                    /* 1.1  */
    CT_Handle( bool b );                                             /* 1.2  */
    CT_Handle( const CT_Handle &a );                                 /* 1.3  */
    const CT_Handle& operator = ( const CT_Handle &b );              /* 1.4  */
    ~CT_Handle( );                                                   /* 1.5  */
 
  public :                                                           /* 2    */
    operator Type    * ( )                                           /* 2.1  */
    { 
      return( this->CT_Handle_Base::operator ->( ) ); 
    }
    Type * operator -> ( )                                           /* 2.2  */
    { 
      return( this->CT_Handle_Base::operator ->( ) ); 
    }
 
  public :                                                           /* 3    */
    unsigned int Get_Count_( );                                      /* 3.1  */
    void         Release_( );                                        /* 3.2  */
};
//=============================================================================
 
 
 
 
 
/******************************************************************************
  *                             Функции-реализации.
  *
  *
  *
  *
******************************************************************************/
//=============================================================================
// *                       Функции-реализации класса CT_Pointer.
// *
// *
// *
// *
//=============================================================================
//                            Базовые функции.
template < typename Type >
inline CT_Pointer< Type >::CT_Pointer( )
{
  this->pointer_ = new Type( );
  this->count_   = 1;
 
  std::cout << "CT_Pointer. Create." << std::endl;
}
//-----------------------------------------------------------------------------
 
template < typename Type >
inline CT_Pointer< Type >::~CT_Pointer( )
{
  delete this->pointer_;
 
  std::cout << "CT_Pointer. Destroy." << std::endl;
}
//=============================================================================
//                          Функции для работы с классом.
template < typename Type >
inline Type * CT_Pointer< Type >::Get_Pointer_( )
{
  return( this->pointer_ );
}
//-----------------------------------------------------------------------------
 
template < typename Type >
inline void CT_Pointer< Type >::Addition_Reference_( )
{
  ++this->count_;
}
//-----------------------------------------------------------------------------
 
template < typename Type >
inline bool CT_Pointer< Type >::Release_Reference_( )
{
  bool result = false;
 
  --this->count_;
 
  if( this->count_ == 0 )
  {
    delete this->pointer_;
    this->pointer_ = NULL;
    result         = true;
  }
 
  return( result );
}
//-----------------------------------------------------------------------------
 
template < typename Type >
inline unsigned int CT_Pointer< Type >::Get_Count_( )
{
  return( this->count_ );
}
//============================================================================
//  *               Функции-реализации класса CT_Handle_Base(движок).
//  *
//  *
//  *
//  *
//=============================================================================
//                                 Базовые функции.
template < typename Type >
inline CT_Handle_Base< Type >::CT_Handle_Base( )
{
  std::cout << "CT_Handle_Base. CT_Handle_Base( )." << std::endl;
 
  this->pointer_ = NULL;
}
//-----------------------------------------------------------------------------
 
template < typename Type >
inline CT_Handle_Base< Type >::CT_Handle_Base( bool /*b*/ )
{
  std::cout << "CT_Handle_Base. CT_Handle_Base( b )" << std::endl;
 
  this->pointer_ = new CT_Pointer< Type >( );
}
//-----------------------------------------------------------------------------
 
template < typename Type >
inline CT_Handle_Base< Type >::CT_Handle_Base( const CT_Handle_Base &a )
{
  std::cout << "CT_Handle_Base. Copy." << std::endl;
 
  this->pointer_ = a.pointer_;
 
  if( this->pointer_ != NULL )
    this->pointer_->Addition_Reference_( );
}
//-----------------------------------------------------------------------------
 
template < typename Type > inline const CT_Handle_Base< Type >& 
CT_Handle_Base< Type >::operator = ( const CT_Handle_Base< Type > &b )
{
  std::cout << "CT_Handle_Base. Appropriate." << std::endl;
 
  if( this->pointer_ == NULL )
  {
    if( b.pointer_ != NULL )
      b.pointer_->Addition_Reference_( );
  }
  else
  {
    if( this->pointer_ != b.pointer_ )
    {
      if( b.pointer_ != NULL )
        b.pointer_->Addition_Reference_( );
 
      this->Release_( );
    }
  }
 
  this->pointer_ = b.pointer_;
 
  return( *this );
}
//-----------------------------------------------------------------------------
 
template < typename Type >
inline CT_Handle_Base< Type >::~CT_Handle_Base( )
{
  std::cout << "CT_Handle_Base. Destroy" << std::endl;
 
  this->Release_( );
}
//=============================================================================
//                          Функции для работы с классом.
template < typename Type >
inline unsigned int CT_Handle_Base< Type >::Get_Count_( )
{
  if( this->pointer_ == NULL )
    return( 0 );
  else
    return( int(this->pointer_->Get_Count_( )) );
}
//-----------------------------------------------------------------------------
 
template < typename Type >
inline void CT_Handle_Base< Type >::Release_( )
{
  if( this->pointer_ != NULL )
    if( this->pointer_->Release_Reference_( ) )
    {
      delete this->pointer_;
      this->pointer_ = NULL;
    }
    else
    {
      this->pointer_ = NULL;
    }
}
//=============================================================================
//                       Функции-реализации класса CT_Handle.
//  *
//  *
//  *
//  *
//  *
//=============================================================================
//                                Базовые функции.
template < typename Type >
inline CT_Handle< Type >::CT_Handle( ) 
{
  std::cout << "CT_Handle. CT_Handle( )." << std::endl;
}
//-----------------------------------------------------------------------------
 
template < typename Type >
inline CT_Handle< Type >::CT_Handle( bool b ) : 
CT_Handle_Base< Type >::CT_Handle_Base( b )
{
  std::cout << "CT_Handle. CT_Handle( b )." << std::endl;
}
//-----------------------------------------------------------------------------
 
template < typename Type >
inline CT_Handle< Type >::CT_Handle( const CT_Handle<Type> &a ) :
CT_Handle_Base< Type >::CT_Handle_Base( a )
{
  std::cout << "CT_Handle. Copy." << std::endl;
}
//-----------------------------------------------------------------------------
 
template < typename Type > inline const CT_Handle< Type >& 
CT_Handle< Type >::operator = ( const CT_Handle< Type > &b )
{
  std::cout << "CT_Handle. Appropriate." << std::endl;
 
  this->CT_Handle_Base::operator =( b );
 
  return( *this );
}
//-----------------------------------------------------------------------------
 
template < typename Type > 
inline CT_Handle< Type >::~CT_Handle( ) 
{
  std::cout << "CT_Handle. Destroy." << std::endl;
}
//=============================================================================
//                         Функции для работы с классом.
template < typename Type >
inline unsigned int CT_Handle< Type >::Get_Count_( )
{
  return( this->CT_Handle_Base::Get_Count_( ) );
}
//-----------------------------------------------------------------------------
 
template < typename Type >
inline void CT_Handle< Type >::Release_( )
{
  this->CT_Handle_Base::Release_( );
}
//=============================================================================
 
#endif
 
/*
ТЕСТОВАЯ ВЕРСИЯ.
 
Дата создания: 22.04.2011.
Дата исправлений: 
1) 24.04.2011 года.
2) 28.04.2011 года.
Описание исправлений: нет.
1. 
  1.1. Изменено возвращаемое значение функции CT_Handle< Type >::Get_Count_( ) 
       c int на unsigned int. Теперь при пустом дескрипторе эта функция 
       возвращает 0, а не -1, что является более правильным.
  1.2. Добавлена функция CT_Handle< Type >::Release_( ), которая делает 
       дескриптор пустым + автоматически удаляет объект, если количество ссылок
       равно нулю. 
       Для пустого дескриптора эта функция ничего не делает.
  1.3. Изменена реализация декрементации количества ссылок в операторе 
       присваивания и деструкторе. Теперь это делает Release_( ).
2.
  2.1. Переименован класс CT_Handle в CT_Handle_Base.
  2.2. Введён класс-интерфейс CT_Handle, который унаследован от класса 
       CT_Handle_Base. В этом примере это особенно ничего не дало - простое
       дублирование функций, но я то думал это сделать для следующей цели:
       клиент работая с классом CT_Handle не видит переменной pointer_ класса
       CT_Handle_Base при использовании средств быстрого набора. Es ist Schade!
       Лично у меня среда разработки эту переменную видит, но менять уже я 
       ничего не буду. Это практически окончательная версия.
  2.3. Добавлена документация по использованию класса CT_Handle. Все остальные
       классы предоставленные в этом заголовочном файле использовать нельзя.
  2.4. Конструктор копирования и оператор присваивания класса CT_Pointer 
       сделаны закрытыми для большей безопасности кода, так как они никогда
       не должны вызываться.
Автор: Максим Владимирович Ковалёв.
*/
Yandex
Объявления
28.04.2011, 20:16     Код.
Ответ Создать тему
Опции темы

Текущее время: 20:18. Часовой пояс GMT +3.
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2016, vBulletin Solutions, Inc.
Рейтинг@Mail.ru