目录
1.什么是容器适配器
在已有的容器(vector、list)的基础上适配出其他的容器。就类似于手机、笔记本电脑的电源适配器，我们已有220V的家庭电源要适配出5V或其他电压的充电器。常用的容器适配器有stack(栈)、queue(队列)、priority_queue(优先级队列)以及反向迭代器。
2.stack的模拟实现
STL使用deque(双端队列)适配出stack，为了方便，自己模拟实现时使用vector容器。
// stack.h
#include <vector>
namespace ly
{
//使用模板泛型化
template<class T,class Container = std::vector<T>>
class stack
{
public:
//成员只有 _con，这个_con还是vector实例化之后的类型
//所以不需要显式定义构造函数，因为默认生成的够用
void push(const T& val)
{
_con.push_back(val);
}
void pop()
{
_con.pop_back();
}
T& top()
{
return _con[_con.size() - 1];
}
size_t size()
{
return _con.size();
}
bool empty()
{
return _con.size() == 0;
}
private:
Container _con;
};
}3.queue的模拟实现
STL使用deque(双端队列)适配出queue，为了方便，自己模拟实现时使用list容器。
#include <list>
namespace ly
{
template<class T,class Container = std::list<T>>
class queue
{
public:
//不需要构造函数
void push(const T& val)
{
_con.push_back(val);
}
void pop()
{
_con.pop_front();
}
T& front()
{
return _con.front();
}
T& back()
{
return _con.back();
}
size_t size()
{
return _con.size();
}
bool empty()
{
return _con.size() == 0;
}
private:
Container _con;
};
}4.deque概述
deque是一种容器，它的中文名为双端队列，但是它并不是一个队列。deque是综合了vector的优点和list的优点而集合在一起的，也就是说deque既能够支持随机访问也能够提高头尾、中间插入删除的效率。但是deque不能取代vector和list。
deque的底层相对于vector与list是比较复杂的。deque使用一个中控指针数组存储每段空间的地址(空间的大小不确定，但都是相同的)。
如果想要头插，那么就要在有效指针之前开辟空间。
如果想要尾插，那么就要在有效指针之后开辟空间。
每一段固定大小的空间称之为buffer数组。deque在进行随机访问时要计算是第几个buffer，再计算具体的元素位置，所以deque的随机访问效率没有vector高。
deque在进行中间插入删除时，可能会涉及数据的挪动问题，所以deque的中间插入删除效率没有list高。
5.priority_queue的模拟实现
priority_queue是一种容器适配器，中文名为优先级队列，但是它并不是一个队列。priority_queue就是一个堆。使用vector容器适配出来。
在模拟实现时会涉及到一个问题，即如何规定建出来的堆是大堆还是小堆。所以我们需要使用仿函数来帮助我们建堆。
5.1仿函数
C语言的库中有qosort函数，其最后一个参数为函数指针，这个指针指向的函数规定了数据比较大小的方式(数据按什么方式排序)。C++可以直接使用这种设计思想，但是它不愿意(C++是一门面向对象的编程语言)。
设计类时可以设计运算符重载，使用对象时可以直接调用此重载(从外形上来看，这种调用方式与直接调用函数没有区别)。
以简单的冒泡排序举例：
//设计两个类，并且都支持函数调用运算符重载
template<class T>
struct sortLess
{
bool operator()(const T& x,const T& y)
{
return x < y;
}
};
template<class T>
struct sortGreater
{
bool operator()(const T& x, const T& y)
{
return x > y;
}
};
template<class T,class Compare>
void bubbleSort(const T& arr,size_t size)
{
Compare com; //对象
for (int i = 0; i < size; i++)
{
for (int j = 0; j < size - 1-i; j++)
{
if (com(arr[j], arr[j + 1])) //com.operator()(arr[j],arr[j+1])
{
swap(arr[j], arr[j + 1]);
}
}
}
}
int main()
{
int arr[] = { 1,546,76,2314,346,879,467,23 };
bubbleSort<int*,sortLess>(arr,sizeof(arr)/sizeof(int));
for (auto& e : arr)
{
cout << e << " ";
}
cout << endl;
return 0;
}STL规定了两个默认的仿函数，即less和greater。针对priority_queue来说，模板参数使用less即建大堆；使用greater即建小堆。
值得注意的是，STL中的less和greater并不能满足所有的使用场景。例如数据类型是地址时，我们并不希望直接比较地址的值，而是希望比较解引用之后的对象。这时我们需要自定义仿函数的行为了。
5.2模拟实现
namespace ly
{
//设计两个仿函数
template<class T>
struct less
{
bool operator()(const T& x, const T& y)
{
return x < y;
}
};
template<class T>
struct greater
{
bool operator()(const T& x, const T& y)
{
return x > y;
}
};
// 数据类型 默认容器 默认比较方式
template<class T,class Container = std::vector<T>,class Compare = less<T>>
class priority_queue
{
public:
priority_queue() //默认构造
{}
void AdjustDown(size_t parent)
{
Compare com;
size_t child = parent * 2 + 1;
while (child < _con.size())
{
if (child + 1 < _con.size() && _con[child + 1] > _con[child])
{
++child;
}
if (com(_con[parent], _con[child]))
{
std::swap(_con[parent], _con[child]);
parent = child;
child = parent * 2 + 1;
}
else
{
break;
}
}
}
void AdjustUp(size_t child)
{
Compare com;
size_t parent = (child - 1) / 2;
while (child > 0)
{
if (com(_con[parent], _con[child]))
{
std::swap(_con[parent], _con[child]);
child = parent;
parent = (child - 1) / 2;
}
else
{
break;
}
}
}
template<class Iterator>
priority_queue(Iterator first, Iterator last)
:_con(first,last) //初始化容器
{
//建堆
for (int i = (_con.size() - 2) / 2; i >= 0; i--)
{
AdjustDown(i); //向下调整建堆
}
}
void push(const T& val)
{
_con.push_back(val);
AdjustUp(_con.size() - 1); //向上调整建堆
}
bool empty()
{
return _con.empty();
}
const T& top()
{
return _con[0];
}
void pop() //删除堆顶元素
{
std::swap(_con[0], _con[_con.size() - 1]);
_con.pop_back();
AdjustDown(0); //向下调整建堆
}
private:
Container _con;
};
}6.反向迭代器
反向迭代器是通过容器的正向迭代器适配出来的，所以反向迭代器也是容器适配器。
//模板参数接收一个正向迭代器
template<class Iterator,class Ref,class Ptr>
class ReverseIterator
{
public:
typedef ReverseIterator<Iterator,Ref,Ptr> Self;
ReverseIterator(const Iterator& it)
:_it(it)
{}
//反向迭代器：使用正向迭代器适配出反向迭代器
Self& operator++()
{
--_it;
return *this;
}
Self operator++(int) //后置++
{
Iterator tmp(_it);
--_it;
return tmp;
}
Self& operator--()
{
++_it;
return *this;
}
Self operator--(int) //后置--
{
Iterator tmp(_it);
++_it;
return tmp;
}
Ref operator*()
{
Iterator tmp(_it);
return *(--tmp); //左闭右开原则
}
Ptr operator->() //返回迭代器指向的数据的地址
{
return &(this->operator*());
}
bool operator!=(const Self& it) const
{
return _it != it._it;
}
private:
Iterator _it; //正向迭代器
};在设计反向迭代器的解引用运算符重载时需要注意：正向迭代器的begin就是反向迭代器的rend；正向迭代器的end就是反向迭代器的rbegin。又因为正向迭代器的end指向的是一个无效数据，所以不难理解我们设计解引用运算符重载的代码思路。
那么在模拟实现vector和list的代码中可以这样设计反向迭代器：
typedef ReverseIterator<iterator, T&, T*> reverse_iterator;
typedef ReverseIterator<const_iterator, const T&, const T*> const_reverse_iterator;
reverse_iterator rbegin()
{
return reverse_iterator(end());
}
reverse_iterator rend()
{
return reverse_iterator(begin());
}
const_reverse_iterator rbegin() const
{
return const_reverse_iterator(end());
}
const_reverse_iterator rend() const
{
return const_reverse_iterator(begin());
}
141
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
