1.2.4.3 functor tips

• functor can be template.
  template<typename Type> 
  class TooBig{ 
  Type cutoff; 
  bool operator()(const T&v){ return v>cutoff}; 
  }
• For template functor, You can get value type from iterator
  template<typename T> 
  struct Average{ 
  T operator()(T t1, T t2){t1+t2/2;} 
  }; 
   
  transfor(beg1, end1, beg1, 
  Average<typename iterator_traits<beg1>::value_type>() ); 
  // 1) I also can extract value_type information from container. 
  // 2) This information can be used in template function object.
• Any functor type should consistent with container type. Pay attention to the second example, you just input Foo to binary_function template, no const and &.
  list<Foo*> 
  struct PtrFooCompare:binary_function 
                 <const Foo*, const Foo*, bool>{ 
  bool operator(const Foo*, const Foo*){...} 
  } 
   
  list<Foo> 
  struct FooCompare:binary_function 
                 <Foo, Foo, bool>{ 
  bool operator(const Foo&, const Foo&){...} 
  }
• Make predicates pure function, see effective STL item 39. That means that there is no side effect in side the fucntion. 1) no I/O, 2) no change any state.
  class Predicate: public unary_function<Foo, bool>{ 
  public: 
  bool operator()(const Foo& f) const{ // two const 
   cutoff++; // this statment will not compile. 
  } 
  private: 
  int cutoff;
• More effective STL item 42. Make sure less<T> means operator< . Don’t specialization of std::less. If you need to another compare, just define your own compare function.
• Generator no argument, unary functions with one argument and binary function with two arguments
• A long story,part 1 , begin from a program, a function can be declare with parameter name.
  int fun (double); //It’s ok when declare, 
  int fun (double(d) ); 
  // it’s ok, () is superfluous and are ignored. 
  //but when you define fun, you must give parameter name. 
   
  int fun (double() );// fun take a function pointer as parameter 
  // I omit the parameter name, 
  //pointer point a function return double and take nothing.
• part2, when you call a function, you can pass a non-name temporary arguments. here, you don’t need give a name of parameter, the const reference will prolong the temporary argument life until the end of function, You have to use const, because you can’t change a temporary arguments.
  fun(const  Foo &fc); 
   
  fun(ftemp());  //ftemp return a Foo 
  fun(Foo()); //un-name Foo temporary obj; 
  fun( fc1+fc2); // just like ftemp 
  fun(1) // implicit change from 1 to Foo
• part3, When you define a object of a class, you may make a mistake.
  Foo fo; //define a obj 
  Foo fo(); //error decalre a function fo 
  //fo take nothing and return Foo.
• part4, Now let see this example. I want to build a list obj, name is data. But compiler think that I declare a function, name is data, take two arguments, and return a list<int>.
  list<int> data(istream_iterator<int>(dataFile), 
     //think as double(d); such as double d. 
     //in fact, it’s istream_iterator<int> temp (dataFile) 
      istream_iterator<int> () 
      //think as a function pointer. 
              );
• part5, you need to write below code to define a list obj. Detail can be seen in effective STL item 6.
  istream_iterator<int> beg (dataFile); 
  istream_iterator<int> end; 
   
  list<int> data(beg, end);