📄 vectimp.h
字号:
{
if( cur >= upper )
return (*vect)[upper-1];
else
return (*vect)[cur++];
}
T operator ++ ()
{
if( cur < upper )
cur++;
if( cur >= upper )
return (*vect)[upper-1];
else
return (*vect)[cur];
}
void restart()
{
restart(lower,upper);
}
void restart( unsigned start, unsigned stop )
{
cur = lower = start;
upper = stop;
}
private:
const BI_VectorImp<T> _FAR *vect;
unsigned cur;
unsigned lower, upper;
};
/*------------------------------------------------------------------------*/
/* */
/* template <class T, class Vect> class BI_InternalIVectorImp */
/* */
/* Implements a vector of pointers to objects of type T. */
/* This is implemented through the form of BI_VectorImp specified by */
/* Vect. Since pointers always have meaningful copy semantics, */
/* this class can handle any type of object. */
/* */
/*------------------------------------------------------------------------*/
template <class T, class Vect> class _CLASSTYPE BI_InternalIVectorImp :
public Vect
{
public:
BI_InternalIVectorImp( unsigned sz, unsigned d = 0 ) :
Vect( sz, d )
{
zero( 0, sz );
}
~BI_InternalIVectorImp()
{
flush();
}
T _FAR * _FAR & operator [] ( unsigned index )
{
PRECONDITION( lim == 0 || data != 0 && index < lim );
return (T _FAR *)(data[index]);
}
T _FAR * _FAR & operator [] ( unsigned index ) const
{
PRECONDITION( lim > 0 && data != 0 && index < lim );
return (T _FAR *)(data[index]);
}
void flush( unsigned = 0, unsigned = UINT_MAX, unsigned = 0 );
void forEach( void (_FAR *f)(T _FAR &, void _FAR *), void _FAR *args )
{
forEach( f, args, 0, lim );
}
void forEach( void (_FAR *)(T _FAR &, void _FAR *),
void _FAR *,
unsigned,
unsigned
);
T _FAR *firstThat( int (_FAR *cond)(const T _FAR &, void _FAR *),
void _FAR *args
) const
{
return firstThat( cond, args, 0, lim );
}
T _FAR *firstThat( int (_FAR *)(const T _FAR &, void _FAR *),
void _FAR *,
unsigned,
unsigned
) const;
T _FAR *lastThat( int (_FAR *cond)(const T _FAR &, void _FAR *),
void _FAR *args
) const
{
return lastThat( cond, args, 0, lim );
}
T _FAR *lastThat( int (_FAR *)(const T _FAR &, void _FAR *),
void _FAR *,
unsigned,
unsigned
) const;
virtual void zero( unsigned, unsigned );
private:
static void delObj( T _FAR &, void _FAR * );
};
template <class T, class Vect>
void BI_InternalIVectorImp<T,Vect>::delObj( T _FAR &tRef, void _FAR * )
{
delete &tRef;
}
template <class T, class Vect>
void BI_InternalIVectorImp<T,Vect>::flush(
unsigned del,
unsigned upr,
unsigned lwr
)
{
upr = min( upr, limit() );
Vect::flush( del, upr, lwr );
if( del )
forEach( delObj, 0, lwr, upr );
zero( lwr, upr );
}
template <class T, class Vect>
void BI_InternalIVectorImp<T,Vect>::forEach( void (_FAR *f)( T _FAR &, void _FAR * ),
void _FAR *args,
unsigned start,
unsigned stop
)
{
for( unsigned cur = start; cur < stop; cur++ )
if( data[cur] != 0 )
f( *(T _FAR *)(data[cur]), args );
}
template <class T, class Vect>
T _FAR *BI_InternalIVectorImp<T,Vect>::firstThat( int (_FAR *cond)( const T _FAR &, void _FAR * ),
void _FAR *args,
unsigned start,
unsigned stop
) const
{
for( unsigned cur = start; cur < stop; cur++ )
if( data[cur] != 0 && cond( *(T _FAR *)(data[cur]), args ) != 0 )
return (T _FAR *)data[cur];
return 0;
}
template <class T, class Vect>
T _FAR *BI_InternalIVectorImp<T,Vect>::lastThat( int (_FAR *cond)( const T _FAR &, void _FAR * ),
void _FAR *args,
unsigned start,
unsigned stop
) const
{
T _FAR *res = 0;
for( unsigned cur = start; cur < stop; cur++ )
if( data[cur] != 0 && cond( *(T _FAR *)(data[cur]), args ) != 0 )
res = (T _FAR *)data[cur];
return res;
}
template <class T, class Vect>
void BI_InternalIVectorImp<T,Vect>::zero( unsigned lwr, unsigned upr )
{
for( unsigned i = lwr; i < min( limit(), upr ); i++ )
data[i] = 0;
}
/*------------------------------------------------------------------------*/
/* */
/* template <class T, class Vect> class BI_InternalICVectorImp */
/* */
/* Implements a counted vector of pointers to objects of type T. */
/* This is implemented through the form of BI_VectorImp specified by */
/* Vect. Since pointers always have meaningful copy semantics, */
/* this class can handle any type of object. */
/* */
/*------------------------------------------------------------------------*/
template <class T, class Vect> class _CLASSTYPE BI_InternalICVectorImp :
public BI_InternalIVectorImp<T,Vect>
{
public:
BI_InternalICVectorImp( unsigned sz, unsigned d = 0 ) :
BI_InternalIVectorImp<T,Vect>( sz, d )
{
}
void add( T _FAR *t );
unsigned find( T _FAR *t ) const
{
PRECONDITION( t->isSortable() );
return find( (void _FAR *)t );
}
protected:
virtual unsigned find( void _FAR * ) const = 0;
private:
virtual void removeData( void _FAR *t )
{
delete (T _FAR *)t;
}
};
template <class T, class Vect>
void BI_InternalICVectorImp<T,Vect>::add( T _FAR *t )
{
while( count_ < limit() && (*this)[count_] != 0 )
count_++;
Vect::add(t);
}
/*------------------------------------------------------------------------*/
/* */
/* template <class T, class Vect> class BI_InternalISVectorImp */
/* */
/* Implements a counted vector of pointers to objects of type T. */
/* This is implemented through the form of BI_VectorImp specified by */
/* Vect. Since pointers always have meaningful copy semantics, */
/* this class can handle any type of object. */
/* */
/*------------------------------------------------------------------------*/
template <class T, class Vect> class _CLASSTYPE BI_InternalISVectorImp :
public BI_InternalICVectorImp<T,Vect>
{
public:
BI_InternalISVectorImp( unsigned sz, unsigned d = 0 ) :
BI_InternalICVectorImp<T,Vect>( sz, d )
{
}
void add( T _FAR *t );
unsigned find( T _FAR *t ) const
{
return BI_InternalICVectorImp<T,Vect>::find( (void _FAR *)t );
}
protected:
virtual unsigned find( void _FAR * ) const = 0;
};
template <class T, class Vect>
void BI_InternalISVectorImp<T,Vect>::add( T _FAR *t )
{
unsigned loc = count_++;
if( count_ > lim )
resize( count_ );
while( loc > 0 && *t < *(T _FAR *)(*this)[loc-1] )
{
(*this)[loc] = (*this)[loc-1];
loc--;
}
(*this)[loc] = t;
}
/*------------------------------------------------------------------------*/
/* */
/* template <class T> class BI_IVectorImp */
/* */
/* Implements a vector of pointers to objects of type T. */
/* This is implemented through the template BI_InternalIVectorImp. */
/* Since pointers always have meaningful copy semantics, this class */
/* can handle any type of object. */
/* */
/*------------------------------------------------------------------------*/
template <class T> class _CLASSTYPE BI_IVectorImp :
public BI_InternalIVectorImp<T, BI_VectorImp<void _FAR *> >
{
public:
BI_IVectorImp( unsigned sz ) :
BI_InternalIVectorImp<T, BI_VectorImp<void _FAR *> >(sz)
{
}
};
/*------------------------------------------------------------------------*/
/* */
/* template <class T> class BI_ICVectorImp */
/* */
/* Implements a counted vector of pointers to objects of type T. */
/* This is implemented through the template BI_InternalICVectorImp. */
/* Since pointers always have meaningful copy semantics, this class */
/* can handle any type of object. */
/* */
/*------------------------------------------------------------------------*/
template <class T> class _CLASSTYPE BI_ICVectorImp :
public BI_InternalICVectorImp<T, BI_CVectorImp<void _FAR *> >
{
public:
BI_ICVectorImp( unsigned sz, unsigned d = 0 ) :
BI_InternalICVectorImp<T, BI_CVectorImp<void _FAR *> >(sz)
{
delta = d;
}
unsigned find( T _FAR *t ) const
{
return find( (void _FAR *)t );
}
protected:
virtual unsigned find( void _FAR * ) const;
};
template <class T> unsigned BI_ICVectorImp<T>::find( void _FAR *t ) const
{
if( limit() != 0 )
{
for( unsigned loc = 0; loc < limit(); loc++ )
if( data[loc] &&
*(const T _FAR *)(data[loc]) == *(const T _FAR *)t
)
return loc;
}
return UINT_MAX;
}
/*------------------------------------------------------------------------*/
/* */
/* template <class T> class BI_ISVectorImp */
/* */
/* Implements a sorted vector of pointers to objects of type T. */
/* This is implemented through the template BI_InternalICVectorImp. */
/* Since pointers always have meaningful copy semantics, this class */
/* can handle any type of object. */
/* */
/*------------------------------------------------------------------------*/
template <class T> class _CLASSTYPE BI_ISVectorImp :
public BI_InternalICVectorImp<T, BI_SVectorImp<void _FAR *> >
{
public:
BI_ISVectorImp( unsigned sz, unsigned d = 0 ) :
BI_InternalICVectorImp<T, BI_SVectorImp<void _FAR *> >(sz)
{
delta = d;
}
unsigned find( T _FAR *t ) const
{
return find( (void _FAR *)t );
}
protected:
virtual unsigned find( void _FAR * ) const;
};
template <class T> unsigned BI_ISVectorImp<T>::find( void _FAR *t ) const
{
unsigned lower = 0;
unsigned upper = count_-1;
if( count_ != 0 )
{
while( lower < upper )
{
unsigned middle = (lower+upper)/2;
if( *(const T _FAR *)(data[middle]) == *(const T _FAR *)t )
return middle;
if( *(const T _FAR *)(data[middle]) < *(const T _FAR *)t )
lower = middle+1;
else
upper = middle-1;
}
}
if( lower == upper && *(const T _FAR*)(data[lower]) == *(const T _FAR*)t )
return lower;
else
return UINT_MAX;
}
/*------------------------------------------------------------------------*/
/* */
/* template <class T> class BI_IVectorIteratorImp */
/* */
/* Implements a vector iterator. This iterator works with any indirect */
/* vector. For direct vectors, see BI_VectorIteratorImp. */
/* */
/*------------------------------------------------------------------------*/
template <class T> class _CLASSTYPE BI_IVectorIteratorImp :
public BI_VectorIteratorImp<void _FAR *>
{
public:
BI_IVectorIteratorImp( const BI_VectorImp<void _FAR *> _FAR &v ) :
BI_VectorIteratorImp<void _FAR *>(v)
{
bump();
}
BI_IVectorIteratorImp( const BI_VectorImp<void _FAR *> _FAR &v,
unsigned l, unsigned u
) :
BI_VectorIteratorImp<void _FAR *>(v,l,u)
{
bump();
}
T _FAR *current()
{
return (T _FAR *)BI_VectorIteratorImp<void _FAR *>::current();
}
T _FAR *operator ++ ( int );
T _FAR *operator ++ ();
void restart()
{
BI_VectorIteratorImp<void _FAR *>::restart();
bump();
}
void restart( unsigned start, unsigned stop )
{
BI_VectorIteratorImp<void _FAR *>::restart( start, stop );
bump();
}
private:
void bump();
};
template <class T> T _FAR * BI_IVectorIteratorImp<T>::operator ++ ()
{
BI_VectorIteratorImp<void _FAR *>::operator++();
bump();
return (T _FAR *)current();
}
template <class T> T _FAR * BI_IVectorIteratorImp<T>::operator ++ ( int )
{
void *temp = current();
BI_VectorIteratorImp<void _FAR *>::operator++(1);
bump();
return (T _FAR *)temp;
}
template <class T> void BI_IVectorIteratorImp<T>::bump()
{
while( *this != 0 && current() == 0 )
BI_VectorIteratorImp<void _FAR *>::operator++();
}
#endif // __VECTIMP_H
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -