请教一下，在 BCB 中如何使用模板？

[SCUM]

从来没用过模板
麻烦哪位举个简单的例子说明一下

模板类 模板函数 在 BCB 中的使用。。

谢了

[ToIP]

//---------------------------------------------------------------------------
#ifndef arrayH_
#define arrayH_

#include <assert.h>
//---------------------------------------------------------------------------
template <class elemType>
class Array
{
protected:
int xy(){return 0};
public:
explicit Array( int size = DefaultArraySize );
Array( elemType *array, int size );

Array( const Array &rhs );

virtual ~Array(){ delete [] ia; }

bool operator==( const Array& ) const;
bool operator!=( const Array& ) const;

Array& operator=( const Array& );

int size() const { return _size }
virtual elemType operator[]( int index ){ return ia[ index ]; }
virtual int sort();
virtual elemType min() const;
virtual elemType max() const;
virtual int find(const elemType &value) const;
private:
int init( elemType *rhs, int size );
static const int DefaultArraySize = 12;
int _size;
elemType *ia;
};

template< class elemType >
inline
int
Array< elemType >::
init( elemType *array, int size )
{
_size = size;
ia = new elemType[ _size ];

for( int ix=0; ix<_size; ix++ )
{
if( array!=0 )
ia[ ix ] = array[ ix ];
else
ia[ ix ] = ia[ 0 ];
}
return 0;
}

template< class elemType >
Array< elemType >::
Array( int size)
{
init( 0, size );
}

template< class elemType >
Array< elemType >::
Array( elemType *array, int size )
{
init( array, size );
}

template< class elemType >
Array< elemType >::
Array( const Array &rhs )
{
init( rhs.ia, rhs._size );
}

template< class elemType >
bool
Array< elemType >::
operator==( const Array< elemType > &rhs ) const
{
if( _size != rhs._size )
return false;
else
for( int ix=0; ix<_size; ix++ )
{
if( ia[ ix ]!=rhs.ia[ ix ] )
return false;
}

return true;
}

template< class elemType >
bool
Array< elemType >::
operator!=( const Array< elemType > &rhs ) const
{
if( _size != rhs._size )
return true;
else
for( int ix=0; ix<_size; ix++ )
{
if( ia[ ix ]!=rhs.ia[ ix ] )
return true;
}

return false;
}

template< class elemType >
Array< elemType >&
Array< elemType >::
operator=( const Array &rhs )
{
delete [] ia;

_size = rhs._size;
ia = new elemType[ _size ];

for( int ix=0; ix<_size; ix++ )
{
ia[ ix ] = rhs.ia[ ix ];
}

return *this;
}

template< class elemType >
int
Array< elemType >::
sort()
{
return 0;
}

template< class elemType >
elemType
Array< elemType >::
min() const
{
return ia[ 0 ];
}

template< class elemType >
elemType
Array< elemType >::
max() const
{
return ia[ 0 ];
}

template< class elemType >
int
Array< elemType >::
find(const elemType &value) const
{
return 0;
}

#endif

只写了个空架子，函数的内容没有写，呵呵

[constantine]

up

[SCUM]

浅显易懂 真是个好例子。。。
谢谢 ToIP(朽木)！