1.6.8 Other

• Alias declaration is better than typedef.
  // FP is a synonym for a pointer to a function taking an int 
  // and a const std::string& and returning nothing 
  typedef void (*FP)(int, const std::string&); 
   
  using FP = void (*)(int, const std::string&); 
  // alias declaration
• C++ doesn’t support typedef template directly, only can be put inside a struct.
  template<typename T> // MyAllocList<T> 
  using MyAllocList = std::list<T, MyAlloc<T>>; 
  // is synonym for std::list<T, MyAlloc<T>> 
  MyAllocList<Widget> lw; // client code 
   
  template<typename T> 
  struct MyAllocList { 
  typedef std::list<T, MyAlloc<T>> type; 
  }; 
  // MyAllocList<T>::type is synonym for std::list<T,  MyAlloc<T>> 
  MyAllocList<Widget>::type lw; // client code
• MyAllocList<T>::type is thus a dependent type, and one of C++’s many endearing rules is that the names of dependent types must be preceded by typename.
  template<typename T> 
  class Widget { // Widget<T> contains 
  private: // a MyAllocList<T> 
  typename MyAllocList<T>::type list; // as a data member 
  }; 
   
  template<typename T> 
  using MyAllocList = std::list<T, MyAlloc<T>>; // as before 
   
  template<typename T> 
  class Widget { 
  private: 
  MyAllocList<T> list; // no "typename" and no "::type" 
  };
  template<typename T> 
  struct type{ typedef std::vector<T> sometype; } 
   
  template<typename TT> 
  void someFunction( typename type<TT>::sometype& myArg ); 
  //You need typename here, because sometype is depended T. 
  //typename indicates type<TT>::sometype is a type. 
   
  std::vector<int> a; 
  someFunction(a); // error, cannot deduce ’TT’ 
  someFunction<int>(a); 
   
   
  template<typename T> 
  using sometype = std::vector<T>; 
  template<typename T> 
  void someFunction(sometype<T> &myArg ); 
   
  std::vector<int> a; 
  someFunction(a);
• C++14 offers alias templates for all the C++11 type traits transformations.
  template <class T> 
  using remove_const_t = typename remove_const<T>::type; 
  template <class T> 
  using remove_reference_t = typename remove_reference<T>::type; 
  template <class T> 
  using add_lvalue_reference_t = 
  typename add_lvalue_reference<T>::type;
• scoped enums
  1. C++98-style enums are now known as unscoped enums.
     enum Color { black, white, red }; 
     // black, white, red are in same scope as Color 
     auto white = false; // error! white already 
      
     enum class Color { black, white, red }; 
     // black, white, red are scoped to Color 
     auto white = false; // fine, no other 
      
     Color c = white; // error! 
     Color c = Color::white; // fine 
     auto c = Color::white; // also fine (and in accord 
     // with Item 5’s advice)
  2. Enumerators of scoped enums are visible only within the enum. They convert to other types only with a cast.
     enum class Color { black, white, red }; // enum is now scoped 
     Color c = Color::red; // as before, but 
     ... // with scope qualifier 
     if (c < 14.5) { // error! can’t compare 
     // Color and double
  3. Both scoped and unscoped enums support specification of the underlying type. The default underlying type for scoped enums is int. Unscoped enums have no default underlying type.
  4. Scoped enums may always be forward-declared. Unscoped enums may be forward-declared only if their declaration specifies an underlying type.
• Prefer deleted functions to private undefined ones. because Any function may be deleted, including non-member functions and template instantiations.
  template <class charT, class traits = char_traits<charT> > 
  class basic_ios : public ios_base { 
  public: 
  basic_ios(const basic_ios& ) = delete; 
  basic_ios& operator=(const basic_ios&) = delete; 
  }; 
   
  bool isLucky(int number); // original function 
  bool isLucky(char) = delete; // reject chars 
  bool isLucky(bool) = delete; // reject bools 
   
  template<typename T> 
  void processPointer(T* ptr); 
  template<> 
  void processPointer<void>(void*) = delete; 
  //you can’t not use void to instantiate
• noexcept
  1. When an exception is throwed from an noexcept function, std::terminate gets triggered. compiler will not check it for you.
  2. noexcept is part of a function’s interface, and that means that callers may depend on it.
  3. noexcept functions are more optimizable than non-noexcept functions.
  4. noexcept is particularly valuable for the move operations, swap, memory deallocation functions, and destructors.
  5. Most functions are exception-neutral rather than noexcept.
• Member in Class Initialization.
  class Section{ 
  int m_a = 10; 
  }