#ifndef REDEFINE_VECTOR_H_
#define REDEFINE_VECTOR_H_
#include"stdafx.h"
#include<memory>
#include<cstring>
#include<fstream>
#include<cstdlib>
template<typename T,typename allocator=std::allocator<T> >
class vector
{
//public:
// typedef T value_type;
// typedef value_type* pointer;
// typedef const value_type const_pointer;
// typedef value_type& reference;
// typedef const value_type& const_reference ;
// typedef std::size_t size_type;
// typedef std::ptrdiff diff_type;
public:
vector();
vector( int num );
vector( resize(int num) );
vector(T* start, T* end );
void assign(int count, T value );
void assign(T* start, T* end );
T& at(int Pos);
const T& at(int Pos) const;
const T& back( )const;
T& back();
int capcity()const;
void clear();
bool empty()const;
T* begin();
T* end();
const T& front()const;
T& front();
void insert( T* pos, const T value );
void insert( T* pos, int count, const T value );
void insert( T* sour, T* first, T* last );
void pop_back( );
void push_back(const T value );
void erase( T* pos );
void erase( T* first , T* last );
~vector();
private:
static std::allocator<T>elem;
T* head;
T* curr;
T* tail;
void unload_handle( );// 转储
const unsigned int resize( int num )const
{ return num; }
void realloc_max(int size );
void realloc_min( int size );
void reallocate();
};
#endif
实现文件//
#include"stdafx.h"
#include"redefine_vector.h"
template<T>vector::vector<T>()
{
T* head=elem.allocate(5);
T* curr=head;
T* tail=head+5;
uninitialized_fill( head, tail, T() );
}
template<T>vector::vector( int num )
{
T* head=elem.allocate(num);
T* curr=head;
T* tail=head+num;
uninitialized_fill( head, tail, T() );
}
template<T>vector::vector( resize(int num) )
{
std::ptrdiff size=tail-head;
if ( num>size )
try
{
realloc_max(num);
}
if ( num<size )
try
{
realloc_min(num);
}
}
template<T>vector::vector(T* start, T* end )
{
std::ptrdiff sur_dis=end-start;
std::ptrdiff des_dis=tail-head;
if ( sur_dis>des_dis )
reallocate();
for ( T* p=curr; p!=head; )
elem.destory( --p );
if ( head )
elem.deallocate( head, tail-head );
for (T* tmp=start; tmp<=end; tmp++ )
{
elem.construct( curr, *tmp);
++curr;
}
}
template<T> void vector::assign(int count, T value )
{
if ( count<=(tail-head) )
{
for ( T* p=curr; p!=head; )
elem.destory( --p );
if ( head )
elem.deallocate( head, tail-head );
uninitialized_fill( head, head+count, value );
}
else
{
realloc_max( count+20 );
uninitialized_fill_n( head, head+10 , value, count );
}
}
template<T> void vector:: assign(T* start, T* end )
{
std::ptrdiff count=end-start;
if ( (end-start)<(tail-head) )
{
for ( T* p=curr; p!=head; )
elem.destory( --p );
if ( head )
elem.deallocate( head, tail-head );
memcpy( head, start, count );//c_memcpy(to ,from, count )
}
if ( (end-start) > (tail-head) )
{
realloc_max( count+20 );
memcpy( head, start, count );
}
}
template<T> T& vector:: at(int Pos)
{
curr=head+pos;
return *curr;
}
template<T>const T& vector:: at(int Pos) const
{
static T* ins_pos=head;
for ( ; ins_pos!=head+pos; ++ins_pos )
;
return *( ins_pos+1);
}
template<T> const T& vector:: back( )const
{
return *curr;
}
template<T> T& vector:: back()
{
return *curr;
}
template<T> int vector:: capcity()const
{
return ( tail-curr );
}
template<T> void vector:: clear()
{
for ( T* p=curr; p!=head; )
elem.destory( --p );
}
template<T> bool vector:: empty()const
{
return ( (curr-head)==0 );
}
template<T> T* vector:: begin()
{
return head;
}
template<T> T* vector:: end()
{
return tail;
}
template<T>const T& vector:: front()const
{
if ( head )
return *head;
}
template<T> T& vector:: front()
{
if (head )
return *head;
}
template<T> void vector:: insert( T* pos, const T value ) // 越界异常
{
std::ptrdiff size=tail-head;
std::ptrdiff dis=pos-head;
if ( pos>tail )
{
cerr<<"Out of range \n ";
exit(EXIT_FAILURE);
}
else
{
memmove(head+dis+1, head+dis, 1 )
for ( T* ins_pos=head; ins_pos<=head+dis; ++ins_pos )
;
elem.construct( ins_pos, value );
}
}
template<T> void vector:: insert( T* pos, int count, const T value )//越界异常
{
std::ptrdiff size=tail-head
std::ptrdiff dis=pos-head;
if ( dis>size )
{
cerr<<"Out of range \n ";
exit(EXIT_FAILURE);
}
else
{
memmove(head+dis+count, head+dis , count );
for ( T* ins_pos=head; ins_pos<=head+dis; ++ins_pos )
;
for ( int vc=0; vc<=count; ++vc )
elem.construct( ins_pos, value );
++ins_pos;
}
}
template<T>void vector:: insert( T* sour, T* first, T* last )// 越界异常
{
std::ptrdiff sur_dis=last-first;
std::ptrdiff des_dis=tail-head;
if ( sur_dis<des_dis )
{
memmove( sour+sur_dis, sour, sur_dis );
for ( T* ins_pos=head; ins_pos<=sour; ++ins_pos )
;
for ( T* ins_value=first; ins_value<=last; ++ins_value )
elem.construct( ins_pos, *ins_value );
++ins_pos;
}
else
{
cerr<<"Out of range \n ";
exit( EXIT_FAILURE);
}
}
template<T> void vector:: pop_back( )
{
if ( emepty() )
{
cerr<<"vector is empty \n ";
return ;
}
else
{
T* pos=curr;
cout<<*pos;
curr--;
elem.destory( pos );
}
}
template<T>void vector:: push_back(const T value )
{
if ( curr=tail )
re_allocate( ) ;
elem.construct( curr, value );
++curr;
}
template<T> void vector:: reserve( int count )
{
realloc_max( count );
}
template<T>void vector:: erase( T* pos )
{
std::ptrdiff position=pos-head;
if ( head+position ==0 )
{
cerr<<"None elements exits "<<endl;
exit(EXIT_FAILURE);
}
else
{
memmove( pos, pos+1, 1);
}
}
template<T>void vector::erase( T* first , T* last )//越界异常
{
if ( first>=head && last<=tail )
{
std::ptrdiff size=last-first;
std::ptrdiff start_dis=first-head;
std::ptrdiff end_dis=last-head;
memmove( head+start_dis, head+end_dis, size );
}
else
{
cerr<<"Out of range \n ";
exit(EXIT_FAILURE);
}
}
template<T> vector::~vector()
{
unload_hand();
if ( head!=tail )
{
for ( T* p=curr; p!=head; )
elem.destory( --p );
deallocate( head, tail-head );
}
}
/private member/
template<typename T >
void vector<T>::unload_handle()
{
ofstream put( "temp.txt", ios::out | ios:: app );
if ( put.is_open()==false )
{
cerr<<"open file failed \n ";
exit(EXIT_FAILURE);
}
else
{
while (; curr!=head ; )
put<<*curr--;
}
put.clear();
put.close();
}
template<T>void vector<T>::realloc_max( int size )
{
std::ptrdiff dis=curr-head;
T* new_mem= elem.allocate( size );
uninitialized_copy( head, curr, new_mem );
for ( T* p=curr; p!=head; )
elem.destory( --p );
if ( head )
elem.deallocate(head, tail-head );
head=new_men;
curr=head+dis;
tail=head+size;
}
template<T>void vector<T>::realloc_min( int size )
{
T* new_mem=elem.allocate(size);
uninitialized_copy( head, head+size, new_mem );
for ( T* p=curr; p!=head; )
elem.destory( --p );
if ( head )
elem.deallocate(head, tail-head );
head=new_mem;
curr=head+size;
tail=head+size;
}
template<T> void vector<T>:: reallocate( )
{
std::ptrdiff size=curr-head;
std::ptrdiff new_size=2*size;
T* new_mem=elem.allocate( new_size )
uninitialized_copy( head, curr, new_mem );
for ( T* p=curr ; p!=head; )
elem.destory( --p );
if ( head );
elem.deallocate( head, tail-head );
head=new_men;
curr=head+size;
tail=head+new_size;
}
catch(std:: bad_alloc& error )
{
unload_hand();
cerr<<"memory allocate error "<<error.what()<<endl;
throw;
}
catch(...){ }
自定义vector容器【未完待续】
最新推荐文章于 2024-04-25 18:30:40 发布