今天发现自己的array类太慢

关注

转载最新推荐文章于 2026-09-18 14:12:32 发布 737 阅读 AI 写同款· GEO 优化 ›

MySQL的`JSON`类型：如何利用`JSON_ARRAY_APPEND`和`JSON_ARRAY_INSERT`操作动态修改数组？这极大地增强了 MySQL 处理半结构化数据的能力，无需预先定义严格的 schema。是 MySQL 中动态修改 JSON 数组的利器，熟练掌握它们能让你在数据库层面灵活地处理复杂的数据结构，提高数据管理的效率和灵活性。如果指定路径不存在，则会创建一个新的数组，并将值添加到该数组中。这两个函数是动态修改 JSON 数组的关键工具，掌握它们能让你在数据库层面灵活地处理复杂的数据结构。函数用于在 JSON 文档中指定路径的数组的指定位置插入一个或多个值。例如，如果路径不存在或者指向的不是一个数组，阅读详情

Lazy Compiler使用Syngram动态创建语法分析器的代码实在是太慢了，debug竟然需要8秒钟来处理91条比较长的文法。于是我打开了Visual Studio 2008的Performance Wizard查看运行时消耗的资源，结果发现竟然都消耗在自己那个array类的operator[]里面了。那一段代码是用来检查文法的左递归引用关系是否出现环的。结果就把用到的四个array全部换成bool*了，当时只是为了创建二维数组方便使用了array类。

过后，debug的时间立刻降为2秒钟不到，于是我又打开Performance Wizard看了一次，这次消耗的瓶颈终于转移到一个合理的地方了。

结果：array竟然比指针慢了无穷多倍，得找个时候重新写一次。不过这段代码好象是去年写的，也没经过什么性能测试，也难怪发现不了问题。在此帖上代码，等Lazy Script写完了重新审查一下自己的那套模板库（NTL，Non-standard Template Library，娃哈哈）。

  1      enum VLE_ArrayCommander
  2     {
  3         vacNewArray
  4     };
  5
  6     template < VLE_ArrayCommander _Commander , VInt _Dims >
  7      class VL_ArrayDimension : public VL_Base
  8     {
  9      public :
10         VInt    Dims[_Dims + 1 ];
11
12         VL_ArrayDimension()
13         {
14              for (VInt i = 0 ;i < _Dims;i ++ )
15             {
16                 Dims[i] = 0 ;
17             }
18         }
19
20         VL_ArrayDimension(VInt Dim , VInt * PrevDims)
21         {
22             Dims[ 0 ] = Dim;
23             memcpy(Dims + 1 ,PrevDims, sizeof (VInt) * (_Dims - 1 ));
24         }
25
26         VL_ArrayDimension < _Commander , _Dims + 1 > operator [](VInt Dim)
27         {
28              return VL_ArrayDimension < _Commander , _Dims + 1 > (Dim,Dims);
29         }
30
31         VInt GetSize()
32         {
33             VInt Size = 1 ;
34              for (VInt i = 0 ;i < _Dims;i ++ )
35             {
36                 Size *= Dims[i];
37             }
38              return Size;
39         }
40     };
41
42      extern VL_ArrayDimension < vacNewArray , 0 > NewArray;
43
44     template < typename _Type >
45      class VL_ArrayInfo : public VL_Base
46     {
47      public :
48         _Type *     Elements;
49         VInt *     Dims;
50         VInt    RefCount;
51         VInt    Size;
52
53         VL_ArrayInfo(VInt aDims)
54         {
55             Dims = new VInt[aDims];
56         }
57
58          ~ VL_ArrayInfo()
59         {
60             delete[] Dims;
61         }
62     };
63
64     template < typename _Type , VInt _Dims >
65      class VL_Array : public VL_Base
66     {
67      protected :
68
69      public :
70
71         template < VInt _RefDims >
72          class VL_ArrayReference : public VL_Base
73         {
74             friend class VL_Array;
75          protected :
76             VL_ArrayInfo < _Type >*     FInfo;
77             _Type *                     FElements;
78             VInt                    FSubSize;
79          public :
80
81             VL_ArrayReference(_Type * Elements , VL_ArrayInfo < _Type >* Info , VInt Dim)
82             {
83                 FInfo = Info;
84                 FSubSize = FInfo -> Size / FInfo -> Dims[_RefDims];
85                 FElements = Elements + Dim * FSubSize;
86             }
87
88             VL_ArrayReference(VL_ArrayInfo < _Type >* Info , _Type * Elements , VInt SubSize)
89             {
90                 FInfo = Info;
91                 FElements = Elements;
92                 FSubSize = SubSize;
93             }
94
95             VL_ArrayReference < _RefDims - 1 > operator [](VInt Dim)
96             {
97                 VInt SubSize = FSubSize / FInfo -> Dims[_RefDims - 1 ];
98                  return VL_ArrayReference < _RefDims - 1 > (FInfo,FElements + Dim * SubSize,SubSize);
99             }
100
101              operator VL_Array < _Type , _RefDims > ()
102             {
103                  return VL_Array < _Type , _Dims - 1 > (FInfo,FElements);
104             }
105
106             VL_Array < _Type , _RefDims > Reference()
107             {
108                  return VL_Array < _Type , _Dims - 1 > (FInfo,FElements);
109             }
110
111             VL_Array < _Type , _RefDims > Clone()
112             {
113                  return VL_Array < _Type , _Dims - 1 > (FInfo,FElements).Clone();
114             }
115
116              void Copy(VL_Array < _Type , _RefDims >& Array)
117             {
118                 VL_ArrayInfo < _Type >* ArrayInfo = Array.GetInfo();
119                 VInt Count = FInfo -> Dims[_RefDims - 1 ];
120                  if (Count > ArrayInfo -> Dims[_RefDims - 1 ])
121                 {
122                     Count = ArrayInfo -> Dims[_RefDims - 1 ];
123                 }
124                  for (VInt i = 0 ;i < Count;i ++ )
125                 {
126                      operator [](i).Copy(Array[i].Reference());
127                 }
128             }
129
130             VInt GetCount()
131             {
132                  return FInfo -> Dims[_RefDims - 1 ];
133             }
134         };
135
136         template <>
137          class VL_ArrayReference < 1 > : public VL_Base
138         {
139          protected :
140             VL_ArrayInfo < _Type >*     FInfo;
141             _Type *                     FElements;
142          public :
143
144             VL_ArrayReference(_Type * Elements , VL_ArrayInfo < _Type >* Info , VInt Dim)
145             {
146                 FInfo = Info;
147                 FElements = Elements + Dim * FInfo -> Size / FInfo -> Dims[ 1 ];
148             }
149
150             VL_ArrayReference(VL_ArrayInfo < _Type >* Info , _Type * Elements , VInt SubSize)
151             {
152                 FInfo = Info;
153                 FElements = Elements;
154             }
155
156             _Type & operator [](VInt Dim)
157             {
158                  return FElements[Dim];
159             }
160
161              operator VL_Array < _Type , 1 > ()
162             {
163                  return VL_Array < _Type , 1 > (FInfo,FElements);
164             }
165
166             VL_Array < _Type , 1 > Reference()
167             {
168                  return VL_Array < _Type , 1 > (FInfo,FElements);
169             }
170
171             VL_Array < _Type , 1 > Clone()
172             {
173                  return VL_Array < _Type , 1 > (FInfo,FElements).Clone();
174             }
175
176              void Copy(VL_Array < _Type , 1 >& Array)
177             {
178                 VL_ArrayInfo < _Type >* ArrayInfo = Array.GetInfo();
179                 _Type * ArrayElements = Array.GetElements();
180                 VInt Count = FInfo -> Dims[ 0 ];
181                  if (Count > ArrayInfo -> Dims[ 0 ])
182                 {
183                     Count = ArrayInfo -> Dims[ 0 ];
184                 }
185                  for (VInt i = 0 ;i < Count;i ++ )
186                 {
187                     FElements[i] = ArrayElements[i];
188                 }
189             }
190
191             VInt GetCount()
192             {
193                  return FInfo -> Dims[ 0 ];
194             }
195         };
196
197      protected :
198         VL_ArrayInfo < _Type >*     FInfo;
199         _Type *                     FElements;
200
201          void Create(VInt Size)
202         {
203             FInfo = new VL_ArrayInfo < _Type > (_Dims);
204             FInfo -> Elements = new _Type[Size];
205             FInfo -> RefCount = 1 ;
206             FInfo -> Size = Size;
207              if (Size == 0 )
208             {
209                  for (VInt i = 0 ;i < _Dims;i ++ )
210                 {
211                     FInfo -> Dims[i] = 0 ;
212                 }
213             }
214             FElements = FInfo -> Elements;
215         }
216
217          void Inc()
218         {
219             FInfo -> RefCount ++ ;
220         }
221
222          void Dec()
223         {
224              if ( !-- FInfo -> RefCount)
225             {
226                 delete[] FInfo -> Elements;
227                 delete FInfo;
228                 FInfo = 0 ;
229                 FElements = 0 ;
230             }
231         }
232
233         VL_Array(VInt Size)
234         {
235             Create(Size);
236         }
237
238      public :
239
240         VL_Array()
241         {
242             Create( 0 );
243         }
244
245         VL_Array(VL_ArrayInfo < _Type >* Info , _Type * Elements)
246         {
247             FInfo = Info;
248             FElements = Elements;
249             Inc();
250         }
251
252         VL_Array(VL_ArrayDimension < vacNewArray , _Dims >& Dims)
253         {
254             Create(Dims.GetSize());
255             memcpy(FInfo -> Dims,Dims.Dims, sizeof (VInt) * _Dims);
256         }
257
258          ~ VL_Array()
259         {
260             Dec();
261         }
262
263         VL_Array(VL_Array < _Type , _Dims >& Array)
264         {
265             FInfo = Array.FInfo;
266             FElements = Array.FElements;
267             Inc();
268         }
269
270         VL_Array < _Type , _Dims >& operator = (VL_Array < _Type , _Dims >& Array)
271         {
272             Dec();
273             FInfo = Array.FInfo;
274             FElements = Array.FElements;
275             Inc();
276              return * this ;
277         }
278
279         VL_ArrayReference < _Dims - 1 > operator [](VInt Dim)
280         {
281              return VL_ArrayReference < _Dims - 1 > (FElements,FInfo,Dim);
282         }
283
284         VL_Array < _Type , _Dims > Reference()
285         {
286              return * this ;
287         }
288
289         VL_Array < _Type , _Dims > Clone()
290         {
291             VL_Array < _Type , _Dims > Array(FInfo -> Size);
292              for (VInt i = 0 ;i < FInfo -> Size;i ++ )
293             {
294                 Array.FElements[i] = FElements[i];
295             }
296             memcpy(Array.FInfo -> Dims,FInfo -> Dims, sizeof (VInt) * _Dims);
297              return Array;
298         };
299
300          void Copy(VL_Array < _Type , _Dims >& Array)
301         {
302              operator = (Array.Clone());
303         }
304
305         VL_ArrayInfo < _Type >* GetInfo()
306         {
307              return FInfo;
308         }
309
310         _Type * GetElements()
311         {
312              return FElements;
313         }
314
315         VInt GetCount()
316         {
317              return FInfo -> Dims[_Dims - 1 ];
318         }
319     };
320
321     template < typename _Type >
322      class VL_Array < _Type , 1 > : public VL_Base
323     {
324      protected :
325         VL_ArrayInfo < _Type >*     FInfo;
326         _Type *                     FElements;
327
328          void Create(VInt Size)
329         {
330             FInfo = new VL_ArrayInfo < _Type > ( 1 );
331             FInfo -> Elements = new _Type[Size];
332             FInfo -> RefCount = 1 ;
333             FInfo -> Size = Size;
334             FInfo -> Dims[ 0 ] = 0 ;
335             FElements = FInfo -> Elements;
336         }
337
338          void Inc()
339         {
340             FInfo -> RefCount ++ ;
341         }
342
343          void Dec()
344         {
345              if ( !-- FInfo -> RefCount)
346             {
347                 delete[] FInfo -> Elements;
348                 delete FInfo;
349                 FInfo = 0 ;
350                 FElements = 0 ;
351             }
352         }
353
354         VL_Array(VInt Size)
355         {
356             Create(Size);
357         }
358
359      public :
360
361         VL_Array()
362         {
363             Create( 0 );
364         }
365
366         VL_Array(VL_ArrayInfo < _Type >* Info , _Type * Elements)
367         {
368             FInfo = Info;
369             FElements = Elements;
370             Inc();
371         }
372
373         VL_Array(VL_ArrayDimension < vacNewArray , 1 >& Dims)
374         {
375             Create(Dims.GetSize());
376             FInfo -> Dims[ 0 ] = Dims.Dims[ 0 ];
377         }
378
379          ~ VL_Array()
380         {
381             Dec();
382         }
383
384         VL_Array(VL_Array < _Type , 1 >& Array)
385         {
386             FInfo = Array.FInfo;
387             FElements = Array.FElements;
388             Inc();
389         }
390
391         VL_Array < _Type , 1 >& operator = (VL_Array < _Type , 1 >& Array)
392         {
393             Dec();
394             FInfo = Array.FInfo;
395             FElements = Array.FElements;
396             Inc();
397              return * this ;
398         }
399
400         _Type & operator [](VInt Dim)
401         {
402              return FInfo -> Elements[Dim];
403         }
404
405         VL_Array < _Type , 1 > Reference()
406         {
407              return * this ;
408         }
409
410         VL_Array < _Type , 1 > Clone()
411         {
412             VL_Array < _Type , 1 > Array(FInfo -> Size);
413              for (VInt i = 0 ;i < FInfo -> Size;i ++ )
414             {
415                 Array.FInfo -> Elements[i] = FInfo -> Elements[i];
416             }
417              return Array;
418         };
419
420          void Copy(VL_Array < _Type , 1 >& Array)
421         {
422              operator = (Array.Clone());
423         }
424
425         VL_ArrayInfo < _Type >* GetInfo()
426         {
427              return FInfo;
428         }
429
430         _Type * GetElements()
431         {
432              return FElements;
433         }
434
435         VInt GetCount()
436         {
437              return FInfo -> Dims[ 0 ];
438         }
439     };

posted on 2008-04-28 11:53 陈梓瀚(vczh) 阅读(259) 评论(2) 编辑收藏引用所属分类: C++

评论:

# re: 今天发现自己的array类太慢 2008-04-28 12:06 | 空明流转

Release的照理没那么慢。回复更多评论

# re: 今天发现自己的array类太慢 2008-04-28 15:35 | 陈梓瀚(vczh)

release只少了1/3，debug对array::operator[]加了太多东西了…… 回复更多评论

收录于