【c++】模板实现vector和list

前面我们也知道模板是泛型编程的基础，是实现类型无关的代码，是一种代码复用的重要手段。

一：模板实现Vector:

.h文件
#pragma once
#include<iostream>
#include<assert.h>
#include<string>
using namespace std;
template<typename T>
class Vector
{
public:
//构造
Vector()
:_data(NULL)
, _size(0)
, _capacity(0)
{}
//拷贝构造
Vector(const Vector<T>&v)
{
_data = new T[v._size];
//memcpy
//memcpy(_data, v._data,_size+1)
for (size_t i = 0; i < v._size; ++i)
{
_data[i] = v._data[i];
}
_size = v._size;
_capacity = v._capacity;
}
//赋值运算符的重载
Vector<T>&operator = (Vector<T>&v)
{
swap(this->_data, v._data);
swap(this->_size, v._size);
swap(this->_capacity, v._capacity);
return *this;
}
//析构函数
~Vector()
{
if (_data)
{
delete[] _data;
_data = NULL;
}
_size = _capacity = 0;
}
size_t  Size()
{
return _size ;
}
int&Back()
{
return _data[_size - 1];
}
void Print()
{
for (size_t i = 0; i < _size; ++i)
{
cout << _data[i] << " ";
}
cout << endl;
}
void PushBack(const T&x)
{
_checkcapacity();
Insert(_size, x);
}
void PopBack()
{
Erase(_size);
}
void PushFront(const T&x)
{
_checkcapacity();
for (size_t i = _size; i > 0; --i)
{
_data[i] = _data[i-1];
}
_data[0] = x;
++_size;
}
void PopFront()
{
for (size_t i =0; i < _size; ++i)
{
_data[i] = _data[i+1];
}
--_size;
}
//实现随机位置的插入
void Insert(size_t pos, const T&x)
{
assert(pos >= 0 && pos <= _size);
_checkcapacity();

for (size_t i = pos; i < _size; ++i)
{
_data[pos + 1] = _data[pos];
}
_data[pos] = x;
++_size;
}
//实现随机位置的删除
void Erase(size_t pos)
{
assert(pos);

size_t end = _size;
while (end!= pos)
{
_data[pos] = _data[pos + 1];
--end;
}
--_size;
}
protected:
void _checkcapacity()
{
if (_size >= _capacity)
{
size_t _newcapacity = _capacity * 2 + 3;
T*tmp = new T[_newcapacity];
if (_data)
{
memcpy(tmp, _data, sizeof(T)*_size);
/*for (size_t i = 0; i < _size; ++i)
{
tmp[i] = _data[i];
}*/
delete _data;
}
_data = tmp;
_capacity = _newcapacity;
}
}
protected:
T* _data;
size_t _capacity;
size_t _size;
};
void TestVector()
{
Vector<int> v;
v.PushFront(1);
v.PushFront(2);
v.PushFront(3);
v.Print();

v.PopBack();
v.PopBack();
v.PopBack();
v.Print();

v.PushFront(4);
v.PushFront(5);
v.PushFront(6);
v.Print();

v.PopFront();
v.PopBack();
v.PopBack();
v.Print();

Vector<string> v2;
v2.PushBack("V1111111111111111111111111111111111111");
v2.Print();
}

 容器适配器 允许 模板参数 是模板类的类型

//适配器
template <typename T,template<class> class Containter =Vector>
class Stack
{
public:
void Push(const T&x)//尾插
{
_con.PushBack(x);
}
void Pop()//尾删
{
_con.PopBack();
}
T&Top()//返回栈顶
{
return _con.Back();
}
T&Top() const
{
return _con.Back();
}
bool Empty()//是否为空
{
return _con.Size() == 0;
}
bool Empty() const
{
return _con.Size() == 0;
}
size_t Size() const //堆栈大小
{
return _con.Size();
}
protected:
Containter <T>_con;
};

void TestStack()
{
Stack<int,Vector> s;
s.Push(7);
s.Push(8);
s.Push(9);

while (!s.Empty())
{
cout << s.Top() << " ";
s.Pop();
}
cout << endl;
}

二：模板实现list:

list.h文件：
#pragma once
#include<iostream>

#include<assert.h>
using namespace std;
//定义一个结构体
template<class T>
struct ListNode
{
T _data;
ListNode<T>* _next;
ListNode<T>* _prev;

ListNode(const T&x = T())
:_data(x)
,_prev(NULL)
,_next(NULL)
{}
};
//带有头结点的双向循环链表
template<class T>
class List
{
typedef ListNode<T>  Node;
public:
List()
{
_head = new Node;
_head->_next = _head;
_head->_prev = _head;
}
List(const List<T>&l)
{
_head = new Node();
_head->_next = _head;
_head->_prev = _head;

Node* cur = (l._head)->_next;
while (cur != l._head)
{
this->PushBack(cur->_data);
cur = cur->_next;
}
}
List<T> & operator=(List<T>l)
{
swap(_head, l._head);
return *this;
}
~List()
{
Clear();
delete _head;
_head = NULL;
}
void Clear()
{
Node* cur = _head->_next;
while (cur != _head)
{
Node* next = cur->_next;
delete cur;
cur = next;
}

_head->_next = _head;
_head->_prev = _head;
}
void PushBack(const T&x)
{
Insert(_head, x);
}
void PopBack()
{
Erase(_head->_prev);
}
void PushFront(const T&x)
{
Insert(_head->_next,x);
}
void PopFront()
{
Erase(_head->_next);
}
void Insert(Node *pos, const T&x)
{
assert(pos);

Node* tmp = new Node(x);
Node* cur = pos;
Node* prev = cur->_prev;

prev->_next = tmp;
tmp->_prev = prev;

tmp->_next = cur;
cur->_prev = tmp;
}
void Erase(Node*pos)
{
assert(pos&&pos != _head);
Node *prev = pos->_prev;
Node*next = pos->_next;

prev->_next = next;
next->_prev = prev;
delete pos;
}
T&Back()//返回队尾
{
assert(_head->_next != _head);
return _head->_prev->_data;
}
T&Front()//返回队头
{
assert(_head->_next != _head);
return _head->_next->_data;
}
size_t Size()//队列元素的个数
{
size_t count = 0;
Node*cur = _head->_next;
while (cur!=_head)
{
++count;
cur = cur->_next;
}
return count;
}

void Print()
{
Node* cur = _head->_next;
while (cur != _head)
{
cout << cur->_data << " ";
cur = cur->_next;
}
cout << endl;
}
protected:
Node *_head;
};

void TestList()
{
List<int> l;
l.PushBack(1);
l.PushBack(2);
l.PushBack(3);
l.Print();

l.PopBack();
l.PopBack();
l.PopBack();
l.Print();

l.PushFront(4);
l.PushFront(5);
l.PushFront(6);
l.Print();
}

 容器适配器 允许 模板参数 是模板类的类型

//适配器
template < class T,class Container = List<T>>
//队列的操作在尾部插入，在头部删除
class Queue
{
public:
void Push(const T& x)//尾插
{
_con.PushBack(x);
}
void Pop()
{
_con.PopFront();
}
T& Front()
{
return _con.Front();
}
T& Back()
{
_con.Back();
}
bool Empty()
{
return _con.Size() == 0;
}
size_t Size()
{
return _con.Size();
}
protected:
Container _con;
};

void TestQueue()
{
Queue<int> q;
q.Push(7);
q.Push(8);
q.Push(9);
while (!q.Empty())
{
cout << q.Front() << " ";
q.Pop();
}
cout << endl;
}