TTypedList一个类型安全的TList模板类

韩冰

偶在一个老外的文章的基础上写的，应该很有用的说，

以前总是用STL的vector做替代，但是STL的用法实在不是很习惯

//-------------------------------------------------------------------------

0 _+ W! ~8 Y4 [2 L# ~

#ifndef TypedListH_0CBFE2E8-E7C5-4D88-9844-1F177F4B00E4

#define TypedListH_0CBFE2E8-E7C5-4D88-9844-1F177F4B00E4

//-------------------------------------------------------------------------

#include <classes.hpp>

0 _( c: x& f. B0 I

//-------------------------------------------------------------------------

, |8 x1 g6 V) @: n0 a3 k

template <class T>

. U/ X a+ H! u7 u; i( P/ V1 W

class TTypedList : public TList

! l; F( c! K2 H

{

typedef TList inherited;

% K: H; o# ^5 k Q# ]+ p

private:

# w4 _% W2 r! J) w6 K( Q/ u

bool FAutoClear;

TClass FItemClassType;

protected:

T* __fastcall Get(int Index) const

- g) ?; j7 X* l% e0 G5 ^- l! }" Z

{

return (T*)inherited::Get(Index);

}

void __fastcall Put(int Index, T* Item)

6 p6 N0 a; F5 I' S' L1 V$ x3 H+ J

{

) O% j4 E, ~/ h, t N+ C5 B

inherited:ut(Index, Item);

7 x B, U7 ?. @, S0 J

}

public:

__property T* Items[int Index] = {read=Get, write=Put};

. @2 w! f% o5 O2 `

public:

__fastcall TTypedList(bool bAutoClear = true)

: TList(), FAutoClear(bAutoClear), FItemClassType(__classid(T))

{ }

{1 l- M8 J" v+ I5 x9 ~3 D9 w

// no destructor needed

int __fastcall Add(T* Item)

2 P- l: d6 ]3 b# ?0 q* ^3 g+ }( i

{

z+ e; p- d& N- }* T" e" Q" Y

return inherited::Add(Item);

% M" x9 O i4 \( e% r

}

# P B4 v4 E7 h

int __fastcall AddList(const TTypedList& List)

8 t) @% Q+ i1 Z% p5 r/ \4 P

{

if(this == &List)

{

throw EInvalidPointer("Can't add a TTypedList to himself!");

+ W8 i, x# F+ [( z! h( f0 m

}

if(FItemClassType != List.FItemClassType)

{

$ G6 T+ m, { |$ n& F8 o$ t

throw EConvertError("Can't add a TTypedList with a different ItemClass

Type!");

/ ]- F; O2 N }1 q

}

8 ?, x0 _) ^& a5 M

for(int i=0; i<List.Count; i++)

2 ~1 @! t2 g, _5 G( Y/ E

{

: {+ w( G/ S+ m- z8 L

Add(List.Get(i));

}

/ R8 _) K2 }% x `0 U

return List.Count;

}

. M3 u" C! w& A% K O

virtual void __fastcall Clear(void)

: R6 [+ v: _' \* Y

{

7 i0 g, Q% b& z! y: ?2 T: j

if(FAutoClear)

{

, A, p, e4 [' @. F% `

for(int i=0; i<Count; i++)

{

' W' ? d1 K6 @6 o" E+ l; ?. m

delete Get(i);

7 X9 O& q" l# h5 q

}

) r6 |5 x# j" u0 `

}

inherited::Clear();

}

# ]0 f9 k* o+ k1 Z( N) t

void __fastcall Delete(int Index, bool bAutoDelete = true)

{

7 P; ?- n4 K; k* F

if(bAutoDelete)

{

- o' v+ V% i3 i+ T" Z2 M/ u

delete Get(Index);

}

inherited:elete(Index);

}

T* __fastcall First(void) const

& y4 p/ A1 w4 P2 N% g$ V. U

{

return (T*)inherited::First();

5 a O/ b+ k9 d" X# m3 Y& ?

}

int __fastcall IndexOf(T* Item) const

* O# j# Y6 F& a$ J/ ]) Y$ c& O8 s/ D

{

return inherited::IndexOf(Item);

}

- ]& @2 K4 { A- c, c

void __fastcall Insert(int Index, T* Item)

/ w O) e5 W) `& g6 g! n

{

( }% ?% L& a! S$ B2 _

inherited::Insert(Index, Item);

}

% A- ?( k, w8 i& `

bool __fastcall IsEmpty(void) const

{

2 q f: x! ?3 m* }1 S8 ^

return Count == 0;

4 L" b, j% O7 z, i) K

}

T* __fastcall Last(void) const

{

return (T*)inherited:ast();

- y" J& Q3 U9 d+ i- A K

}

int __fastcall Remove(T* Item, bool bAutoDelete = true)

{

int nIndex = inherited::Remove(Item);

if(bAutoDelete && (nIndex != -1))

" _" [8 Z* s3 F$ L, j* {$ Y4 H

{

! A, Z1 j& u; N: ]% O9 {6 N0 \

delete Item;

; i+ r( B0 V8 \$ s* N

}

- y3 ^0 h" `- a2 s) G8 E1 S) M5 O

return nIndex;

6 q: l# B8 W% z$ p, t1 l

}

2 X4 [- j6 V# N2 J7 n. k. z. }

void operator<<(T* Item)

{

Add((T *)Item);

R# Y/ d$ o. s& o# G5 l. ^

}

n: H2 \3 B6 |1 X

void operator<<(const TTypedList& List)

$ [7 t7 }! b! Y/ @, A. A6 C! n& T

{

AddList(List);

}

2 ]& N" Z5 R- D6 n

}; // end of TTypedList

, \, O! B8 v7 D' E+ i5 A# U. o

//-------------------------------------------------------------------------

#endif