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

韩冰

) O7 }# P; A7 _. K# I+ ?

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

$ l0 r) T- c& s m

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

& A" v7 Y; i# Q6 y6 p

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

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

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

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

7 c$ X' ~+ e) e$ H

#include <classes.hpp>

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

: Q) g. { a3 J

template <class T>

& n1 B* d4 D7 S$ ?, `3 t

class TTypedList : public TList

1 L. L0 @$ e" @4 l2 i! R" n

{

" c' d2 \2 n# Z7 L4 c4 G

typedef TList inherited;

0 O" j- J; j& h4 K

private:

' B4 c$ T+ d3 h( u: v+ m5 [

bool FAutoClear;

9 v( ?/ z4 R0 G

TClass FItemClassType;

9 b0 C$ j! P8 y% d) }

protected:

T* __fastcall Get(int Index) const

{

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

}

" X/ P: [$ T6 R. e

void __fastcall Put(int Index, T* Item)

; R$ O9 c; Z% w- s: w

{

' ~! |- u( X- I! _) ]7 [7 r6 Q

inherited:ut(Index, Item);

# ~$ C, E; c5 X/ @& M- L

}

. r, R2 K- K# N$ }

public:

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

public:

, A' s$ ?6 N: ^

__fastcall TTypedList(bool bAutoClear = true)

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

; y# D- D' W4 U) D0 ~

{ }

// no destructor needed

$ p: p) P. W7 C J! _1 K

int __fastcall Add(T* Item)

{

return inherited::Add(Item);

! S1 K- E, U% p \; W% S

}

int __fastcall AddList(const TTypedList& List)

{

if(this == &List)

{

" r. R" K9 E7 o) X) O7 \

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

* c4 |; S1 Y7 x' G5 g9 U" I6 p% P

}

* \/ g( I% t% [( A5 t: i

if(FItemClassType != List.FItemClassType)

" o" `" g0 @: `+ m% p

{

3 x7 B6 q6 l& h9 A5 ^% C5 o; G+ b# ~/ r

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

8 I+ H4 N; l( _7 t- Y7 A0 P

Type!");

}

* Q9 Q- n1 j: F% @& i' Y

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

{

Add(List.Get(i));

}

O2 z6 [$ E3 O3 `

return List.Count;

/ l3 ~9 `2 y3 s/ N8 O: U

}

9 A" T& p( E% [0 Q- l1 y6 m2 W- _

virtual void __fastcall Clear(void)

{

! j6 G4 P% u# T( k

if(FAutoClear)

" U$ z% a* N7 l2 \1 l; \

{

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

{

delete Get(i);

( Y# b5 U% Q$ S9 r, M- E! v

}

}

, w) B4 U$ H# J! B" r) W' A# ]

inherited::Clear();

}

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

{

3 N/ k) _. j$ n' c8 Y. P

if(bAutoDelete)

7 \1 h2 g3 H4 C+ p

{

delete Get(Index);

/ i5 O# ^0 @6 w3 H, F5 ~

}

inherited:elete(Index);

}

) \: r6 M& K6 f3 M0 K3 S

T* __fastcall First(void) const

$ o- |: e& y0 w) Y* Y

{

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

# n+ d2 {0 w. s: b: z; x" l$ T& Y! g

}

int __fastcall IndexOf(T* Item) const

( I" \8 a7 J2 u% T

{

5 l# `( b) B u1 E/ v3 i

return inherited::IndexOf(Item);

}

void __fastcall Insert(int Index, T* Item)

+ a; x$ M' r8 }: r5 @

{

inherited::Insert(Index, Item);

}

/ J4 @$ k f* A; V- X& X* G) n% J

bool __fastcall IsEmpty(void) const

{

3 Q& z. X7 b# m+ V @" V, x

return Count == 0;

}

1 ^ m# o3 K& U7 L( J! S' r1 J) r3 u

T* __fastcall Last(void) const

1 g s4 A j: D& [

{

" D9 I# J5 `3 F% x1 G N

return (T*)inherited:ast();

. q6 f7 i% k7 i

}

+ ]7 K# I3 @! S; Q/ e" _

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

+ n# r+ K* K. O M- S9 O3 K. |1 X

{

int nIndex = inherited::Remove(Item);

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

* K+ m, i6 t4 r C& A l

{

0 d( C2 `9 g2 h: X0 k1 _+ |

delete Item;

0 ~% z, q' ]( b5 Q5 b& U

}

8 H& g) c4 f: `4 P, s- e. {

return nIndex;

' ?- \, {3 Z# i. W% S

}

3 x% m! A. v, N7 i V- _

void operator<<(T* Item)

{

) O w; G& c8 d; @2 ^) o) V

Add((T *)Item);

}

void operator<<(const TTypedList& List)

- C( a, j( j' Y$ G8 z 7 L6 u3 S$ j1 h7 E1 W$ l

{

AddList(List);

4 A0 w. S/ Q. o% a; e

}

$ G3 O7 {" k3 d: G* e* l

}; // end of TTypedList

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

& ?; K) t: q. v! Z2 s* g

#endif