非排序map的适配器

以前写过的一些代码，拿出来与大家分享一下，在看代码前先交代清楚它的优缺点，顾名思义此适配器去除了std::map按key排序的特性，元素的排序按我们插入的顺序排列，因此失去了二分查找的性能，查询的时间为常数N。在我们不希望std::map排序元素，且保存元素较少的情况下，这是个不错的解决方案。

Map.h

#pragma once
#include <vector>
#include <utility>

namespace std
{
	template
		<
			class K,
			class V,
			class A = allocator< pair<K, V> >
		>
	class Map 
		: private vector< pair<K, V>, A >
	{
		typedef vector<pair<K, V>, A> Base;

	public:
		typedef K key_type;
		typedef V mapped_type;
		typedef typename Base::value_type value_type;

		typedef typename Base::iterator iterator;
		typedef typename Base::const_iterator const_iterator;
		typedef typename Base::size_type size_type;
		typedef typename Base::reverse_iterator reverse_iterator;
		typedef typename Base::const_reverse_iterator const_reverse_iterator;


		explicit Map(
			const A& alloc = A())
			: Base(alloc)
		{}

		template <class InputIterator>
		Map(InputIterator first, InputIterator last, 
			const A& alloc = A())
			: Base(first, last, alloc)
		{

		}

		Map& operator=(const Map& rhs)
		{ 
			Map(rhs).swap(*this); 
			return *this;
		}

		iterator begin() { return Base::begin(); }
		const_iterator begin() const { return Base::begin(); }
		iterator end() { return Base::end(); }
		const_iterator end() const { return Base::end(); }
		reverse_iterator rbegin() { return Base::rbegin(); }
		const_reverse_iterator rbegin() const { return Base::rbegin(); }
		reverse_iterator rend() { return Base::rend(); }
		const_reverse_iterator rend() const { return Base::rend(); }

		bool empty() const { return Base::empty(); }
		size_type size() const { return Base::size(); }
		size_type max_size() { return Base::max_size(); }

		mapped_type& operator[](const key_type& key)
		{ 
			if (find(key) != end())
			{
				return find(key)->second;
			}
			else{
				push_back(value_type(key,mapped_type()));
				return find(key)->second;
			}
		}

		void insert(const value_type& val)
		{
			Base::push_back(val);
		}

		iterator insert(iterator pos, const value_type& val)
		{
				return Base::insert(pos, val);
		}

		template <class InputIterator>
		void insert(InputIterator first, InputIterator last)
		{ 
			for (; first != last; ++first) 
				insert(*first); 
		}

		void erase(iterator pos)
		{ Base::erase(pos); }

		size_type erase(const key_type& k)
		{
			iterator i(find(k));
			if (i == end()) return 0;
			erase(i);
			return 1;
		}

		void erase(iterator first, iterator last)
		{ Base::erase(first, last); }

		void swap(Map& other)
		{
			Base::swap(other);
		}

		void clear()
		{ Base::clear(); }

		iterator find(const key_type& k)
		{
			iterator i(Base::begin());
			for (;i!=Base::end();++i)
			{
				if(i->first == k)
					return i;
			}
			
			return i;
		}

		const_iterator find(const key_type& k) const
		{       
			const_iterator i(Base::begin());
			for (;i!=Base::end();++i)
			{
				if(i->first == k)
					return i;
			}
			return i;
		}

		size_type count(const key_type& k) const
		{ 
			size_type i = 0;
			for (const_iterator i = Base::begin();i!=Base::end();++i)
			{
				if (i->first == k)
				{
					++i;
				}				
			}
			return i;
		}
	};
} 

main.cpp //对比std::map

#include "Map.h"
#include <iostream>
#include <string>
#include <map>
using namespace std;

int main(void)
{
    Map<int,string> strs_M;
    strs_M[4] = "four";
    strs_M[3] = "three";
    strs_M[5] = "five";
    strs_M[7] = "seven";
    strs_M[2] = "two";
    strs_M[1] = "one";
    strs_M[0] = "zero";
    for(Map<int,string>::iterator it = strs_M.begin();
        it != strs_M.end();++it)
        cout<<it->first<<" "<<it->second<<endl;
    cout<<"==============================================="<<endl;
    map<int,string> strs_m;
    strs_m[4] = "four";
    strs_m[3] = "three";
    strs_m[5] = "five";
    strs_m[7] = "seven";
    strs_m[2] = "two";
    strs_m[1] = "one";
    strs_m[0] = "zero";
    for(map<int,string>::iterator it = strs_m.begin();
        it != strs_m.end();++it)
        cout<<it->first<<" "<<it->second<<endl;
    return 0;
}