std::vector<int> a;
...
for_each(a.begin(), a.end(), ... ) ;

G>std::vector<int> a;
G>...
G>for_each(a.begin(), a.end(), ... ) ;
G>

for (std::vector<int>::iterator ii=vec.begin(); ii!=vec.end();ii++)
{
    (*ii) *= 2;
}

G>std::vector<int> a;
G>...
G>for_each(a.begin(), a.end(), ... ) ;
G>

// alg_for_each.cpp
// compile with: /EHsc
#include <vector>
#include <algorithm>
#include <iostream>

// The function object multiplies an element by a Factor
template <class Type>
class MultValue
{
private:
   Type Factor;   // The value to multiply by
public:
   // Constructor initializes the value to multiply by
   MultValue ( const Type& _Val ) : Factor ( _Val ) {
   }

   // The function call for the element to be multiplied
   void operator ( ) ( Type& elem ) const
   {
      elem *= Factor;
   }
};

// The function object to determine the average
class Average
{
private:
   long num;      // The number of elements
   long sum;      // The sum of the elements
public:
   // Constructor initializes the value to multiply by
   Average ( ) : num ( 0 ) , sum ( 0 )
   {
   }

   // The function call to process the next elment
   void operator ( ) ( int elem )    {
      num++;      // Increment the element count
      sum += elem;   // Add the value to the partial sum
   }

   // return Average
   operator double ( )
   {
      return  static_cast <double> (sum) /
      static_cast <double> (num);
   }
};

int main( )
{
   using namespace std;
   vector <int> v1;
   vector <int>::iterator Iter1;

   // Constructing vector v1
   int i;
   for ( i = -4 ; i <= 2 ; i++ )
   {
      v1.push_back(  i );
   }

   cout << "Original vector  v1 = ( " ;
   for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
      cout << *Iter1 << " ";
   cout << ")." << endl;

   // Using for_each to multiply each element by a Factor
   for_each ( v1.begin ( ) , v1.end ( ) , MultValue<int> ( -2 ) );

   cout << "Multiplying the elements of the vector v1\n "
        <<  "by the factor -2 gives:\n v1mod1 = ( " ;
   for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
      cout << *Iter1 << " ";
   cout << ")." << endl;

   // The function object is templatized and so can be
   // used again on the elements with a different Factor
   for_each (v1.begin ( ) , v1.end ( ) , MultValue<int> (5 ) );

   cout << "Multiplying the elements of the vector v1mod\n "
        <<  "by the factor 5 gives:\n v1mod2 = ( " ;
   for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
      cout << *Iter1 << " ";
   cout << ")." << endl;

   // The local state of a function object can accumulate
   // information about a sequence of actions that the
   // return value can make available, here the Average
   double avemod2 = for_each ( v1.begin ( ) , v1.end ( ) ,
      Average ( ) );
   cout << "The average of the elements of v1 is:\n Average ( v1mod2 ) = "
        << avemod2 << "." << endl;
}

D>// The function object to determine the average
D>class Average
D>{
D>private:
D>   long num;      // The number of elements
D>   long sum;      // The sum of the elements
D>public:
D>   // Constructor initializes the value to multiply by
D>   Average ( ) : num ( 0 ) , sum ( 0 )
D>   {
D>   }

D>   // The function call to process the next elment
D>   void operator ( ) ( int elem )    {
D>      num++;      // Increment the element count
D>      sum += elem;   // Add the value to the partial sum
D>   }

D>   // return Average
D>   operator double ( )
D>   {
D>      return  static_cast <double> (sum) /
D>      static_cast <double> (num);
D>   }
D>};

D>   // The local state of a function object can accumulate
D>   // information about a sequence of actions that the
D>   // return value can make available, here the Average
D>   double avemod2 = for_each ( v1.begin ( ) , v1.end ( ) ,
D>      Average ( ) );

double avemod2 = for_each(v1.begin(), v1.end(), Average()).getResult();

void MultValue::operator ( ) ( const Type& elem ) const

B>Ну так потому и работает

B>void MultValue::operator ( ) ( const Type& elem ) const
B>

void fff(int& x)
{
   x*=2;
}



   std::vector<int> a(10, 5);

   std::for_each(a.begin(), a.end(), fff);

PX>void fff(int& x)
PX>{
PX>   x*=2;
PX>}



PX>   std::vector<int> a(10, 5);

PX>   std::for_each(a.begin(), a.end(), fff);

PX>

std::vector<int>::const_iterator itBegin = a.begin();
std::vector<int>::const_iterator itEnd = a.end();
std::for_each(itBegin, itEnd, fff);

    std::valarray<int> Values(2, 5); // к примеру инициализируем пятью двойками
    Values *= 2;

G>std::vector<int> a;
G>...
G>for_each(a.begin(), a.end(), ... ) ;

VK>for (std::vector<int>::iterator ii=vec.begin(); ii!=vec.end();ii++)
VK>{
VK>    (*ii) *= 2;
VK>}
VK>

VK>Либо есть еше вариант, в контейнере указатели хранить,но это уже попахивает каким-то извратом

transform(vec.begin(), vec.end(), vec.begin(), bind2nd(multiplies<int>, 2));