構(gòu)造函數(shù)：
template<typename T>
Vector<T>::Vector(unsigned n, T const& t)
: elem_(0), size_(n), cpct_(n)
{
if(n > 0) {
elem_ = (T*)::malloc(n*sizeof(T));
std::uninitialized_fill(elem_, elem_ + n, t);
}
}
std::uninitialized_fill 為標(biāo)準(zhǔn)模板庫(kù)STL中的算法，它將未初始化的內(nèi)存填充一個(gè)固定的值；
拷貝構(gòu)造函數(shù)
創(chuàng)建一個(gè)內(nèi)容和me相同的向量；
template<typename T>
Vector<T>::Vector(Vector const& me)
: elem_(0), size_(me.size()), cpct_(me.size())
{
if(size_ > 0) {
elem_ = (T*)::malloc(size_*sizeof(T));
::memcpy(elem_, me.elem_, size_*sizeof(T));
}
}
重載賦值運(yùn)算符；
template<typename T>
Vector<T>& Vector<T>::operator=(Vector const& rhs)
{
reserve(size_ = rhs.size());
::memcpy(elem_, rhs.elem_, size_*sizeof(T));
return *this;
}
reserve函數(shù)保證自身至少容納一定量的元素，賦值運(yùn)算符返回對(duì)自身的引用；
析構(gòu)函數(shù)：
template<typename T>
Vector<T>::~Vector(void)
{
::free(elem_);
}
清空函數(shù)：
template<typename T>
void Vector<T>::clear(void)
{
size_ = 0;
}
獲取向量的成員：
template<typename T>
T& Vector<T>::front(void)
{
return elem_[0];
}
template<typename T>
T& Vector<T>::back(void)
{
return elem_[size_ - 1];
}
template<typename T>
T& Vector<T>::operator[ ](unsigned n)
{
return elem_[n];
}
向量迭代子定義：
template<typename T>
struct Vector {
typedef T* Iterator;
};
begin，end函數(shù)的實(shí)現(xiàn)：
template<typename T>
typename Vector<T>::Iterator Vector<T>::begin(void)
{
return elem_;
}
template<typename T>
typename Vector<T>::Iterator Vector<T>::end(void)
{
return elem_ + size_;
}
///////////////////////////////////////////////
template<typename T>
T* Vector<T>::begin(void)
{
return elem_;
}
template<typename T>
T* Vector<T>::end(void)
{
return elem_ + size_;
}
向量元素的刪除：
刪除最后元素不需移動(dòng)任何元素，復(fù)雜度為θ(1)
template<typename T>
void Vector<T>::pop_back(void)
{
--size_;
}
將后面所有元素向前移動(dòng)一位將其覆蓋，復(fù)雜度為θ(n)
template<typename T>
void Vector<T>::erase(Iterator p)
{
::memmove(p, p + 1, sizeof(T)*(elem_ + --size_ - p));
}
向量?jī)?nèi)存管理策略：
reserve(n)保證向量的容量大于等于n
template<typename T>
void Vector<T>::reserve(unsigned n)
{
if(cpct_ < n) {
elem_ = (T*)::realloc(elem_, n*sizeof(T));
std::uninitialized_fill(elem_ + cpct_, elem_ + n, T());
cpct_ = n;
}
}
判滿(mǎn)函數(shù)：
full()
template<typename T>
bool Vector<T>::full(void) const
{
return size_ == cpct_;
}
添加函數(shù)：
在p之前添加v
template<typename T>
void Vector<T>::insert(T* p, T const& v)
{
if(full())
{
int const offset = p - elem_;
reserve(next_capacity());
p = elem_ + offset;
}
::memmove(p + 1, p, sizeof(T)*(elem_ + size_++ - p) );
*p = v;
}
resize函數(shù)：
將元素個(gè)數(shù)強(qiáng)制設(shè)置為n
template<typename T>
void Vector<T>::resize(unsigned ns)
{
reserve(ns);
size_ = ns;
}
交換內(nèi)容函數(shù)：
template<typename T>
void swap(T& a, T& b)
{
T temp = a;
a = b;
b = temp;
}
交換兩向量?jī)?nèi)容：
template<typename T>
void swap(Vector<T>& a, Vector<T>& b)
{
std::swap(a.elem_, b.elem_);
std::swap(a.size_, b.size_);
std::swap(a.cpct_, b.cpct_);
}
std::swap 是TSL中的算法；
