#include "stdlib.h"#
include "stdio.h"
#include "string"#
include "iostream"using namespace std;template
class sq_List{ public: sq_List(int c,int l){cap = c;len = l;} //构造函数,初始化表长度和空间容量 void creat_List(); //创建空的顺序表 T check_List(); //检测顺序表的状态 void input_List(); //输入顺序表的元素 T *insert_List(int pos,int num); //插入元素 T *delete_List(int pos);//删除元素 void show_List(); //输出新表 void free_List(); //释放空间 private: int cap; //存储空间容量 int len; //顺序表的长度 T *p; //模板类型指针 };//建立空的顺序表 template
void sq_List
::creat_List(){ p = new T[cap]; //指向动态开辟的一维数组空间的首地址 }//检测顺序表 template
T sq_List
::check_List(){ if(cap == len) return -1; else if(len == 0) return 0; else return 1; }//输入顺序表的元素,输出 template
void sq_List
::input_List(){ int i; for(i = 0;i
> *(p+i); for(i = 0;i
T *sq_List
::insert_List(int pos_in,int num){ int i; if(cap == len) cout << "上溢错误" << endl;//顺序表已满的情况 if(pos_in>len) pos_in = len+1; //插入位置在表的最后一个元素之后,表中元素不需要移动 if(pos_in<1) pos_in = 1; //插入元素在表的第一个元素之前,需要移动 表的所有元素 for(i = len;i>=pos_in;i--) p[i] = p[i-1]; p[pos_in-1] = num; //插入新元素 len++; //表长度加一 return p; //返回首地址 }//删除元素 template
T *sq_List
::delete_List(int pos_de){ int i; if(len == 0) cout << "下溢错误" << endl; //顺序表为空表,表中没有元素 if(pos_de<1||pos_de>=len) cout << "没有这个元素" << endl;//表中没有待删除的元素 for(i = pos_de;i
void sq_List
::show_List(){ int i; for(i = 0;i
void sq_List
::free_List(){ delete []p; }int main(){ sq_List
list(10,7); list.creat_List(); list.input_List(); list.check_List(); list.insert_List(5,26); list.delete_List(8); list.show_List(); list.free_List(); system("pause"); return 0; }

精有空时仔细看看

我也来一个有意思的：/* Name: Vector Copyright: FFA Author: Leeroy Description: a standard container*/
#ifndef _MY_Vector_#
define _MY_Vector_#include
#include
#include
#include
#include
inline size_t __upper_bound_2(size_t x){ size_t tmp = 1; while (tmp < x) tmp <<= 1; return tmp;}template
>class Vector{ public: typedef A allocator_type; typedef typename A::pointer pointer; typedef typename A::const_pointer const_pointer; typedef typename A::reference reference; typedef typename A::const_reference const_reference; typedef typename A::value_type value_type; typedef pointer iterator; typedef const_pointer const_iterator; typedef size_t size_type; typedef ptrdiff_t difference_type; typedef std::reverse_iterator
reverse_iterator; typedef std::reverse_iterator
const_reverse_iterator; //5 constructors: Vector(); explicit Vector(const A &); explicit Vector(size_type); Vector(size_type, const T &); Vector(size_type, const T &, const A &); Vector(const Vector &); template
Vector(InIt, InIt); template
Vector(InIt, InIt, const A &); inline void reserve(size_type); inline size_type capacity() const; inline iterator begin(); inline const_iterator begin() const; inline iterator end(); inline const_iterator end() const; inline reverse_iterator rbegin(); inline const_reverse_iterator rbegin() const; inline reverse_iterator rend(); inline const_reverse_iterator rend() const; void resize(size_type); void resize(size_type, T = T()); inline size_type size() const; inline size_type max_size() const; inline bool empty() const; inline A get_allocator() const; inline reference operator[](size_type); inline const_reference operator[](size_type) const; inline reference front(); inline const_reference front() const; inline reference back(); inline const_reference back() const; inline void push_back(const T &); inline void pop_back(); template
inline void assign(InIt, InIt); inline void assign(size_type, const T &); inline iterator insert(iterator, const T &); inline void insert(iterator, size_type, const T &); template
inline void insert(iterator, InIt, InIt); inline iterator erase(iterator); inline iterator erase(iterator, iterator); inline void clear(); inline void swap(Vector &); ~Vector(); protected: template
inline void __constructor(InIt first, InIt last, std::input_iterator_tag); template
inline void __constructor(InIt first, InIt last, std::forward_iterator_tag); A c_al; size_type c_ca; iterator start, finish;};//first constructors:template
Vector
::Vector():

c_ca(1), start(c_al.allocate(c_ca)), finish(start){}template
Vector
::Vector(const A &al):c_al(al), c_ca(1), start(c_al.allocate(c_ca)), finish(start){}template
Vector
::Vector(size_type n):c_ca(__upper_bound_2(n)), start(c_al.allocate(c_ca)), finish(start + n){}template
Vector
::Vector(size_type n, const T &x):c_ca(__upper_bound_2(n)), start(c_al.allocate(c_ca)), finish(std::uninitialized_fill_n(start, n, x)){}template
Vector
::Vector(size_type n, const T &x, const A &al):c_al(al), c_ca(__upper_bound_2(n)), start(c_al.allocate(c_ca)), finish(std::uninitialized_fill_n(start, n, x)){}template
Vector
::Vector(const Vector &an_vec):c_al(an_vec.c_al), c_ca(an_vec.c_ca), start(c_al.allocate(c_ca)), finish(std::uninitialized_copy(an_vec.start, an_vec.finish, start)){}template
template
Vector
::Vector(InIt first, InIt last){ __constructor(first, last, typename std::iterator_traits
::iterator_category());}template
template
Vector
::Vector(InIt first, InIt last, const A &al):c_al(al){ __constructor(first, last, typename std::iterator_traits
::iterator_category());}//second constructors:template
template
voidVector
::__constructor(InIt first, InIt last, std::input_iterator_tag){ c_ca = 1; start = c_al.allocate(c_ca); finish = start; while (first != last) push_back(*first++);}template
template
voidVector
::__constructor(InIt first, InIt last, std::forward_iterator_tag){ c_ca = __upper_bound_2(std::distance(first, last)); start = c_al.allocate(c_ca); finish = std::uninitialized_copy(first, last, start);}//constructors;template
voidVector
::reserve(size_type n){ size_type tmp(c_ca); if (n <= c_ca) return; iterator tmpb(begin()), tmpe(end()); start = c_al.allocate(c_ca = __upper_bound_2(n)); finish = std::uninitialized_copy(tmpb, end(), begin()); for (iterator to_delete = tmpb; to_delete != tmpe; c_al.destroy(to_delete)); c_al.deallocate(tmpb, tmp);}template
typename Vector
::size_typeVector
::capacity() const{ return c_ca;}template
typename Vector
::iteratorVector
::begin(){ return start;}template
typename Vector
::const_iteratorVector
::begin() const{ return start;}template
typename Vector
::iteratorVector
::end(){ return finish;}template
typename Vector
::const_iteratorVector
::end() const{ return finish;}template
typename Vector
::reverse_iteratorVector
::rbegin()

{ return reverse_iterator(end());}template
typename Vector
::const_reverse_iteratorVector
::rbegin() const{ return const_reverse_iterator(end());}template
typename Vector
::reverse_iteratorVector
::rend(){ return reverse_iterator(begin());}template
typename Vector
::const_reverse_iteratorVector
::rend() const{ return const_reverse_iterator(begin());}template
voidVector
::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
voidVector
::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_typeVector
::size() const{ return end() - begin();}template
typename Vector
::size_typeVector
::max_size() const{ return c_al.max_size();}template
boolVector
::empty() const{ return end() == begin();}template
AVector
::get_allocator() const{ return c_al;}template
typename Vector
::referenceVector
::operator[](size_type pos){ return begin[pos];}template
typename Vector
::const_referenceVector
::operator[](size_type pos) const{ return begin[pos];}template
typename Vector
::referenceVector
::front(){ return *begin();}template
typename Vector
::const_referenceVector
::front() const{ return *begin();}template
typename Vector
::referenceVector
::back(){ return *(end() - 1);}template
typename Vector
::const_referenceVector
::back() const{ return *(end() - 1);}template
voidVector
::push_back(const T &x){ if (size() == capacity()) reserve(c_ca <<= 1); c_al.construct(finish++, x);}template
voidVector
::pop_back(){ c_al.destroy(--finish);}template
template
voidVector
::assign(InIt first, InIt last){ reserve(distance(first, last)); clear(); finish = uninitialized_copy(first, last, begin());}template
voidVector
::assign(size_type n, const T &x){ reserve(n); clear(); finish = uninitialized_fill_n(begin(), n, x);}template
typename Vector
::iteratorVector
::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
voidVector
::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
voidVector
::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
::iteratorVector
::erase(iterator it){ c_al.destroy(it); copy(it + 1, end(), it); --finish; return it;}template
typename Vector
::iteratorVector
::erase(iterator first, iterator last){ while (first < last) { erase(first); --last; } return first;}template
voidVector
::clear(){ while (!empty()) pop_back();}template
voidVector
::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 < end(); destroy(tmp++)); c_al.deallocate(start, c_ca);}#endif不过可移植性忘记了，好久以前写的了

这是C++的

0..0

很好，如果日后用C或C++解决实际问题的话，数据结构很重要。

达人

帅

q

回复：7楼
能把你的程序注释一下吗，谢谢了？