C++を勉強しすぎると

このような拗ねたコードしか書かなくなるぞ。

//VBスタイルForの静的バージョン。正直これ需要あるのwww
//パフォーマンスについて、全部inline関数使ってるから、コンパイラーが最適化かけたらフラットに展開される筈。
//使い方：VB_For< 開始, 終了, ステップ, [VB_For<...>] >( 関数ポインタ/関数オブジェクト/ラムダ式　);
//例： VB_For< 1, 10, 1 >( 一つの引数を持つ 関数ポインタ/関数オブジェクト/ラムダ式 );
// VB_For< 1, 10, 1, >( 二つの引数を持つ 関数ポインタ/関数オブジェクト/ラムダ式 );
// ...
// depth = 3まで実装した。かなり煩雑なコードになったが、variadic templateがあればもっとスマートな実装ができる(かもしれない)。
//
//もっと詳しい例：
//
//using namespace std;
//using namespace boost::lambda;
//int a[2][3];
//VB_For<0,1,1,
// VB_For<2,0,-1> >
//(
// var(a)[_1][_2]=_1*3+_2 //[&](int x1, int x2){ a[x1][x2]=x1*3+x2; }
//);
//cout << a[0][0] << "," << a[0][1] << "," << a[0][2] << endl;
//cout << a[1][0] << "," << a[1][1] << "," << a[1][2] << endl;
//
//上記の例をc++のforで直せばこんな感じ：
//for( int i=0; i<=1; ++i )
// for( int j=2; j>=0; --j )
// a[i][j]=i*3+j;
//

namespace Private {

struct VB_For_null;

template< bool IsOK >
struct VB_For_guard;

template<>
struct VB_For_guard< true > {};

////

template< int COUNT__, int STEP__, int CUR__ >
struct VB_For_impl_n_1
{
  template<class T>
  inline static void run( const T& t )
  {
    t( CUR__ );
    VB_For_impl_n_1::template run(t);
  }
};

template< int STEP__, int CUR__ >
struct VB_For_impl_n_1< 0, STEP__, CUR__ >
{
  template<class T>
  inline static void run( const T& t ) {}
};

////

template< int COUNT__, int STEP__, int CUR__, int COUNT2__, int STEP2__, int CUR2__ >
struct VB_For_impl_n_2_1
{
  template<class T>
  inline static void run( const T& t )
  {
    t( CUR__, CUR2__ );
    VB_For_impl_n_2_1< COUNT__, STEP__, CUR__, COUNT2__-1, STEP2__, CUR2__+STEP2__ >::template run(t);
  }
};

template< int COUNT__, int STEP__, int CUR__, int STEP2__, int CUR2__ >
struct VB_For_impl_n_2_1< COUNT__, STEP__, CUR__, 0, STEP2__, CUR2__ >
{
  template<class T>
  inline static void run( const T& t ) {}
};

template< int COUNT__, int STEP__, int CUR__, int COUNT2__, int STEP2__, int CUR2__ >
struct VB_For_impl_n_2
{
  template<class T>
  inline static void run( const T& t )
  {
    VB_For_impl_n_2_1< COUNT__, STEP__, CUR__, COUNT2__, STEP2__, CUR2__ >::template run(t);
    VB_For_impl_n_2< COUNT__-1, STEP__, CUR__+STEP__, COUNT2__, STEP2__, CUR2__ >::template run(t);
  }
};

template< int STEP__, int CUR__, int COUNT2__, int STEP2__, int CUR2__ >
struct VB_For_impl_n_2< 0, STEP__, CUR__, COUNT2__, STEP2__, CUR2__ >
{
  template<class T>
  inline static void run( const T& t ) {}
};

////

template< int COUNT__, int STEP__, int CUR__, int COUNT2__, int STEP2__, int CUR2__, int COUNT3__, int STEP3__, int CUR3__ >
struct VB_For_impl_n_3_2_1
{
  template<class T>
  inline static void run( const T& t )
  {
    t( CUR__, CUR2__, CUR3__ );
    VB_For_impl_n_3_2_1< COUNT__, STEP__, CUR__, COUNT2__, STEP2__, CUR2__, COUNT3__-1, STEP3__, CUR3__+STEP3__ >::template run(t);
  }
};

template< int COUNT__, int STEP__, int CUR__, int COUNT2__, int STEP2__, int CUR2__, int STEP3__, int CUR3__ >
struct VB_For_impl_n_3_2_1< COUNT__, STEP__, CUR__, COUNT2__, STEP2__, CUR2__, 0, STEP3__, CUR3__ >
{
  template<class T>
  inline static void run( const T& t ) {}
};

template< int COUNT__, int STEP__, int CUR__, int COUNT2__, int STEP2__, int CUR2__, int COUNT3__, int STEP3__, int CUR3__ >
struct VB_For_impl_n_3_2
{
  template<class T>
  inline static void run( const T& t )
  {
    VB_For_impl_n_3_2_1< COUNT__, STEP__, CUR__, COUNT2__, STEP2__, CUR2__, COUNT3__, STEP3__, CUR3__ >::template run(t);
    VB_For_impl_n_3_2< COUNT__, STEP__, CUR__, COUNT2__-1, STEP2__, CUR2__+STEP2__, COUNT3__, STEP3__, CUR3__ >::template run(t);
  }
};

template< int COUNT__, int STEP__, int CUR__, int STEP2__, int CUR2__, int COUNT3__, int STEP3__, int CUR3__ >
struct VB_For_impl_n_3_2< COUNT__, STEP__, CUR__, 0, STEP2__, CUR2__, COUNT3__, STEP3__, CUR3__ >
{
  template<class T>
  inline static void run( const T& t ) {}
};

template< int COUNT__, int STEP__, int CUR__, int COUNT2__, int STEP2__, int CUR2__, int COUNT3__, int STEP3__, int CUR3__ >
struct VB_For_impl_n_3
{
  template<class T>
  inline static void run( const T& t )
  {
    VB_For_impl_n_3_2< COUNT__, STEP__, CUR__, COUNT2__, STEP2__, CUR2__, COUNT3__, STEP3__, CUR3__ >::template run(t);
    VB_For_impl_n_3< COUNT__-1, STEP__, CUR__+STEP__, COUNT2__, STEP2__, CUR2__, COUNT3__, STEP3__, CUR3__ >::template run(t);
  }
};

template< int STEP__, int CUR__, int COUNT2__, int STEP2__, int CUR2__, int COUNT3__, int STEP3__, int CUR3__ >
struct VB_For_impl_n_3< 0, STEP__, CUR__, COUNT2__, STEP2__, CUR2__, COUNT3__, STEP3__, CUR3__ >
{
  template<class T>
  inline static void run( const T& t ) {}
};

template< int DEPTH, class T >
struct VB_For_impl_n;

template<class FORT>
struct VB_For_impl_n< 2, FORT >
{
  template<class T>
  inline static void run( const T& t )
  {
    VB_For_impl_n_2< FORT::count, FORT::step, FORT::cur, FORT::next_t::count, FORT::next_t::step, FORT::next_t::cur >::template run(t);
  }
};

template<class FORT>
struct VB_For_impl_n< 3, FORT >
{
  template<class T>
  inline static void run( const T& t )
  {
    VB_For_impl_n_3<
      FORT::count, FORT::step, FORT::cur,
      FORT::next_t::count, FORT::next_t::step, FORT::next_t::cur,
      FORT::next_t::next_t::count, FORT::next_t::next_t::step, FORT::next_t::next_t::cur
      >::template run(t);
  }
};

}

template< int FROM__, int TO__, int STEP__, class NEXT__ = Private::VB_For_null >
struct VB_For : Private::VB_For_guard< FROM__ == TO__ || ( (FROM__ < TO__) ? (STEP__ > 0) : (STEP__ < 0) ) >
{
  typedef NEXT__ next_t;

  enum {
    count = FROM__ == TO__ ? 1 : ( TO__ + STEP__ - FROM__ ) / STEP__ ,
    cur = FROM__,
    step = STEP__,
    depth = NEXT__::depth + 1
  };

  template
  inline VB_For( const T& t ) { Private::VB_For_impl_n< depth, VB_For >::template run(t); }
};

template< int FROM__, int TO__, int STEP__ >
struct VB_For< FROM__, TO__, STEP__, Private::VB_For_null >
: Private::VB_For_guard< FROM__ == TO__ || ( (FROM__ < TO__) ? (STEP__ > 0) : (STEP__ < 0) ) >
{
  typedef Private::VB_For_null next_t;

  enum {
    count = FROM__ == TO__ ? 1 : ( TO__ + STEP__ - FROM__ ) / STEP__ ,
    cur = FROM__,
    step = STEP__,
    depth = 1
  };

  template<class T>
  inline VB_For( const T& t ) { Private::VB_For_impl_n_1::template run(t); }
};