Zaawansowane CPP/Ćwiczenia 12: Używanie funktorów

Ćwiczenie 1

Napisz algorytm for_each który działałby na dwu zakresach.

template<typename InputIterator1,
         typename InputIterator2,
         typename BinaryFunction op> 
BinaryFunction for_each(InputIterator1 first1,
                        InputIterator1 last1,
                        InputIterator2 first2,
                        BinaryFunction op);

Algorytm ma działać tak jak standardowy for_each, tyle że funkcja op ma być stosowana do par elementów:

op(*first1,*first2);
op(*(first1+1),*(first2+1);
...

Rozwiązanie

To rozwiązanie nie wymaga chyba komentarza.

template<typename InputIterator1,
         typename InputIterator2, 
         typename BinaryFunction >
BinaryFunction for_each(InputIterator1 first1,InputIterator1 last1,
                        InputIterator2 first2,
                        BinaryFunction op) {

 for(;first1! =   last1;++first1,++first2)
   op(*first1,*first2);

 return op;
}

Kod znajduje się w pliku for_each.h.

Ćwiczenie 2

Zaimplementuj opisany na wykładzie adapter, który opakowuje funkcję lub funktor, ignorując zwracaną przez nie wartość i zwracający zamiast niej jakąś wartość wybranego typu. Np.:

double f(int);
adapt(f,7)(0);

wywołuje f(0) i zwraca 7.

double f(int);
adapt(f)(0);

wywołuje f(0) i nie wraca żadnej wartości.

Rozwiązanie

template<typename Function , typename Result > class adapt_t:
public functor_traits<Function>::f_type {
  typedef typename functor_traits<Function>::arg1_type arg1_type;
  typedef typename functor_traits<Function>::arg2_type arg2_type;
  Function _f;
  Result  _val;
public:
  adapt_t(Function f,Result val):_f(f),_val(val) {};
  typedef Result result_type;

  result_type operator()() {_f();return result_type(_val);};
  result_type operator()(arg1_type a1) {_f(a1);return result_type(_val);};
  result_type operator()(arg1_type a1,arg2_type a2) {_f(a1,a2);return
result_type(_val);};

};

Do tego dochodzi jeszcze specjalizacja dla {Result = void} i funkcje:

template<typename R,typename F> adapt_t<F,R>
adapt(F f,R val) {return adapt_t<F,R>(f,val);}
template<typename F> adapt_t<F,void>
adapt(F f) {return adapt_t<F,void>(f);}

Kod znajduje się w pliku dev_null.h.

Ćwiczenie 3

Napisz iterator, który nic nie robi, ignorując przypisywane do niego elementy.

Rozwiązanie

Korzystamy z prostej klasy proxy:

 struct sink {
   void operator =   (const T&) {};
 };

której operator przypisania "połyka" swój argument. Kod znajduje się w pliku dev_null.h.

Ćwiczenie 4

Zaimplementuj opisany w wykładzie iterator, który działa podaną funkcją na przypisywane obiekty.

Rozwiązanie

Iterator

template<typename F,typename T>  
class exec_iterator_t: public std::iterator<std::output_iterator_tag,T> 
{
  F _fun;

oparty jest o zagnieżdżoną klasę proxy:

struct do_it {
   exec_iterator_t *_parent;
   do_it(exec_iterator_t *parent):_parent(parent) {};
   void operator =   (const T& x) { _parent->_fun(x);}
 };

 do_it _proxy;

której operator przypisania wywołuje podaną funkcje na wartości mu przekazanej. Operator * zwraca obiekt proxy, a operatory ++ nie robią nic:

public:
  exec_iterator_t(F fun):_fun(fun),_proxy(this) {};
  do_it &operator*(){return _proxy;};
  exec_iterator_t &operator++() {return *this;}
  void operator++(int) {}
};

Do utworzenia iteratora używamy szablon funkcji

template<typename T,typename F> 
exec_iterator_t<F,T> exec_iterator(F f){
return exec_iterator_t<F,T>(f);
};

korzystając z automatycznej dedukcji typów.

Kod znajduje się w pliku exec_iterator.h.