vector在可用空间不足,进行某些插入操作的时候就会重新分配空间,然后再进行一系列的拷贝工作,如果对象比较大,那么拷贝起来是非常缓慢的。有没有办法提高拷贝时的速度呢。办法是有的。那就是以空间换取时间。vector只存取大对象的指针。指针的大小是固定的,比较小的。这样就能提高拷贝的速度。当然如果是小对象也那么干,速度不但不会提升,反到会下降。白白多了一些内存分配动作。下面是一个实现:
#ifndef FASHLISH_H
#define FASHLISH_H
#include<vector>
namespace lytool
{
using namespace std;
struct __fastlist_iterator_base
{
typedef size_t size_type;
typedef ptrdiff_t difference_type;
typedef random_access_iterator_tag iterator_category;
};
template<typename T, typename Ref, typename Ptr>
struct __fastlist_iterator: public __fastlist_iterator_base
{
typedef __fastlist_iterator<T, T&, T*> iterator;
typedef __fastlist_iterator<T, const T&, const T*> const_iterator;
typedef __fastlist_iterator<T, Ref, Ptr> self;
typedef T value_type;
typedef Ptr pointer;
typedef Ref reference;
typename vector<T*>::iterator node;
__fastlist_iterator(){}
__fastlist_iterator(typename vector<T*>::iterator iter)
{ node = iter; }
__fastlist_iterator(const self& other)
{ node = other.node; }
reference operator* () const { return **node; }
pointer operator-> () const { return &(operator*()); }
self& operator= (const self& other)
{
if( this == &other)
return *this;
node = other.node;
return *this;
}
self& operator++ ()
{
++node;
return *this;
}
self operator++ (int)
{
self temp = *this;
++node;
return temp;
}
self& operator-- ()
{
--node;
return *this;
}
self operator-- (int)
{
self temp = *this;
--node;
return temp;
}
self operator+= (int n)
{
node + = n;
return *this
}
self operator-= (int n)
{
return operator+= (-n);
}
self operator+ (int n)
{
return operator+= (n);
}
self operator- (int n)
{
return operator-= (n);
}
bool operator== (const self& other)
{
return (node == other.node);
}
bool operator!= (const self& other)
{
return !(operator== (other));
}
};
template<typename T>
class fastlist
{
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 size_t size_type;
typedef ptrdiff_t difference_type;
typedef __fastlist_iterator<T, T&, T*> iterator;
typedef __fastlist_iterator<T, const T&, const T*> const_iterator;
private:
vector<T*> data;
private:
pointer construct()
{
return new T;
}
pointer construct(const T& other)
{
return new T(other);
}
void destruct(T* p)
{
delete p;
}
public:
iterator begin()
{
return iterator(data.begin());
}
iterator end()
{
return iterator(data.end());
}
size_type size()
{
return data.size();
}
bool empty()
{
return data.empty();
}
reference front()
{
return *begin();
}
reference back()
{
return *( end() - 1 );
}
void insert(const T& other,iterator iter)
{
pointer p = construct(other);
data.insert(iter.node, p);
}
void push_back(const T& other)
{
pointer p = construct(other);
data.push_back(p);
}
void push_front(const T& other)
{
insert(other, begin());
}
void pop_back(const iterator& iter)
{
data.pop_back(*(iter.node));
}
void pop_front(const iterator& iter)
{
data.pop_front(*(iter.node));
}
void erase(iterator iter)
{
destruct(*(iter.node));
}
void clear()
{
iterator iter = begin();
iterator iterend = end();
for(;iter != iterend; ++iter)
{
destruct(*(iter.node));
}
data.clear();
}
fastlist()
{
}
fastlist(const fastlist& other)
{
data = other.data;
}
~fastlist()
{
clear();
}
};
}
#endif
上面的Fastlist容器的优点是针对大对象而言,插入和遍历速度都快于
vector,遍历速度当然更是远快于list(名字的由来)
此外,提供了符合c++标准的迭代器,可以使用的一些C++中的一些算法。但由于这个迭代器还没有完工,有的方法还没有实现,所以有些算法还不能使用。