#include <iostream>

using namespace std;

class functor
{
  int state;
public:
  functor(int initial):state(initial) {}
  void operator()()  { ++state; printf("state %d\n", state); }
};

void do_for_each( int count, functor& action ) // line 13
{
  while(--count >= 0)
    action();
}

int main()
{
    do_for_each( 3, functor(12) ); // line 21
    return 0;
}

C:\tests\temp_args\main.cpp||In function `int main()':|
C:\tests\temp_args\main.cpp|21|error: invalid initialization of non-const reference of type 'functor&' from a temporary of type 'functor'|
C:\tests\temp_args\main.cpp|14|error: in passing argument 2 of `void do_for_each(int, functor&)'|

int main()
{
   functor f(12);
   do_for_each( 3, f ); // line 21
   return 0;
}

class functor
{
  int state;
public:
  functor(int initial):state(initial) {}
  void operator()() const { ++state; printf("state %d\n", state); }
};

void do_for_each( int count, const functor& action ) // line 13
{
  while(--count >= 0)
    action();
}

A reference to type “cv1 T1” is initialized by an expression of type “cv2 T2” as follows:
— If the initializer expression
    — is an lvalue (but is not a bit-field), and “cv1 T1” is reference-compatible with “cv2 T2,” or
    — has a class type (i.e., T2 is a class type) and can be implicitly converted to an lvalue of type “cv3 T3,” where
...
— Otherwise, the reference shall be an lvalue reference to a non-volatile const type (i.e., cv1 shall be const), or shall
be an rvalue reference.

F>A reference to type “cv1 T1” is initialized by an expression of type “cv2 T2” as follows:
F>— If the initializer expression
F>    — is an lvalue (but is not a bit-field), and “cv1 T1” is reference-compatible with “cv2 T2,” or
F>    — has a class type (i.e., T2 is a class type) and can be implicitly converted to an lvalue of type “cv3 T3,” where
F>...
F>— Otherwise, the reference shall be an lvalue reference to a non-volatile const type (i.e., cv1 shall be const), or shall
F>be an rvalue reference.
F>

int main()
{
    {
        functor _t(12);
        do_for_each( 3, _t );
    }
    return 0;
}

int main()
{
    {
        do_for_each( 3, functor(12) );
    }
    return 0;
}

int main()
{
    do_for_each( 3, const_cast<functor&>(static_cast<const functor&>(functor(12))) ); // line 21
    return 0;
}

#include <iostream>

using namespace std;

class functor
{
  int state;
public:
  functor(int initial):state(initial) {}
  void operator()()  { ++state; printf("state %d\n", state); }
}

void do_for_each( int count, functor* action ) // line 13
{
  while(--count >= 0)
    (*action)();
}

int main()
{
    do_for_each( 3, &functor(12) ); // line 21
    return 0;
}

#include <iostream>

using namespace std;

class functor
{
  int state;
public:
  functor(int initial):state(initial) {}
  void operator()()  { ++state; printf("state %d\n", state); }

  functor & operator + () { return *this; }
};

void do_for_each( int count, functor& action ) // line 13
{
  while(--count >= 0)
    action();
}

int main()
{
    do_for_each( 3, +functor(12) ); // line 21
    return 0;
}

functor& self() { return *this; }

do_for_each( 3, functor(12).self() );

int main()
{
    do_for_each( 3, functor(12)=functor(12) ); // line 21
    return 0;
}

#include <iostream>

using namespace std;

class functor
{
  mutable int state;
public:
  functor(int initial) : state(initial) {}
  void operator()() const { ++state; printf("state %d\n", state); }
};

void do_for_each(int count, const functor& action )
{
  while(--count >= 0)
    action();
}

int main()
{
    do_for_each( 3, functor(12) );
    return 0;
}

class functor
{
  int _state;
  int& state;
public:
  functor(int initial) : _state(initial), state(_state) {}
  functor(const functor& other) : _state(other._state), state(_state) {}

  functor& operator=(const functor& other) { _state = other._state; return *this;}
  
  void operator()() const { ++state; printf("state %d\n", state); }
};

class functor
{
  int& state_;
public:
  functor(int& state):state_(state) {}
  void operator()() const { ++state_; printf("state %d\n", state_); }
};

// или void do_for_each( int count, functor action )
void do_for_each( int count, const functor& action ) // line 13
{
  while(--count >= 0)
    action();
}

int main()
{
    int state = 12;
    do_for_each( 3, functor(state) ); // line 21
    return 0;
}

template <class State, class R = void, R (State::*updater)() = State::operator()>
class StateUpdater
{
  State& state_;
public:
  StateUpdater(State& state):state_(state) {}
  R operator()() const { return (state_.*updater)(); }
};

template<class F>
F n_times(int n, F f)
{
    for(int i=0; i!=n; ++i)
        f();
    return f;
}

struct fun
{
    Heavy data;
    .....
};

Heavy data = for_each(begin,end,fun()).data; // куча копирований Heavy

/////////////////////////////

struct fun_light
{
    Heavy* data;
    explicit fun_light(Heavy* side) : data(side) {}
    .....
};

Heavy data;
for_each(begin,end,fun_light(&data));

////////////////////////////

struct fun_smart
{
    shared_ptr<Heavy> data;
    fun_smart() : data(new Heavy()) {}
    explicit fun_smart(shared_ptr<Heavy> side) : data(side) {}
    .....
};

shared_ptr<Heavy> data = for_each(begin,end,fun_smart()).data;