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

韩冰

& i7 v9 w0 G& |" I, I0 \* N

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

6 T/ {* s( N' m4 z# B* M E8 }

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

( T6 s* ^/ c8 i0 o: G

# A6 Q7 a+ f3 ~& _, a3 ?3 H6 U

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

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

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

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

#include <classes.hpp>

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

- |: L( l. A5 G1 m: c' n+ { A

template <class T>

; o; {1 }9 U% ~! y% P$ ~- a# Q

class TTypedList : public TList

/ k) i. k" C9 y) ^, |; n

{

8 d8 \5 y5 q/ c

typedef TList inherited;

private:

bool FAutoClear;

TClass FItemClassType;

) W( w. }, u2 S

protected:

' F& z7 L# D, @! S9 P

T* __fastcall Get(int Index) const

{

8 i/ B3 r& {. D+ H8 Y

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

}

void __fastcall Put(int Index, T* Item)

8 T4 D. E$ t1 N- ^! j

{

inherited:ut(Index, Item);

/ T2 [% {# ?: a9 C7 N* O

}

public:

$ }- l- P5 W: B2 D' n

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

public:

' p2 Q5 k% Z0 ^. l

__fastcall TTypedList(bool bAutoClear = true)

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

{ }

// no destructor needed

int __fastcall Add(T* Item)

{

return inherited::Add(Item);

}

int __fastcall AddList(const TTypedList& List)

' O8 G* a; x' ~# n- g4 k( z; R2 ^+ W

{

. \. U# t/ `* R- f

if(this == &List)

{

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

7 R2 g/ n! k4 N1 I! l

}

if(FItemClassType != List.FItemClassType)

' d2 Q3 X) K @

{

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

Type!");

' H) S6 E. A) j' w

}

7 D) J; o( k6 D4 x6 P+ d9 s- G

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

{

Add(List.Get(i));

1 h: y2 g8 u# _$ }# v5 R8 c

}

; _9 Q2 k+ ]& e7 G/ q4 w$ q

return List.Count;

4 r; F8 h1 g$ k- P- h

}

virtual void __fastcall Clear(void)

{

if(FAutoClear)

2 r$ `6 j8 |- U* [; T3 ~' E

{

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

{

( M m6 X) o: y3 \- W

delete Get(i);

# r3 B* Z- K2 M# U+ A+ Q

}

$ v. k% \4 u' |. x% G

}

1 P4 F, G0 Y2 Y4 Z \" v* u

inherited::Clear();

}

8 j H4 u/ K: m% q

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

* i) P. A# h% x& k, P

{

if(bAutoDelete)

7 ^* } ?0 S8 ?! E7 x# i

{

' `. k; F3 R! v" }0 _6 M

delete Get(Index);

}

inherited:elete(Index);

- D W( b4 j& f( U# r# T

}

T* __fastcall First(void) const

{

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

- z @3 \7 F7 P0 N% [- Q% u* g

}

* Q6 _) ~# q3 E& c

int __fastcall IndexOf(T* Item) const

{

% k; D Y' W6 ^; l9 g" S8 W

return inherited::IndexOf(Item);

}

. w( n, A( U% L5 w

void __fastcall Insert(int Index, T* Item)

{

5 {' E; O! W' ]% O1 Q

inherited::Insert(Index, Item);

}

bool __fastcall IsEmpty(void) const

9 F1 Y2 c: X1 n! q3 S. W7 ~

{

return Count == 0;

2 X2 d+ @# c5 ~. |, H' u* e

}

T* __fastcall Last(void) const

{

1 `) F0 z% g& d v

return (T*)inherited:ast();

}

, L7 ]3 Z7 Z; t5 G

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

) H4 z. o& k1 a6 M+ O

{

int nIndex = inherited::Remove(Item);

$ B( Z5 I! c) Y8 y% t

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

+ q) q8 d2 t: O3 M6 M

{

delete Item;

0 K* B5 D+ Y; w% ~ d9 N: @

}

return nIndex;

}

! p! R! L* R8 W8 A

void operator<<(T* Item)

3 ?3 G: J( j2 O& I; w$ S. f- Q

{

5 z4 |% j4 c! E) ]# b

Add((T *)Item);

7 g. i. j, V. S

}

3 R6 m k W) K+ g6 M+ s! I q+ @

void operator<<(const TTypedList& List)

* A7 S/ ]( S7 p( U9 ]

{

AddList(List);

}

}; // end of TTypedList

# K. F5 ?# L6 f7 P+ M7 E

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

#endif