我所用过的C++ 循环

/*

目标：在不太损失效率的情况下写最简洁最放心的循环

声明：随意写下的，有的功能还没实现，欢迎大家纠正补充。


① []类数组方式,实现简洁明了，代价也是显而易见：不检查越界情况。
   如果不嫌规范也可以这样定义循环变量vector < shared_ptr<CWorker> >::size_type i=0;
   at(int index);直接返回该位置上的记录，而且越界的话会检查的。此种方式归为第一类。

② 最常见

③ 宏BOOST_TYPEOF和BOOST_AUTO一样 可以自动推断表达式类型，书上说对于自定义类型要“注册”，但我发现没注册一样用。
   个人觉得比起typedef 这种随用随定义蛮好，尤其是很变态长的声明，能少写一点是一点。
   有个问题是如何 加上 const 有待解决。
   BOOST_TYPEOF( vecW.begin() ) w; 是个空指针，程序会崩溃，有待解决。

④ 声明下个人原因用transform的优先级最低。且用bind 取代标准库配接器，但是transform的那个bind我没有写出来。
   google有会也没写出来，有待解决。

⑤ 智能指针bind 时要用*_1

⑥ 很多人对boost::BOOST_FOREACH不以为然，for简单的封装。
   用习惯了它反而觉得前三种怪异，循环集合为何要定义变量？

⑦ 同上
*/

#include "stdafx.h"

#include <iostream>
#include <string>

#include <vector>
#include <algorithm>
#include <functional>

#include "boost/lambda/lambda.hpp"
#include "boost/lambda/bind.hpp"

#include "boost/assign.hpp"
#include "boost/typeof/typeof.hpp"
#include "boost/foreach.hpp"
#include <boost/shared_ptr.hpp>

#define foreach BOOST_FOREACH
#define auto_t  BOOST_AUTO

using namespace boost;
using namespace boost::lambda;
using namespace std;

//④ transform 调用
template <class ty>
class nullify
{
public:
ty operator () ( ty &elem )
{
std::cout  << elem->m_name  << endl;
return elem;
}
};

//自定义类
struct CWorker
{  
CWorker( long ll,string ss)
:m_No     (ll)
,m_name   (ss)
{}
long   m_No     ;
string m_name   ;
};

int _tmain(int argc, _TCHAR* argv[])
{
std::vector< shared_ptr<CWorker> > vecW;
vecW = boost::assign::list_of(shared_ptr<CWorker>(new CWorker(1001,"1001")) )
     (shared_ptr<CWorker>(new CWorker(1002,"1002")) )
     (shared_ptr<CWorker>(new CWorker(1003,"1003")) )
     (shared_ptr<CWorker>(new CWorker(1004,"1004")) )
     (shared_ptr<CWorker>(new CWorker(1005,"1005")) );

//① 标准的循环如下 at()  
std::cout << " ----   [i]  循环   ----  \n";
for(unsigned i=0; i< vecW.size();++i )
{
std::cout << vecW[i]->m_name  << endl;
}
   
//② 标准的循环如下 at()
std::cout << " ----   迭代器  循环   ----  \n";
vector < shared_ptr<CWorker> >::const_iterator ww = vecW.begin();
for (;ww != vecW.end(); ++ww)
{
       std::cout  << (*ww)->m_name  << endl;
}

//③ 迭代器的方式
std::cout << " ----  迭代器 循环(BOOST_TYPEOF)  ---- \n";
BOOST_TYPEOF( vecW.begin() ) w;
//for (;w != vecW.end(); ++w)
//{  
// std::cout  << (*w)->m_name  << endl;
//}


//④ transform 循环
std::cout << " ----  transform 循环  ---- \n";
std::transform(vecW.begin(),vecW.end(),vecW.begin(),
           nullify< shared_ptr<CWorker> >() );

    //⑤ for_each 的方式
std::cout << " ---- for_each 循环 ---- \n";
std::for_each(vecW.begin(),vecW.end(),
          std::cout << bind(&CWorker::m_name ,*_1)<< '\n');

//⑥ BOOST_FOREACH
std::cout << " ---- foreach 循环 ---- \n";
foreach(const shared_ptr<CWorker> &ww,vecW)
{
std::cout  << ww->m_name  << endl;
}

//⑦ BOOST_FOREACH + BOOST_AUTO
std::cout << " ---- BOOST_FOREACH + BOOST_AUTO 循环 ---- \n";
foreach(auto_t( ww,*vecW.begin()),vecW)
{
std::cout  << ww->m_name  << endl;
}

return 0;
}