Example for template, callback function

dependent.cpp

template<class Container>
void doWork(Container& container)
{
  Container::iterator it;
  Container::iterator * it_ptr;
}

struct Person
{
  static int iterator;
};
int it_ptr = 1;
int main()
{
  doWork(vector<int>{1,2,3,4,5});
  doWork(Person());
  return 0;
}

func_ptr.cpp

int doWork(long l, int i, std::string str)
{
  // do work here.
}

bool isWorking(int state)
{
  // check here
}

typedef int (*func_ptr_type)(long, int, std::string);

int main()
{
  func_ptr_type fp = doWork;
  fp(1, 1, "abcd");
  
  bool (*fp2)(int) = isWorking;
  fp2(1);
  return 0;
}

functor.cpp

struct Comparer
{
  int operator()(int left, int right)
  {
    return left - right;
  }
};

int main()
{
  Comparer comparer;
  cout << comparer(2, 1);
  return 0;
}

static_polymorphism.cpp

template< class T >
class CCounter 
{
public:
	bool CanPerformAction() {
		return static_cast<T*>(this)->canPerformActionImpl();
	}
};
  
class D1: public CCounter< D1 > 
{
	friend class CCounter< D1 >;
private:
	bool canPerformActionImpl() 
	{
		return true;
	}
};
  
class D2: public CCounter< D2 > 
{
	friend class CCounter< D2 >;
private:
	bool canPerformActionImpl() 
	{
		return false;
	}
};

template_disambiguator.cpp

template<typename T>
struct S {
  template<typename U> void foo(){}
};
 
template<typename T>
void bar()
{
  S<T> s;
  s.foo<T>(); // error: < parsed as less than operator
  s.template foo<T>(); // OK
}

template<typename T>
class Foo
{
  template<typename U> void foo(){}
  
  template<typename U, typename V>
  void bar(U)
  {
    S<T> s;
    s.foo<U>(); // error: < parsed as less than operator
    s.template foo<U>(); // OK
    T::template foo<V>(); // OK
    this->template foo<U>(); // OK
    
    typename T::template iterator<int>::value_type v; 
  }
}

template_specilization.cpp

/*
 * Copy from http://coliru.stacked-crooked.com/view?id=5a098714e58041fb
 * which introduced at http://en.cppreference.com/w/cpp/language/template_specialization
 */

#include <iostream>
template<typename T>   // primary template
struct is_void : std::false_type
{
};
template<>  // explicit specialization for T = void
struct is_void<void> : std::true_type
{
};
int main()
{
    // for any type T other than void, the 
    // class is derived from false_type
    std::cout << is_void<char>::value << '\n'; 
    // but when T is void, the class is derived
    // from true_type
    std::cout << is_void<void>::value << '\n';
    return 0;
}