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

韩冰

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

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

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

6 p* ^. W- m( k! I4 k

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

* j# A$ l2 T7 a; R; w

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

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

" R+ p: W8 |8 _ c; Z+ ]0 ^% U! u) L7 k

#include <classes.hpp>

- b+ z2 t! Y2 \7 f L3 q/ H& a

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

) t# v8 W* d- A, B. Z+ f& N( s5 M9 Z

template <class T>

class TTypedList : public TList

; m* H N' Z' q9 j) V f

{

typedef TList inherited;

private:

9 ~7 d3 T, D$ C( @: D, g1 u- g

bool FAutoClear;

TClass FItemClassType;

protected:

T* __fastcall Get(int Index) const

v: P0 ^. i- s. r3 W

{

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

}

5 {7 R7 u/ G! ?! r: s

void __fastcall Put(int Index, T* Item)

{

inherited:ut(Index, Item);

}

public:

2 |" p( r/ [0 m: a O& v/ V

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

7 Q$ m* H" \& ?

public:

4 A9 p8 @/ x: Y) F3 x

__fastcall TTypedList(bool bAutoClear = true)

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

9 e0 H7 b7 C( H

{ }

: C2 e) B" S; h0 C) F

// no destructor needed

int __fastcall Add(T* Item)

/ c u9 f3 Y9 X- n1 e

{

! E3 e! c( y6 K

return inherited::Add(Item);

}

/ {; f' q: \5 Z3 Z3 T& f% h. P# `

int __fastcall AddList(const TTypedList& List)

{

. ~5 w7 n0 U9 N9 @" a6 o

if(this == &List)

{

3 M$ y1 F' ]3 g4 B# p) I

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

2 c9 @& X; t4 h9 i" q

}

if(FItemClassType != List.FItemClassType)

+ k1 `/ u& }5 v

{

% g9 q% g5 l$ @+ s$ Z

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

, l4 i H, y% V% k

Type!");

}

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

' w0 x" u7 P) Q: Q! h( @* y6 a

{

Add(List.Get(i));

3 s, n" v5 T$ Y1 v# N/ L: _& j; D

}

+ y- o/ J( F5 E

return List.Count;

1 B' ~5 j/ S0 Y! u$ }# ?

}

virtual void __fastcall Clear(void)

& g2 A8 x; c# u. g0 y' o2 E' f: x

{

if(FAutoClear)

5 O" G( A( s7 {- ]/ |1 n. t9 R4 ?8 z

{

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

{

delete Get(i);

}

6 E" W2 v" G5 \/ u0 q

}

inherited::Clear();

. T+ V& ?7 e0 V

}

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

{

( ?. d" K$ Y* r f

if(bAutoDelete)

{

delete Get(Index);

}

inherited:elete(Index);

}

T* __fastcall First(void) const

+ e- w" M9 v9 i6 K( |, h

{

- n8 ^( G6 k& Z! Y6 V

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

# |/ S9 X* q9 ?: ]

}

: ^1 K) d R: E. A

int __fastcall IndexOf(T* Item) const

{

% r0 U; Z% t& s

return inherited::IndexOf(Item);

4 c5 f0 i$ f' G

}

/ ~: @% {; i' N

void __fastcall Insert(int Index, T* Item)

{

inherited::Insert(Index, Item);

}

4 c( O ^4 j5 a% B+ t

bool __fastcall IsEmpty(void) const

( [( G3 b, {: R$ U, R

{

7 E' I# D( i7 {% B& z4 f2 G; G

return Count == 0;

}

T* __fastcall Last(void) const

, A8 R$ p6 f% s I4 |

{

return (T*)inherited:ast();

}

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

{

, u8 o2 n; T/ K1 G9 E7 t: u

int nIndex = inherited::Remove(Item);

. e7 B9 }3 W: l' s: }' G

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

{

$ t8 N3 Y4 L5 d' R2 ?. j$ Z; _4 N+ D, p

delete Item;

}

return nIndex;

}

' a5 ?, g+ G: |) Q, |3 ~

void operator<<(T* Item)

{

Add((T *)Item);

$ x5 @ k0 l4 ~

}

0 c. U$ l& T4 l+ J& b# }

void operator<<(const TTypedList& List)

{

AddList(List);

C6 m+ k; g& x7 O2 M

}

}; // end of TTypedList

: L4 {. O) i0 e. v) N [- U, u2 L- n

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

8 s1 P% D6 S$ _

#endif