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

韩冰

9 j# A2 k& x% \: p

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

/ I) P- j/ V6 w, O1 T1 _

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

1 {, A8 Z( _' I! i

) t `9 F& l/ F0 I& }

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

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

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

+ Z4 i( k) B V2 G9 x) a- M

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

/ A- R8 O' I! g% h

#include <classes.hpp>

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

8 ]5 i1 k. Q0 z7 d+ [

template <class T>

2 W2 a6 u" {. t9 \

class TTypedList : public TList

; y! e, m% |+ ^. P5 `

{

4 A- o1 e, S8 I, J. n r5 n/ s+ i

typedef TList inherited;

1 ~0 G1 n" Z1 `8 n) h

private:

bool FAutoClear;

TClass FItemClassType;

- ]- F9 X8 s; A" Q6 F

protected:

T* __fastcall Get(int Index) const

{

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

}

void __fastcall Put(int Index, T* Item)

- e' j9 ]9 N/ O" A+ Q/ ]( m. P* H

{

inherited:ut(Index, Item);

/ ]' c0 }# [: R8 W/ s$ F h

}

public:

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

. g6 V6 e5 n2 Z8 J# U

public:

W. ]# z0 Q+ c7 ?5 |$ q; F

__fastcall TTypedList(bool bAutoClear = true)

# X& F+ ~9 K! |% G: G* Q; |

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

{ }

* @' E: Q, T1 |

// no destructor needed

int __fastcall Add(T* Item)

' B! V, y0 f' H5 n' q3 [

{

return inherited::Add(Item);

}

int __fastcall AddList(const TTypedList& List)

{

if(this == &List)

{

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

1 T2 r/ ~' K- O8 j

}

if(FItemClassType != List.FItemClassType)

{

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

, V$ z+ `! S/ \0 f$ d

Type!");

}

7 g$ W0 _" `8 o

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

{

Add(List.Get(i));

}

return List.Count;

P5 r9 ~ z5 _2 z v* Y

}

virtual void __fastcall Clear(void)

{

if(FAutoClear)

5 Y7 |" ]' \% ~+ y' ]+ ]+ i: o- q9 L

{

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

3 W4 f. c! X' R- d! H! I

{

# A. W! c; {3 n+ K

delete Get(i);

. {9 }2 b3 h5 C' v/ J9 s' ?. P

}

}

inherited::Clear();

0 Y a! p6 C1 z

}

* L- V' @9 O) u: F7 m

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

{

) K/ V+ V9 n8 c- I% L

if(bAutoDelete)

{

delete Get(Index);

2 W$ w0 e P( O% q5 ~0 N: e

}

inherited:elete(Index);

}

T* __fastcall First(void) const

{

; R8 A. G6 t- G; e# Z

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

}

int __fastcall IndexOf(T* Item) const

{

return inherited::IndexOf(Item);

, L, O- j9 U7 k! s0 s2 G

}

void __fastcall Insert(int Index, T* Item)

4 O8 b& K! D2 n$ g

{

! y+ G* h/ U1 k# f3 X* }

inherited::Insert(Index, Item);

! o( [6 z. f& y3 w1 j# q4 {3 m

}

0 d! |" F; ?3 b$ V- M' M* m% w& X

bool __fastcall IsEmpty(void) const

# D; m$ r2 Y* r

{

( M" E4 ~/ t- h. {, H. z' p; C

return Count == 0;

}

T* __fastcall Last(void) const

) r7 S* v `& K; b$ D4 h2 P

{

8 u1 m7 _$ G5 Y2 V4 U

return (T*)inherited:ast();

}

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

2 x/ f5 z5 v$ c/ k& V7 ?

{

3 D# N% d8 J% E& f" H0 H$ w1 [

int nIndex = inherited::Remove(Item);

- y+ m2 E$ u- {. C/ {

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

- q) [& V. l0 [! x9 W2 U7 M

{

) E" v+ r6 J1 v5 j$ z1 G

delete Item;

}

return nIndex;

}

4 V4 }6 J4 C. k5 x* G

void operator<<(T* Item)

{

Add((T *)Item);

}

void operator<<(const TTypedList& List)

4 _5 k" w8 }6 J- t5 _4 U4 N

{

AddList(List);

5 P! s& s9 ^" M) R

}

}; // end of TTypedList

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

#endif