c语言线性表存储插入删除,线性表的建立,插入和删除

该楼层疑似违规已被系统折叠 隐藏此楼查看此楼

{

return reverse_iterator(end());

}

template 

typename Vector::const_reverse_iterator

Vector::rbegin() const

{

return const_reverse_iterator(end());

}

template 

typename Vector::reverse_iterator

Vector::rend()

{

return reverse_iterator(begin());

}

template 

typename Vector::const_reverse_iterator

Vector::rend() const

{

return const_reverse_iterator(begin());

}

template 

void

Vector::resize(size_type n)

{

if (n <= c_ca)

{

erase(begin() + n, end());

return;

}

reserve(n);

std::uninitialized_fill(end(), begin() + n, T());

finish = begin() + n;

}

template 

void

Vector::resize(size_type n, T x)

{

if (n <= c_ca)

{

erase(begin() + n, end());

return;

}

reserve(n);

std::uninitialized_fill(end(), begin() + n, x);

finish = begin() + n;

}

template 

typename Vector::size_type

Vector::size() const

{

return end() - begin();

}

template 

typename Vector::size_type

Vector::max_size() const

{

return c_al.max_size();

}

template 

bool

Vector::empty() const

{

return end() == begin();

}

template 

A

Vector::get_allocator() const

{

return c_al;

}

template 

typename Vector::reference

Vector::operator[](size_type pos)

{

return begin[pos];

}

template 

typename Vector::const_reference

Vector::operator[](size_type pos) const

{

return begin[pos];

}

template 

typename Vector::reference

Vector::front()

{

return *begin();

}

template 

typename Vector::const_reference

Vector::front() const

{

return *begin();

}

template 

typename Vector::reference

Vector::back()

{

return *(end() - 1);

}

template 

typename Vector::const_reference

Vector::back() const

{

return *(end() - 1);

}

template 

void

Vector::push_back(const T &x)

{

if (size() == capacity())

reserve(c_ca <<= 1);

c_al.construct(finish++, x);

}

template 

void

Vector::pop_back()

{

c_al.destroy(--finish);

}

template 

template 

void

Vector::assign(InIt first, InIt last)

{

reserve(distance(first, last));

clear();

finish = uninitialized_copy(first, last, begin());

}

template 

void

Vector::assign(size_type n, const T &x)

{

reserve(n);

clear();

finish = uninitialized_fill_n(begin(), n, x);

}

template 

typename Vector::iterator

Vector::insert(iterator it, const T &x)

{

reserve(size() + 1);

std::copy_backward(it - 1, end() - 1, finish + 1);

c_al.destroy(it);

c_al.construct(it++, x);

return it;

}

template 

void

Vector::insert(iterator it, size_type n, const T &x)

{

reserve(size() + n);

std::copy_backward(it - 1, end() - 1, finish + n);

c_al.destroy(it, it + n);

std::uninitialized_fill_n(it, n, x);

finish = finish + n;

return it;

}

template 

template 

void

Vector::insert(iterator it, InIt first, InIt last)

{

size_type n;

reserve(size() + (n = distance(first, last)));

std::copy_backward(it - 1, end() - 1, finish + n);

c_al.destroy(it, it + n);

std::uninitialized_copy(first, last ,it);

return it;

}

template 

typename Vector::iterator

Vector::erase(iterator it)

{

c_al.destroy(it);

copy(it + 1, end(), it);

--finish;

return it;

}

template 

typename Vector::iterator

Vector::erase(iterator first, iterator last)

{

while (first 

{

erase(first);

--last;

}

return first;

}

template 

void

Vector::clear()

{

while (!empty())

pop_back();

}

template 

void

Vector::swap(Vector &x)

{

std::swap(c_al, x.c_al);

std::swap(c_ca, x.c_ca);

std::swap(start, x.start);

std::swap(finish, x.finish);

}

//destructor:

template 

Vector::~Vector()

{

for (iterator tmp = begin(), tmp 

c_al.deallocate(start, c_ca);

}

#endif

不过可移植性忘记了，好久以前写的了