1.2.1.1 class categories

• Basic class categories:
  1. Value class, such as std::pair, std::vector, std::string.
     1. Has a public destructor, copy ctor and assignment with value semantics
     2. Has no virtual function. so intended to be used as a concrete class, not as a base class.
     3. instantiated on stack or as a member of an other class.
  2. Base class.
     1. Has a destructor that is public and virtual, But for some trait class, destructor can be protected, such as std::unary_function
     2. Establish interface.
     3. Usually instantiated on heap, and used via a (smart) pointer or reference to support polymorphism.
  3. Trait class.
     1. Contain only typedef and static functions, It has no modifiable state.
     2. Is not instantiated( ctor is private or disable)
     3. Usually instantiated on heap, and used via a (smart) pointer.
• Policies are classes (or class templates) to inject behavior into a parent class, typically through inheritance. Through decomposing a parent interface into orthogonal (independent) dimensions, policy classes form the building blocks of more complex interfaces. An often seen pattern is to supply policies as user-definable template (or template-template) parameters with a library-supplied default. An example from the Standard Library are the Allocators, which are policy template parameters of all STL containers
  template<class T, class Allocator = 
                           std::allocator<T> > class vector;
• Traits are class templates to extract properties from a generic type. There are two kind of traits: single-valued traits and multiple-valued traits. Examples of single-valued traits are the ones from the header <type_traits>. Single-valued traits are often used in template-metaprogramming and SFINAE tricks to overload a function template based on a type condition.
  template< class T > 
  struct is_integral{ 
      static const bool value 
       /* = true if T is integral, false otherwise */; 
      typedef std::integral_constant<bool, value> type; 
  }; 
   
  template <class T> 
  T f(T i){ 
      static_assert(std::is_integral<T>::value, "Integer␣required."); 
      return i; 
  } 
   
  int main() { 
      std::cout << f(123) << ’\n’; //output 123 
  }