Posts - 161,
Articles - 0,
Comments - 162
键盘，琴盘，指尖，狂弹
21:52 by Aga.J, ... 阅读,
1 adapter在设计模式上的定义如下：将一个class的接口转换为另一个class的接口，使得原本因为接口不兼容而不能合作的classes可以一起运作。
2 STL提供多种adapter，其中
改变functor（仿函数）的接口的叫做 function adapter。
改变 container（容器）接口的叫做container adapter
改变 iterator（迭代器）接口的叫做iterator adapter
3 container adapter
容器queue和stack就是一种container adapter，他们修饰deque的接口形成一种新的容器接口
4 iterator adapter
Insert iterator, reverse iterator, iostream iterator都属于 iterator adapter。
Insert iterator 将 一般的 iterator 的赋值操作（assign） 修饰为 插入（insert）操作，例如back_insert_iterator, front_insert_iterator, insert_iterator。
Reverse iterator 将 一般的iterator的前进方向逆转，使得原本应该前进的++操作变成了后退操作。
Iostream iterator 将 iterator 绑定到某个iostream上，使其拥有输入功能。
//use case
#include&iterator&
#include&deque&
#include&algorithm&
#include&iostream&
Int main()
Ostream_iterator&int& outite( cout, & & );
//将outite绑定到cout，每次对outite指派一个元素，然后就接一个& &
Int ia[]={0,1,2,3,4,5};
Deque&int& id( ia, ia+6);
Copy ( id.begin(), id.end(0, outite); //相当于cout&&0 1 2&.
Copy( ia+1, ia+2, front_inserter( id) );
Copy( id.begin(), id.end(), outite); // 相当于cout&&1 0 1 2 3 4 5
Copy( ia+3, ia+4, back_inserter(id));
Copy( id.begin(), id.end(), outite); //
5 functor adapter
Functor adapter的价值在于，通过它们之间的绑定，组合，修饰，几乎可以无限制的创造出各种可能的表达式，搭配STL算法一起演出。例如，我们可能希望找出某个序列中所有不小于12的元素个数，虽然，&不小于&或者&大于或等于&，我们可以选择STL内建的仿函数greater_euqal，但是如果希望完全按照题目，可以这样做
Not1( bind2nd( less&int&(), 12 ))
这个式子将less的第二个参数绑定为12，再加上否定操作，就形成了不小于12的语义，凑成了一个表达式。 可以和任何&可接受表达式为参数&的算法匹配。
#include& algorithm&
#include& functional&
#include& vector&
#include& iostream&
#include& iterator&
Int main()
Ostream_iterator&int& outite( cout,&&);
Int ia[6]={2,21,12,7,19,23};
Vector&int& iv( ia, ia+6);
Foreach( iv.begin, iv.end, compose1( bind2nd( multiplies&int&(),3), bind2nd(plus&int&().2) ));
// 对每个元素v身上执行 (v+2)*3
Copy( iv.begin(), iv.end(), outite);
Transform( iv.begin(), iv.end(), outite, compose1( bind2nd(multipies&int&(),3), bind2nd(plus&int& (),2 ) ));
为什么会有functior adapter，因为仿函数就是将function call操作符重载的一种class，而任何算法接受一个仿函数时，在其演算过程中调用该仿函数的operator()， 这使得不具备仿函数之形，而又真函数之实的&一般函数&和&成员函数&感到为难，所以STL提供了众多的配接器，使得这些普通函数可以无缝的和其他配接器和算法结合起来。
//use case
#include& algorithm&
#include&functional&
#include&vector&
#include&iostream&
Void print(int i) //这里有个既存函数，希望可以在STL体系中复用
{ cout&&i&&& &;}
Explicit int(int i): m_i(i) {}
Void print1() const{cout&&&[&&&m_i&&&]&;} //这个函数也希望可以在STL体系中复用
Int main()
Ostream_iterator& int& outite( cout, & & );
Int ia[6]={2,21,12,7,19,23};
Vector&int& iv( ia, ia+6);
Cout&&count_if ( iv,begin(), iv.end(), not1(bind2nd( less&int&(), 12));
Transform( iv,begin() , iv,end(), outite, compose1( bind2nd( multiplies&int&(),3), bind2nd(plus&int&(),2) ));
Copy( iv.begin(), iv.end(), outite);
For_each( iv.begin(), iv.end(), print); //用函数指针搭配STL算法
For_each( iv.begin(), iv.end(), ptr_fun(print)); //用ptrfun修饰一般函数，并匹配STL算法
上述是各种function adapter和辅助函数，实际效果。
附网上的仿函数好文：
C++ STL 学习 ：for_each与仿函数(functor)（一）
C++ STL 学习 ：for_each与仿函数(functor)（一）
By zieckey( All right reserved!)
先看wikipedia定义：
A function object, also called a functor, functional, or functionoid,[1] is a computer programming construct allowing an object to be invoked or called like it was an ordinary function, usually with the same syntax.
简单来将，仿函数（functor）就是一个重载了"()"运算符的struct或class，利用对象支持operator()的特性，来达到模拟函数调用效果的技术。
我们平时对一个集合类遍历的时候，例如vector，是这样做的：
for(vector&int&::const_iterator iter = ivec.begin(); iter != ivec.end(); ++iter)
//do your whatever you want here
例如下面的代码：
#include &vector&
#include &iostream&
struct State
State( int state ) : m_state( state ){}
~State() { std::cout && "~State(), m_state=" && m_state && std:: }
void setState( int state ){ m_state = }
int getState() const{ return m_ }
void print() const { std::cout && "State::print: " && m_state && std:: }
int main()
std::vector&State*&
vect.push_back( new State(0) );
vect.push_back( new State(1) );
vect.push_back( new State(2) );
vect.push_back( new State(3) );
std::vector&State*&::iterator it( vect.begin() );
std::vector&State*&::iterator ite( vect.end() );
for ( ; it != ++it )
(*it)-&print();
system( "pause" );
这里的for循环语句有点冗余， ach ，为了使用for_each，我们需要定义一个函数，如下：
void print( State* pstate )
pstate-&print();
于是就可以简化为下面代码：
std::for_each( vect.begin(), vect.end(), &print );
上面这段代码有点丑陋，看起来不太爽，主要是函数指针的原因。
在这种应用环境下，C++有仿函数来替代，我们定义一个仿函数，如下：
struct Printer
template&typename T& void operator()( T* t ) { t-&print(); }
于是就可以简化为下面代码：
std::for_each( vect.begin(), vect.end(), Printer() );
下面，我们初步看下 for_each 的STL源码实现：
// TEMPLATE FUNCTION for_each
template&class _InIt,
class _Fn1& inline
_Fn1 for_each(_InIt _First, _InIt _Last, _Fn1 _Func)
{ // perform function for each element
_DEBUG_RANGE(_First, _Last);
_DEBUG_POINTER(_Func);
_CHECKED_BASE_TYPE(_InIt) _ChkFirst(_CHECKED_BASE(_First));
_CHECKED_BASE_TYPE(_InIt) _ChkLast(_CHECKED_BASE(_Last));
for (; _ChkFirst != _ChkL ++_ChkFirst)
_Func(*_ChkFirst);
return (_Func);
上面的代码看起来挺晕菜的，这里给出 effective STL 里面的一个实现，简单明了：
template& typename InputIterator, typename Function &
Function for_each( InputIterator beg, InputIterator end, Function f ) {
while ( beg != end )
f( *beg++ );
其实for_each就是一个模板函数，将for循环语句封装起来，前面两个参数都是迭代器，第三个参数是使用一个函数指针（或仿函数），
其功能是对每一个迭代器所指向的值调用仿函数。之前觉得for_each挺神秘的，其实看看源码也挺简单的。呵呵。
上面代码还是有点冗余，因为为了使用for_each还要单独定义一个函数（或仿函数），不太清爽，
呵呵，stl早为我们准备好了 mem_fun 模板函数来解决这个一个问题，于是代码再次简化为：
std::for_each( vect.begin(), vect.end(), std::mem_fun( &State::print ) ); //function adapter
我们一起看看 mem_fun 的STL源码实现：
// TEMPLATE FUNCTION mem_fun
template&class _Result,
class _Ty& inline
mem_fun_t&_Result, _Ty& mem_fun(_Result (_Ty::*_Pm)())
{ // return a mem_fun_t functor adapter
return (std::mem_fun_t&_Result, _Ty&(_Pm));
mem_fun 函数实际上是调用 mem_fun_t 函数，我们接着深入看看 mem_fun_t，
// TEMPLATE CLASS mem_fun_t
template&class _Result,
class _Ty&
class mem_fun_t
: public unary_function&_Ty *, _Result&
{ // functor adapter (*p-&*pfunc)(), non-const *pfunc
explicit mem_fun_t(_Result (_Ty::*_Pm)())
: _Pmemfun(_Pm)
{ // construct from pointer
_Result operator()(_Ty *_Pleft) const
{ // call function
return ((_Pleft-&*_Pmemfun)());
_Result (_Ty::*_Pmemfun)(); // the member function pointer
将上面这段代码定义的写的我们好看懂一点，如下：
// TEMPLATE CLASS mem_fun_t
template& typename _Result, typename _Ty &
class mem_fun_t : public unary_function&_Ty *, _Result&
typedef _Result (_Ty::*_Pmemfun)();
explicit mem_fun_t( _Pmemfun& pfunc )
: m_pfun( pfunc )
{ // construct from pointer
_Result operator()(_Ty *_Pleft) const
{ // call function
return ( (_Pleft-&*m_pfun)() );
_Pmemfun m_ // the member function pointer
这样就比较清晰了，定义了仿函数mem_fun_t内部定义了一个类成员函数指针，
仿函数构造的时候将函数指针保存起来，当仿函数operator()被调用的时候，
就通过与一个类的实例关联起来从而实现了类成员函数的调用。
其调用流程是这样的，for_each把vector中的元素传送给mem_fun，
mem_fun自己产生一个仿函数mem_fun_t，然后仿函数调用其重载的()。
上述源码还有最后一个没有说明，就是unary_function，直接上源码：
// TEMPLATE STRUCT unary_function
template&class _Arg,
class _Result&
struct unary_function
{ // base class for unary functions
typedef _Arg argument_
typedef _Result result_
就一个模板结构体。没有数据成员，非常简单。
最后，定义一个删除指针的仿函数：
struct DeletePointer
template&typename T& void operator()( T* ptr ) const { }
然后调用，就一个逐一删除vector里面的所有元素了。
std::for_each( vect.begin(), vect.end(), DeletePointer() );
#include &vector&
#include &iostream&
#include &algorithm&
#include &functional&
struct State
State( int state ) : m_state( state ){}
~State() { std::cout && "~State(), m_state=" && m_state && std:: }
void setState( int state ){ m_state = }
int getState() const{ return m_ }
void print() const { std::cout && "State::print: " && m_state && std:: }
void print( State* pstate )
pstate-&print();
struct Printer
template&typename T& void operator()( T* t ) { t-&print(); }
struct DeletePointer
template&typename T& void operator()( T* ptr ) const { }
int main()
std::vector&State*&
vect.push_back( new State(0) );
vect.push_back( new State(1) );
vect.push_back( new State(2) );
vect.push_back( new State(3) );
std::vector&State*&::iterator it( vect.begin() );
std::vector&State*&::iterator ite( vect.end() );
for ( ; it != ++it )
(*it)-&print();
std::for_each( vect.begin(), vect.end(), &print );
std::for_each( vect.begin(), vect.end(), Printer() );
std::for_each( vect.begin(), vect.end(), std::mem_fun( &State::print ) );
std::for_each( vect.begin(), vect.end(), DeletePointer() );
vect.clear();
system( "pause" );
//源码实现与分析
#include&vector&
#include&iostream&
#include &algorithm&
#include &functional&
struct State
State(int state):m_state(state){}
~State(){std::cout&&"~state(),m_state="&&m_}
void setState(int state){m_state=}
int getState(){return m_}
void print() const {std::cout&&"State:print:"&&m_state&&std::}
void print(State* pstate)
(pstate)-&print();
struct Printer
template&typename T& void operator()(T* t){t-&print();}
int main()
std::vector&State*&
vect.push_back(new State(0));
vect.push_back( new State(1) );
vect.push_back( new State(2) );
vect.push_back( new State(3) );
std::vector&State*&::iterator it(vect.begin());
std::vector&State*&::iterator ite(vect.end());
//传统的遍历需要我们取得迭代子进行对象的访问
for(;it!=++it)
(*it)-&print();
//可以尝试使用std自带的for_each,但是需要使用一个函数指针来实现。
std::for_each(vect.begin(),vect.end(),&print);
//其实for_each还是使用了for和迭代器，并把迭代器作为指针函数的参数传入来调用。
template&class InputIterator, class Function&
Function for_each(InputIterator first, InputIterator last, Function f)
for ( ; first!= ++first ) f(*first);
/reference/algorithm/for_each/
//下面试一试使用仿函数，需要先定义一个functor
std::for_each(vect.begin(),vect.end(),p);
//同样利用for_each函数，但是这次我们在模板参数中传入一个类对象，在foreach中使用对象的()操作符时调用所重载的函数，实现我们的目的
// 还是需要自己定义一个仿函数，这次试试function adapter
std::for_each(vect.begin(),vect.end(), std::mem_fun(&State::print));
mem_fun的实现是怎样？
// TEMPLATE FUNCTION mem_fun
template&class _Result,class _Ty& inline
mem_fun_t&_Result, _Ty& mem_fun(_Result (_Ty::*_Pm)())
{ // return a mem_fun_t functor adapter
return (std::mem_fun_t&_Result, _Ty&(_Pm));
注意mem_fun的参数_Result(_Ty::*_Pm)()
注意函数实现中调用了mem_fun_t这个functor adapter
// TEMPLATE CLASS mem_fun_t
template& typename _Result, typename _Ty &
class mem_fun_t : public unary_function&_Ty *, _Result& //继承已有的unary_funcion
typedef _Result (_Ty::*_Pmemfun)();
explicit mem_fun_t( _Pmemfun& pfunc )
: m_pfun( pfunc )
{ // construct from pointer
_Result operator()(_Ty *_Pleft) const
{ // call function
return ( (_Pleft-&*m_pfun)() );
_Pmemfun m_ // the member function pointer
这样就比较清晰了，定义了仿函数mem_fun_t内部定义了一个【类成员函数指针】，
仿函数构造的时候将函数指针保存起来，当仿函数operator()被调用的时候，
就通过与一个类的实例关联起来从而实现了类成员函数的调用。
其调用流程是这样的，for_each把vector中的元素传送给mem_fun，
mem_fun【自己产生一个仿函数mem_fun_t】，然后仿函数调用其重载的()。
所以这里的functor adapter其实就是帮助我们实现一个仿函数来实现和算法的组合等便捷功能。
而且注意到mem_fun_t是如何帮助我们自动实现一个仿函数的
他需要我们传入&State:print，这时候其实也就记录了State类和print函数指针，还有print函数返回值【分别对应Ty Pm Result】然后再根据这些信息来实现一个仿函数，
std::cin&&i;
//见C++ Reference解释：
Convert function pointer to function object
Returns a function object that encapsulates function f.
也就是书里面介绍的方法（将一个普通函数转化为仿函数）
Convert member function to function object (pointer version)
Returns a function object that encapsulates member function f of type T. The member function returns a value of type S and, optionally, can take one parameter of type A.
也就是网上文章中介绍的方法（将一个类成员函数转化为仿函数）【供应代理销售 KPTD-3216SURCK-01 23-21C/T1D-CP2Q2TY/2A(STL)】供应代理销售 KPTD-3216SURCK-01 23-21C/T1D-CP2Q2TY/2A(STL)价格 - 中国供应商
您好，欢迎回来
您好，欢迎来到中国供应商！
当前位置：
&供应代理销售 KPTD-3216SURCK-01 23-21C/T1D-CP2Q2TY/2A(STL)
供应代理销售 KPTD-3216SURCK-01 23-21C/T1D-CP2Q2TY/2A(STL)
订货量（个）
发 &货&期：不限
供货总量：0（个）
最小起订量：
联系人：陈汉雄先生
经营模式：
中国 广东 深圳市福田区 华强北国利大厦30楼
主营产品：
供应信息分类
联系人:陈汉雄
职 位 :经理
地 址 :中国 广东 深圳市福田区 华强北国利大厦30楼
价格：￥300.00
价格：￥111.00
价格：￥88.00
价格：￥10000.00
价格：￥100.00
价格：￥1780.00
价格：￥4300.00
供应代理销售 KPTD-3216SURCK-01 23-21C/T1D-CP2Q2TY/2A(STL)
创信达电子商行位于深圳市福田区华强北电子元器件商业地带，常备有大量现货。公司始终凭借直接的一手采购渠道，充足的货源、合理的价格、可靠的质量为客户提供价优质高的产品。以积极良好的态度、优质快速的服务建立了良好的信誉，在同行业中具有很强的竞争力，并得到客户一致支持和好评。本公司常备大量现货，并有专业的配套人员为您配套.本店专业经营分销世界品牌电子元器件。产品广泛!因为电子元器件型号繁多，未能一一上传，在本司搜索不到的型号，可直接与业务员进行询价！主营:贴片/直插: 钽电容、电容电阻、二三极管、集成电路IC、铝电解电容、可调电容电阻、电感、磁珠、保险管、等系列电子产品配套业务，钽电容品牌:AVX、KEMET、NEC、NICHICON、VIHSAY、MATSUO、SAMSUNG;集成电路IC品牌：TI、BB、AD、ATMEL、MAXIN、NXP、NSC(国半)、LT、PHI、等知名品牌;贴片钽电容体积有：J/K/M型(0603)、P/R型(0805)、A型(3216)、B型(3528)、C型(6032)、D型(7343)、E（7343D）S型/A薄（3216）、Y/V型(7343)、W/U型（6032）、X型/D薄（7343）等封装。贴片LED,大功率LED,06,及3020等特殊规格,品质优良,供货稳定,价格实惠1NN RL201-RL08 6A01-6A10 10A01-10A10 1N2 SR160~SR560 SR3100~SR5100 FR101~FR107 FR301~FR307 HER101~HER108贴片电容体积有：、、、、2220，TDK、村田、三星、风华、国巨等品牌贴片陶瓷电容；贴片电阻体积有：、、、、、国巨、厚生等品牌贴片电阻；TDK、muRata等品牌贴片电感；TDK功率电感；台产功率电感；磁珠。贴片直插二极管：1/2W、1W、2W、5W全系列稳压管、1N4148开关二极管、1N60检波二极管、整流管系列、肖特基系列。贴片直插三极管：SOT-523、SOT-323、SOT-23、SOT-153、SOT-353、SOT-163、SOT-363、SOD-523、SOD-323、SOD-123、SOT-89、SOT-223、SOT-252、SOT-263、TO-92、TO-92S、TO-92，TO-126、TO-220封装的系列大中小功率三极管。直插电容: 独石电容、瓷片电容、高压电容、涤纶电容、铝电解电容、插件钽电容、金属化聚丙烯膜电容、CBB电容、安规电容等。直插电阻：1/8W、1/6W、1/4W、1/2W、1W、2W、3W、5W等封装。（固定电阻器、可变电阻器、热敏电阻器、压敏电阻器、排电阻器）。贴片电解电容、贴片保险丝、金属膜电容、涤纶电容、滤波电容、稳压二极管、快恢复二极管、肖特基二极管、发光二极管、整流二极管、带阻尼三极管、开关三极管、微波三极管、光敏三极管、场效应三极管、高频三极管等产品均为环保正品，原厂进货，一手货源，价格优惠！质量可靠！常备现货！我司能提供产品参数资料、SGS报告等技术支持！竭诚欢迎国内外经销商、厂商前来洽谈合作，迎接共赢的明天！产品众多不能尽录，有任何需要请与我们联系。一、我司主要经营模式以实体经营为主，在深圳有经营实体店，买家可根据自身需要选择直接到我们实体店取货或由快递公司送货。本店所有产品宝贝全部支持支付宝交易、银行转账及快递代收货款.二、少量或需提供样品者请提前与公司销售人员联系,价格系根据市场行情波动与数量的变化调整的，拍前请联系，我们会给予最优惠的价格.三、本店经营商品报价均不含税，我们可根据客户需要，为客户提供相关发票，税款由客户承担（普通发票6.2%，增值税发票17%）四、由于电子元件种类较多，许多相同型号的产品后辍与封装有时会有不同，所以买家购买前务必先与我们确认好您所需商品的品牌、封装、批号及其他相关参数！以便准确迅速地发货长期合作的快递公司包括:顺丰速运，龙邦快递、信丰快递，圆通快递，速尔快递、EMS等几家内国派送范围较大的快递公司。省内的客户可以快递代收货款。快递运费按快递公司标准收费，并由买家承担。姓名：郭先生QQ:1550479电子邮箱：手机号码：固定电话：35传真：44联系地址：中国广东深圳市福田区新亚洲电子市场二楼邮编：518000旺旺帐号：zhongying3376
深圳市天凌箭科技有限公司是电容、电阻、钽电容、电解电容、三星电容、村田电容、国巨电容、高压电容、陶瓷电容、云母电容、可变电容器、铝电解电容、独石电容、固态电容、晶振、聚苯乙烯电容、合金电解电容、有极性有机薄膜电容、光耦、继电器等产品专业生产加工的公司，拥有完整、科学的质量管理体系。深圳市天凌箭科技有限公司的诚信、实力和产品质量获得业界的认可。欢迎各界朋友莅临参观、指导和业务洽谈。
主营产品或服务：
主营行业：
经营模式：
注册资本：
公司成立日期：
公司所在地：
中国 广东 深圳市福田区 华强北国利大厦30楼
企业类型：
中国 广东 深圳市福田区 华强北国利大厦30楼
深圳市天凌箭科技有限公司
价格：￥8.00
价格：￥350.00
价格：面议
价格：￥565.00
价格：￥128.00
价格：￥2700.00
价格：面议
价格：￥1.00
价格：￥700.00
价格：￥302.00
价格：￥930.00
价格：￥1.00
日-17日上海新国际博览中心
日-28日上海世博展览馆
日-17日上海新国际博览中心
日-4日深圳会展中心
日-27日深圳会展中心
日-31日深圳会展中心
日-7日国家会展中心（上海）
日-17日上海新国际博览中心
日-31日深圳会展中心
日-27日青岛国际会展中心
日-11日国家会议中心
日-13日上海新国际博览中心
免责声明：
本商铺内所展现的供应代理销售 KPTD-3216SURCK-01 23-21C/T1D-CP2Q2TY/2A(STL)信息及其他相关信息均由商铺所属企业自行提供，信息的真实性、准确性和合法性由商铺所属企业完全负责。中国供应商对此不承担任何保证责任。
友情提醒：
建议您在购买相关产品前务必确认供应商资质及产品质量，过低的价格有可能是虚假信息，请谨慎对待，谨防欺诈行为。
地址：中国 广东 深圳市福田区 华强北国利大厦30楼&&
按拼音检索：
技术支持：
￥10000.00