목차

map<Key,T>::iterator it;
(*it).first;  // the key value (of type Key)
(*it).second; // the mapped value (of type T)
(*it);        // the "element value" 
            // (of type pair<const Key,T>)

// 다음과 같이 사용할 수도 있다.

it->first;    // (*it).first   (the key value)
it->second;   // (*it).second  (the mapped value)//

목차

template <class InputIterator, class Function>
   Function for_each (
             InputIterator first, InputIterator last,
             Function f);

// TEMPLATE FUNCTION for_each
template<class _II, class _Fn> inline
    _Fn for_each(_II _F, _II _L, _Fn _Op)
    {for (; _F != _L; ++_F)
        _Op(*_F);
    return (_Op); }

#include <iostream>
#include <algorithm>
#include <vector>

// function for for_each
// element를 받아서 출력
void MyPrintFn (int i)
{
    std::cout << " " << i;
}

// class for for_each
// element를 받아서 출력
class MyPrintClass
{
public:
    void operator() (int i)
    {
        std::cout<<" "<<i;
    };
};

// struct for for_each 
// element를 받아서 출력
struct MyStruct
{
    void operator() (int i)
    {
        std::cout<<" "<<i;
    };
}  tStruct;

int main()
{
    // vector for eample
    std::vector<int> myvector;
    myvector.push_back(10);
    myvector.push_back(20);
    myvector.push_back(30);

    // #1. function
    std::cout << "for_each by function"<<std::endl;
    std::for_each(myvector.begin(), myvector.end(), MyPrintFn);

    // #2. class
    std::cout << "\nfor_each by class "<<std::endl;
    MyPrintClass myPrintClass;
    std::for_each (myvector.begin(), myvector.end(), myPrintClass);

    // #3. struct
    std::cout << "\nfor_each by strcut "<<std::endl;
    std::for_each (myvector.begin(), myvector.end(), tStruct);

    std::cout<<std::endl;

    return 0;
}

목차

template < class InputIterator, 
           class OutputIterator, class UnaryOperator >
  OutputIterator transform 
  ( InputIterator first1, InputIterator last1,
    OutputIterator result, UnaryOperator op );

template < class InputIterator1, class InputIterator2,
           class OutputIterator, class BinaryOperator >
  OutputIterator transform 
  ( InputIterator1 first1, InputIterator1 last1,
    InputIterator2 first2, OutputIterator result,
    BinaryOperator binary_op );

// TEMPLATE FUNCTION transform WITH UNARY OP
template<class _II, class _OI, class _Uop> inline
        _OI transform(_II _F, _II _L, _OI _X, _Uop _U)
        {for (; _F != _L; ++_F, ++_X)
                *_X = _U(*_F);
        return (_X); }
// TEMPLATE FUNCTION transform WITH BINARY OP
template<class _II1, class _II2, class _OI, class _Bop> inline
        _OI transform(_II1 _F1, _II1 _L1, _II2 _F2, _OI _X,
                      _Bop _B)
        {for (; _F1 != _L1; ++_F1, ++_F2, ++_X)
                *_X = _B(*_F1, *_F2);
        return (_X); }

#include <iostream>
#include <algorithm>
#include <vector>

// 1씩 증가 시키는 unary operator
int op_increase (int i)
{
        return ++i;
}

// 두 수를 더하는 binary operator
int op_sum (int i, int j)
{
        return i+j;
}

int main ()
{
  std::vector<int> first;
  std::vector<int> second;
  std::vector<int>::iterator it;

  // 첫 번째 container
  // 10, 20, 30, 40, 50
  for (int i=1; i<6; i++)
          first.push_back (i*10);

  // 두 번째 container size 할당
  second.resize(first.size());

  // usage 1
  // 첫 번째 container의 elements를 
  // op_increase unary operator를 이용해서 
  // 1씩 증가
  // 결과 11, 21, 31, 41, 51
  std::transform (first.begin(), first.end(),
                                  second.begin(),
                                  op_increase);

  // usage 2
  // 첫 번째 container의 elements와
  // usgae 1의 결과 container를
  // op_sum인 binary operator를 이용해서 
  // 더함
  // 결과 21, 41, 61, 81, 101
  std::transform (first.begin(), first.end(),
                              second.begin(),
                              first.begin(),
                              op_sum);

  // 결과 출력
  std:: cout << "first contains:";
  for (it=first.begin(); it!=first.end(); ++it)
    std::cout << " " << *it;

  std::cout << std::endl;
  return 0;
}