ComSDK
 Указатель Классы Пространства имен Функции Переменные Определения типов Перечисления Элементы перечислений Друзья Группы Страницы
memorytools.h
1 //===========================================================================
2 #ifndef comfrm_MemoryManagementH
3 #define comfrm_MemoryManagementH
4 //===========================================================================
6 // [prd]Period: 01/2012
7 // [aut]Author: Сергей Сборщиков
8 // [did]DeveloperID: ss
9 // [pid]ProblemID: 00001
10 // [rvs = did.date.pid]Revision: //#ss.06.01.2012.00001
11 // [dsc]Description: Исправление удаления трёхмерного массива
12 // [ccm]CodeComment: rvs.{[s]Start | [e]End | []}{[n]New | [o]Old | [d]Develop}
13 // ============================================================================================ //
14 // [prd]Period: 01/2012
15 // [aut]Author: Соколов Александр
16 // [did]DeveloperID: sa
17 // [pid]ProblemID: 00002
18 // [rvs = did.date.pid]Revision: //#sa.25.01.2012.00002
19 // [dsc]Description: Оптимизация быстродействия работы циклов
20 // [ccm]CodeComment: rvs.{[s]Start | [e]End | []}{[n]New | [o]Old | [d]Develop}
21 // ============================================================================================ //
22 // [prd]Period: 02/2012
23 // [aut]Author: Александр Соколов
24 // [did]DeveloperID: sa
25 // [pid]ProblemID: 00012
26 // [rvs = did.date.pid]Revision: //#sa.18.02.2012.00012
27 // [dsc]Description: рефакторинг: перенес функцию сборки матрицы B + добавил новую функцию для обнуления
28 // массивов
29 // [ccm]CodeComment: rvs.{[s]Start | [e]End | []}{[n]New | [o]Old | [d]Develop}
30 // ============================================================================================ //
31 // [prd]Period: 02/2012
32 // [aut]Author: Alexandr Sokolov
33 // [did]DeveloperID: sa
34 // [pid]ProblemID: 00002
35 // [rvs = did.date.pid]Revision: //#sa.28.02.2012.00002
36 // [dsc]Description: Переработал метод обращения матрицы методом Гаусса.
37 // Изменил шаблонные функции выделения памяти под многомерные массивы.
38 // Изменил шаблонные функции инициализации многомерных массивов.
39 // [ccm]CodeComment: rvs.{[s]Start | [e]End | []}{[n]New | [o]Old | [d]Develop}
40 // ============================================================================================ //
49 // ============================================================================================ //
50 #include "tree.h"
51 
52 #include <list>
53 #include <algorithm>
54 
58 #define MAC_MEMRELEASE(A) {if (A!=NULL) delete A; A = NULL;}
59 
60 
64 #define MAC_ARRRELEASE(A) {if (A!=NULL) delete[] A; A = NULL;}
65 
66 #define MEM_NULL_INIT_VALUE 111
67 #define MEM_NULL_INIT_ARRAY 112
68 
69 namespace com
70 {
71  namespace mem
72  {
78  ,mdaArray
80  };
81 
85  template<class DataType>
87  {
88  public:
89  void operator()(DataType* p_data)
90  {
91  MAC_MEMRELEASE(p_data);
92  }
93  };
94 
99  template< class T >
100  void tmp_ReleaseList(std::list< T* >*& o_list)
101  {
102  if (o_list!=NULL)
103  {
104  for (typename std::list< T* >::iterator p = o_list->begin(); p != o_list->end(); ++p)
105  MAC_MEMRELEASE((*p));
106 
107  MAC_MEMRELEASE(o_list);
108  }
109  }
110 
115  template< class T >
116  void tmp_ReInitList(std::list< T >*& o_list)
117  {
118  MAC_MEMRELEASE(o_list);
119  o_list = new std::list< T >();
120  o_list->clear();
121  }
122 
127  template< class T >
128  void tmp_ReInitPtrList(std::list< T* >*& v_list)
129  {
130  com::mem::tmp_ReleaseList<T>(v_list);
131  v_list = new std::list< T* >();
132  v_list->clear();
133  }
134 
139  template< class T >
141  {
142  typedef typename tree< T* >::post_order_iterator LIT;
143  if (o_tree != NULL)
144  {
145  for (LIT p = o_tree->begin(); o_tree->is_valid(p); ++p)
146  delete (*p);
147 
148  if (o_tree != NULL)
149  delete o_tree;
150 
151  o_tree = NULL;
152  }
153  }
154 
160  template< class T >
161  void tmp_CopyList(std::list< T* >& o_dest, std::list< T* >& p_source)
162  {
163  typedef typename std::list< T* >::iterator LIT;
164 
165  // освобождение памяти
166  for (LIT p = o_dest.begin(); p != o_dest.end(); ++p)
167  delete (*p);
168 
169  o_dest.clear();
170 
171  // копирование с созданием
172  for (LIT p = p_source.begin(); p != p_source.end(); ++p)
173  {
174  T* tmp = new T(*(*p));
175  o_dest.push_back((*p));
176  }
177  }
178 
187  template<typename DataType>
188  void copyTwoDimArray(DataType** o_res, DataType** const p_orig, int p_rows, int p_cols)
189  {
190  for (int iCount = 0; iCount < p_rows; iCount++){
191  for (int jCount = 0; jCount < p_cols; jCount++){
192  o_res[iCount][jCount] = p_orig[iCount][jCount];
193  }
194  }
195  }
196 
206  template<class T>
207  int tmp_reinitOneDimArray(T*& o_array, bool p_createNew, int p_dim, enu_MultiDimArrayType p_init_type, T* p_init_value)
208  {
209  int res = 0;
210 
211  if (p_createNew)
212  o_array = new T[p_dim];
213 
214  switch (p_init_type)
215  {
216  case mdaNotInitialized:
217  // ничего не делаем
218  // - по умолчанию для повышения быстродействия не следует инициализировать массив, если предполагается, что он весь будет
219  // заполнен вычислительным алгоритмом позже!!!
220  break;
221  case mdaIdentity:
222  // определен по-разному для многомерных массивов и реализуется отдельно в каждой функции
223  //
224  // ПО ОПРЕДЕЛЕНИЮ - ИНИЦИАЛИЗИРУЕМ ТОЛЬКО ПЕРВЫЙ ЭЛЕМЕНТ МАССИВА
225  o_array[0] = T(1);
226  break;
227  case mdaValue:
228  if (p_init_value != NULL)
229  for (T* it = o_array; it != o_array + p_dim; it++)
230  *it = *p_init_value;
231  else
232  {
233  for (T* it = o_array; it != o_array + p_dim; it++)
234  *it = T(0);
235 
236  res = MEM_NULL_INIT_VALUE;
237  }
238  break;
239  case mdaArray:
240  if (p_init_value!=NULL)
241  for (T *it = o_array, *src = p_init_value; it != o_array + p_dim; ++it, ++src)
242  *it = *src;
243  else
244  res = MEM_NULL_INIT_ARRAY;
245  break;
246  default:
247  // ничего не делаем
248  break;
249  };
250 
251  if (res == MEM_NULL_INIT_VALUE || res == MEM_NULL_INIT_ARRAY)
252  for (T *it = o_array;it != o_array + p_dim; ++it)
253  *it = T(0);
254 
255  return res;
256  }
257 
266  template<class T>
267  int tmp_reinitOneDimArray(T*& out, bool p_createNew, int p_dim, const T& p_init_value=T(0))
268  {
269  T temp = p_init_value;
270  return tmp_reinitOneDimArray<T>(out, p_createNew, p_dim, mdaValue, &temp);
271  }
272 
283  template<class T>
284  int tmp_reinitTwoDimArray(T**& o_array, bool p_create_new, int p_rows, int p_cols, enu_MultiDimArrayType p_init_type, T** p_init_value)
285  {
286  if (p_create_new)
287  o_array = new T*[p_rows];
288 
290  if (p_init_value != NULL && p_init_type == mdaArray)
291  for (T **it = o_array, **src = p_init_value; it != o_array + p_rows; ++it, ++src)
292  tmp_reinitOneDimArray< T >(*it, p_create_new, p_cols, p_init_type, *src);
293  else if (p_init_value == NULL && p_init_type == mdaValue)
294  for (T **it = o_array; it != o_array + p_rows; ++it)
295  tmp_reinitOneDimArray< T >(*it, p_create_new, p_cols, p_init_type, NULL);
296  else if (p_init_value != NULL && p_init_type == mdaValue)
297  for (T **it = o_array; it != o_array + p_rows; ++it)
298  tmp_reinitOneDimArray< T >(*it, p_create_new, p_cols, **p_init_value);
299  else if (p_init_type == mdaNotInitialized)
300  for (T **it = o_array; it != o_array + p_rows; ++it)
301  tmp_reinitOneDimArray< T >(*it, p_create_new, p_cols, p_init_type, NULL);
302  else if (p_init_type == mdaIdentity)
303  for (int i=0; i < p_rows; ++i)
304  for (int j=0; j < p_cols; ++j)
305  o_array[i][j] = (i==j)?T(1):T(0);
306  return 0;
307  }
308 
318  template<class T >
319  int tmp_reinitTwoDimArray(T**& p_out, bool p_createNew, int p_rows, int p_cols, const T& p_init_value= T(0))
320  {
321  T temp = p_init_value;
322  T *ptr = &temp;
323  T **pptr = &ptr;
324  return tmp_reinitTwoDimArray< T >(p_out, p_createNew, p_rows, p_cols, mdaValue, pptr);
325  }
326 
335  template<class T>
336  T* createOneDimArray(int p_dim, enu_MultiDimArrayType p_init_type, T* p_init_array=NULL)
337  {
338  T *out = NULL;
339  tmp_reinitOneDimArray<T>(out, true, p_dim, p_init_type, p_init_array);
340  return out;
341  }
342 
351  template<class T>
352  T** createTwoDimArray(int p_rows, int p_cols, enu_MultiDimArrayType p_init_type, T** p_init_value=NULL)
353  {
354  T **o_array = NULL;
355  tmp_reinitTwoDimArray(o_array, true, p_rows, p_cols, p_init_type, p_init_value);
356  return o_array;
357  }
358 
370  template<class T>
371  int tmp_reinitThreeDimArray(T***& o_array, bool p_create_new, int p_dim1, int p_dim2, int p_dim3, enu_MultiDimArrayType p_init_type, T*** p_init_value)
372  {
373  if (p_create_new)
374  o_array = new T**[p_dim1];
376  if (p_init_value != NULL && p_init_type == mdaArray)
377  for (T ***it = o_array, ***src = p_init_value; it != o_array + p_dim1; ++it, ++src)
378  tmp_reinitTwoDimArray< T >(*it, p_create_new, p_dim2, p_dim3, p_init_type, *src);
379  else if (p_init_value == NULL && p_init_type == mdaValue)
380  for (T ***it = o_array; it != o_array + p_dim1; ++it)
381  tmp_reinitTwoDimArray< T >(*it, p_create_new, p_dim2, p_dim3, p_init_type, NULL);
382  else if (p_init_value != NULL && p_init_type == mdaValue)
383  for (T ***it = o_array; it != o_array + p_dim1; ++it)
384  tmp_reinitTwoDimArray< T >(*it, p_create_new, p_dim2, p_dim3, ***p_init_value);
385  else if (p_init_type == mdaNotInitialized)
386  for (T ***it = o_array; it != o_array + p_dim1; ++it)
387  tmp_reinitTwoDimArray< T >(*it, p_create_new, p_dim2, p_dim3, p_init_type, NULL);
388  else
389  {
390  if (p_init_type == mdaIdentity)
391  for (int i = 0; i < p_dim1; ++i)
392  for (int j = 0; j < p_dim2; ++j)
393  for (int k = 0; k < p_dim3; ++k)
394  o_array[i][j][k] = (i==j && j==k)?T(1):T(0);
395  }
396  return 0;
397  }
398 
410  template<class T>
411  int tmp_reinitThreeDimArray(T***& o_out, bool p_create_new, int p_dim1, int p_dim2, int p_dim3, const T& p_init_value=T(0))
412  {
413  T temp = p_init_value;
414  T *ptr = &temp;
415  T **pptr = &ptr;
416  T ***ppptr = &pptr;
417  return tmp_reinitThreeDimArray< T >(o_out, p_create_new, p_dim1, p_dim2, p_dim3, mdaValue, ppptr);
418  }
419 
428  template<class T>
429  T*** createThreeDimArray(int p_dim1, int p_dim2, int p_dim3, const T& p_init_value=T(0))
430  {
431  T ***o_array = NULL;
432  tmp_reinitThreeDimArray(o_array, true, p_dim1, p_dim2, p_dim3, p_init_value);
433  return o_array;
434  }
435 
445  template<class T>
446  T*** createThreeDimArray(int p_dim1, int p_dim2, int p_dim3, enu_MultiDimArrayType p_init_type, T*** p_init_value=NULL)
447  {
448  T ***o_array = NULL;
450  tmp_reinitThreeDimArray(o_array, true, p_dim1, p_dim2, p_dim3, p_init_type, p_init_value);
451  return o_array;
452  }
453 
460  template<class T>
461  T* createOneDimArray(int p_dim, const T& p_init_value=T(0))
462  {
463  T *out = NULL;
464  T temp = p_init_value;
465  tmp_reinitOneDimArray<T>(out, true, p_dim, mdaValue, &temp);
466  return out;
467  }
468 
476  template<class T>
477  T** createTwoDimArray(int p_rows, int p_cols, const T& p_init_value=T(0))
478  {
479  T **out = NULL;
480  T temp = p_init_value;
481  tmp_reinitTwoDimArray<T>(out, true, p_rows, p_cols, temp);
482  return out;
483  }
484 
490  template<class T>
491  void freeTwoDimArray(T**& o_ptr, int p_rows)
492  {
493  if (o_ptr != NULL)
494  {
495  for (int i = 0; i < p_rows; ++i)
496  MAC_ARRRELEASE(o_ptr[i]);
497 
498  MAC_ARRRELEASE(o_ptr);
499  }
500  }
501 
508  template<class T>
509  void freeThreeDimArray(T*** o_ptr, int p_dim1, int p_dim2)
510  {
511  if (o_ptr != NULL)
512  {
513  for (int i = 0; i < p_dim1; ++i)
514  {
515  for (int j = 0 ; j < p_dim2; ++j)
516  MAC_ARRRELEASE(o_ptr[i][j]);
517 
518  MAC_ARRRELEASE(o_ptr[i]);
519  }
520 
521  MAC_ARRRELEASE(o_ptr);
522  }
523  }
524 
529  template<typename DATATYPE>
531  {
532  int m_dim1;
533  DATATYPE *m_data;
534  public:
535  cls_oneDimArray(int p_dim1)
536  :m_dim1(p_dim1)
537  ,m_data(createOneDimArray<DATATYPE>(m_dim1))
538  {}
539 
540  ~cls_oneDimArray()
541  {
542  MAC_ARRRELEASE(m_data);
543  }
544 
545  DATATYPE* data()
546  {
547  return m_data;
548  }
549  };
550 
555  template<typename DATATYPE>
557  {
558  public:
559  cls_twoDimArray(int p_dim1, int p_dim2)
560  :m_dim1(p_dim1)
561  ,m_dim2(p_dim2)
562  ,m_data(createTwoDimArray<DATATYPE>(m_dim1,m_dim2))
563  {}
564 
565  ~cls_twoDimArray()
566  {
567  freeTwoDimArray<DATATYPE>(m_data,m_dim1);
568  }
569 
570  DATATYPE** data()
571  {
572  return m_data;
573  }
574 
575  private:
576  int m_dim1;
577  int m_dim2;
578  DATATYPE **m_data;
579  };
580  }
581 }
582 //===========================================================================
583 #endif
Класс одномерного массива
Definition: memorytools.h:530
enu_MultiDimArrayType
Набор параметров, определяющих как нужно инициализировать многомерный массив.
Definition: memorytools.h:74
#define MAC_ARRRELEASE(A)
Definition: memorytools.h:64
Массив не следует инициализировать
Definition: memorytools.h:75
void tmp_ReInitList(std::list< T > *&o_list)
Definition: memorytools.h:116
где N - размерность массива, а i1,i2,...,iN - индексы элементов по каждой размерности ...
Definition: memorytools.h:77
Функциональный класс для освобождения памяти
Definition: memorytools.h:86
void copyTwoDimArray(DataType **o_res, DataType **const p_orig, int p_rows, int p_cols)
Definition: memorytools.h:188
int tmp_reinitOneDimArray(T *&o_array, bool p_createNew, int p_dim, enu_MultiDimArrayType p_init_type, T *p_init_value)
Definition: memorytools.h:207
void tmp_ReleaseTree(tree< T * > *&o_tree)
Definition: memorytools.h:140
void tmp_CopyList(std::list< T * > &o_dest, std::list< T * > &p_source)
Definition: memorytools.h:161
pre_order_iterator begin() const
Return iterator to the beginning of the tree.
Definition: tree.h:613
#define MAC_MEMRELEASE(A)
Definition: memorytools.h:58
T ** createTwoDimArray(int p_rows, int p_cols, enu_MultiDimArrayType p_init_type, T **p_init_value=NULL)
Definition: memorytools.h:352
Класс двухмерного массива
Definition: memorytools.h:556
bool is_valid(const iterator_base &) const
Determine whether the iterator is an &#39;end&#39; iterator and thus not actually pointing to a node...
Definition: tree.h:1818
Depth-first iterator, first accessing the children, then the node itself.
Definition: tree.h:144
Массив следует инициализировать одним заданным значением
Definition: memorytools.h:76
void tmp_ReInitPtrList(std::list< T * > *&v_list)
Definition: memorytools.h:128
void freeTwoDimArray(T **&o_ptr, int p_rows)
Definition: memorytools.h:491
Definition: tree.h:71
Массив следует инициализировать данными из другого массива (аналог копирующего конструктора для класс...
Definition: memorytools.h:79
void freeThreeDimArray(T ***o_ptr, int p_dim1, int p_dim2)
Definition: memorytools.h:509
T *** createThreeDimArray(int p_dim1, int p_dim2, int p_dim3, const T &p_init_value=T(0))
Definition: memorytools.h:429
int tmp_reinitTwoDimArray(T **&o_array, bool p_create_new, int p_rows, int p_cols, enu_MultiDimArrayType p_init_type, T **p_init_value)
Definition: memorytools.h:284
void tmp_ReleaseList(std::list< T * > *&o_list)
Definition: memorytools.h:100
T * createOneDimArray(int p_dim, enu_MultiDimArrayType p_init_type, T *p_init_array=NULL)
Definition: memorytools.h:336
int tmp_reinitThreeDimArray(T ***&o_array, bool p_create_new, int p_dim1, int p_dim2, int p_dim3, enu_MultiDimArrayType p_init_type, T ***p_init_value)
Definition: memorytools.h:371