STL適配器，所謂適配器在設(shè)計模式中也有相應(yīng)的講解即，在不改變原有接口的前提下，將該接口轉(zhuǎn)換為我們期待的接口，通常要求的接口和被適配的接口會有相同或者相似的功能，分為三者，Target（客戶要求的接口） adaptee：（原有的接口，被適配的接口）? adapter（適配器接口）,adapter是共有繼承了Target，成員變量獲得adaptee的指針來實現(xiàn)的?。?！

，適配器模式，分為兩種一種是對象適配器模式，一種是類適配器模式，STL適配器有三種，一種是迭代器適配器，一種是函數(shù)適配器，最后一種則是容器適配器：

所謂適配器說的簡單些，其根本就是類型轉(zhuǎn)換器其較簡單的講解就是原本是向前的操作，轉(zhuǎn)換之后變成了向后的操作。我們采用原本是iterator適配器，我們從容器中從前向后進行遍歷，而反向迭代器則是從最后元素開始遍歷，其下一個則是向前移動的。我們將原有的迭代器進行封裝，其C++代碼如下：

templateclass?TVector_iterator;
templateclass?Iterator_m
{
public:
	virtual?T*First()?=?0;	
	virtual?T*Next()?=?0;	
	virtual?bool?isDone()?=?0;
};
templateclass?TVector
{
private:
	T*?m_list;
	int?m_cur_num;
	int?m_max_num;
public:
	TVector()
	{
		m_list?=?NULL;
		m_max_num?=?24;
		m_list?=?new?T[m_max_num];
		m_cur_num?=?0;
	}
	int?get_num()
	{
		return?m_cur_num;
	}
	T*?First()
	{
		return?m_list;
	}
	TVector_iterator*?create_iterator()
	{
		return?new?TVector_iterator(this);
	}
	void?append(T?m)
	{
		if?(m_cur_num?==?m_max_num)
		{
			T*?new_list?=?new?T[m_max_num?*?2];
			for?(int?i?=?0;?i?<?m_max_num;?i++)
			{
				new_list[i]?=?m_list[i];
			}
			delete?m_list;
			m_list?=?new_list;
		}
		m_list[m_cur_num++]?=?m;
	}
};
templateclass?TVector_iterator?:public?Iterator_m{
private?:
	TVector*?m_hinstance;
	int?m_cur_pos;
	T*?m_head;
public:
	TVector_iterator(TVector*?m)
	{
		m_hinstance?=?m;
		m_cur_pos?=?0;
		m_head?=?m_hinstance->First();
	}
	T*?First()
	{
		m_cur_pos?=?0;
		return?m_head=m_hinstance->First();
	}
	T*?Next()
	{
		return?&m_head[m_cur_pos++];
	}
	T*?Prev()
	{
		return?&m_head[m_cur_pos--];
	}
	T*?Last()
	{
		m_cur_pos?=?m_hinstance->get_num()?-?1;
		m_head?=?m_hinstance->First();
		return?&m_head[m_cur_pos];
	}
	int?get_cur_pos()
	{
		return?m_cur_pos;
	}
	bool?isDone()
	{
		if?(m_cur_pos?==?m_hinstance->get_num())
		{
			return?true;
		}
		return?false;
	}
};
templateclass?reverse_iterator_m?:public?Iterator_m{
private:
	TVector_iterator*?m_iterator;
public:
	T*?First()
	{
		return?m_iterator->Last();
	}
	T*?Next()
	{
		return?m_iterator->Prev();

	}
	reverse_iterator_m(TVector_iterator*?m)
	{
		m_iterator?=?m;
		m_iterator->First();
	}
	bool?isDone()
	{
		if?(m_iterator->get_cur_pos()?==?-1)
		{
			return?true;
		}
		return?false;
	}

};
int?main()
{
	TVectormm;
	for?(int?i?=?0;?i?<?20;?i++)
	{
		mm.append(i);
	}
	TVector_iterator*?itr?=?mm.create_iterator();
	cout?<<?"這是使用Iterator?的結(jié)果n";
	while?(!itr->isDone())
	{
		cout?<<?*(itr->Next())?<<?endl;	
	}
	reverse_iterator_m*?ritr?=?new?reverse_iterator_m(itr);
	cout?<<?"這是使用reverse_Iterator?的結(jié)果n";
	ritr->First();
	while?(!ritr->isDone())
	{
		cout?<<?*(ritr->Next())?<<?endl;
	}
}

接下來要討論的就是函數(shù)適配器，所謂函數(shù)適配器，也即函數(shù)的類型轉(zhuǎn)換，比如大家最常用的例子是find_if，find_if的第三個參數(shù)是需要接受一個一元函數(shù)，然而我們真的需要的是動態(tài)獲取find_if中的first到last中的數(shù)據(jù)，另一個參數(shù)則是確定的值，這時候，就會需要進行函數(shù)的轉(zhuǎn)換，也即函數(shù)適配器：其C++代碼實現(xiàn)下所示：

#include#includeusing?namespace?std;



templatestruct?get_equal?:public?binary_function{
	bool?operator()(T?m,?T?n)
	{
		return?m?==?n;
	}
};

templateclass?bind_1St_cla?:public?unary_function{
protected:
	Fn?op;//保存函數(shù)對象
	typename?Fn::first_argument_type?value;//根據(jù)函數(shù)第一參數(shù)的類型，聲明變量，將值保存，以后不變，也即進行了綁定
public:
	//這里面需要做的兩個，一個是構(gòu)造函數(shù)，對op?和value進行賦值
	bind_1St_cla(const?Fn&?m,?typename?Fn::first_argument_type?n)?:op(m),?value(n)
	{}
	//第二個是重載（）操作符
	typename?Fn::result_type?operator()(const?typename?Fn::second_argument_type?m)
	{
		return?op(value,?m);
	}
};
//接下來是定義一個內(nèi)聯(lián)函數(shù)，對類bind_1St_cla進行使用
templateinline?/*標志常駐內(nèi)存，提高速度*/?bind_1St_clathe_real_fuction(const?Fn&?m,?const?Ty?ha)
{
	return?bind_1St_cla(m,?ha);
}


int?main()
{
	int?a[]?=?{?1,?2,?3,?4,?5,?6,?7,?8?};
	int*?mm?=?find_if(a,?a?+?8,?the_real_fuction(get_equal(),?4));
	cout?<<?*mm?<<?endl;
}