Что такое шаблоны в C++?

template<>
struct numeric_limits<bool>

template<typename _Tp>
    struct numeric_limits<const _Tp>
    : public numeric_limits<_Tp> { };

template
<typename
_Tp>
struct
numeric_limits
<const
_Tp>
:
public
numeric_limits
<_Tp>
{
};

template<typename _Tp> struct numeric_limits<const _Tp>: public numeric_limits<_Tp> { };

  /// numeric_limits<bool> specialization.
  template<>
    struct numeric_limits<bool>
    {
      static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true;
 
      static _GLIBCXX_CONSTEXPR bool 
      min() _GLIBCXX_USE_NOEXCEPT { return false; }
 
      static _GLIBCXX_CONSTEXPR bool 
      max() _GLIBCXX_USE_NOEXCEPT { return true; }
 
#if __cplusplus >= 201103L
      static constexpr bool
      lowest() noexcept { return min(); }
#endif
      static _GLIBCXX_USE_CONSTEXPR int digits = 1;
      static _GLIBCXX_USE_CONSTEXPR int digits10 = 0;
#if __cplusplus >= 201103L
      static constexpr int max_digits10 = 0;
#endif
      static _GLIBCXX_USE_CONSTEXPR bool is_signed = false;
      static _GLIBCXX_USE_CONSTEXPR bool is_integer = true;
      static _GLIBCXX_USE_CONSTEXPR bool is_exact = true;
      static _GLIBCXX_USE_CONSTEXPR int radix = 2;
 
      static _GLIBCXX_CONSTEXPR bool 
      epsilon() _GLIBCXX_USE_NOEXCEPT { return false; }
 
      static _GLIBCXX_CONSTEXPR bool 
      round_error() _GLIBCXX_USE_NOEXCEPT { return false; }
 
      static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0;
      static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0;
      static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0;
      static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0;
 
      static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false;
      static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false;
      static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false;
      static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm 
       = denorm_absent;
      static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false;
 
      static _GLIBCXX_CONSTEXPR bool 
      infinity() _GLIBCXX_USE_NOEXCEPT { return false; }
 
      static _GLIBCXX_CONSTEXPR bool 
      quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return false; }
 
      static _GLIBCXX_CONSTEXPR bool 
      signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return false; }
 
      static _GLIBCXX_CONSTEXPR bool 
      denorm_min() _GLIBCXX_USE_NOEXCEPT { return false; }
 
      static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false;
      static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true;
      static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false;
 
      // It is not clear what it means for a boolean type to trap.
      // This is a DR on the LWG issue list.  Here, I use integer
      // promotion semantics.
      static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps;
      static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false;
      static _GLIBCXX_USE_CONSTEXPR float_round_style round_style 
       = round_toward_zero;
    };

template<typename T>
class F
{
};
 
template<>
class F<int> : public F<int>
{
};

struct FTraits
{
   typedef void void_type;
};
 
template<typename T>
struct F : FTraits
{
   static constexpr int value = 0;
};
 
template<>
struct F<int> : Ftraits
{
   static constexpr int value = std::numeric_limits<int>::max();
};
 
static_assert(std::is_same<F<int>::void_type, F<double>::void_type>::value, "Not same");
static_assert(F<int>::value != F<double>::value, "Equals in primary and in spec");
 
int main() {}

#ifndef TARRAY_HPP_INCLUDED
#define TARRAY_HPP_INCLUDED
//=================================================================================================
template <class TItem> class TArray
{
//-------------------------------------------------------------------------------------------------
 protected:
//-------------------------------------------------------------------------------------------------
  TItem             *Data;
  size_t             Count;
//-------------------------------------------------------------------------------------------------
 public   :
//-------------------------------------------------------------------------------------------------
                     TArray          (                          );
                     TArray          (TArray           &Original);
//-------------------------------------------------------------------------------------------------
                    ~TArray          (                          );
//-------------------------------------------------------------------------------------------------
  TArray             operator =      (const
                                      TArray           &Original);
//-------------------------------------------------------------------------------------------------
  TItem             &operator []     (size_t            Index   );
//-------------------------------------------------------------------------------------------------
                     operator bool   (                          );
                     operator size_t (                          );
//-------------------------------------------------------------------------------------------------
  bool               ReSieze         (size_t            Count   );
//-------------------------------------------------------------------------------------------------
};
//=================================================================================================
template
<class TItem>
TArray <TItem> ::    TArray          (                          )
{
 Data =NULL;
 Count=0;
}
//-------------------------------------------------------------------------------------------------
template
<class TItem>
TArray <TItem> ::    TArray          (TArray           &Original)
{
 TItem *Source;
 TItem *Target;
 if (Original.Count>0)
 {
  Data=new TItem [Original.Count];
  if (Data)
  {
   for (Source=Original.Data+Original.Count-1, Target=Data+Original.Count-1; Target>=Data; --Source, --Target)
   {
    *Target=*Source;
   }
   Count=Original.Count;
  }
  else
  {
   Count=0;
  }
 }
 else
 {
  Data =NULL;
  Count=0;
 }
}
//-------------------------------------------------------------------------------------------------
template
<class TItem>
TArray <TItem> ::   ~TArray          (                          )
{
 if (Data)
 {
  delete [] Data;
 }
 Data =NULL;
 Count=0;
}
//-------------------------------------------------------------------------------------------------
template
<class TItem>
TArray <TItem>
TArray <TItem> ::    operator =      (const
                                      TArray           &Original)
{
 TItem *Source;
 TItem *Target;
 if (Original.Count>0)
 {
  Data=new TItem [Original.Count];
  if (Data)
  {
   for (Source=Original.Data+Original.Count-1, Target=Data+Original.Count-1; Target>=Data; --Source, --Target)
   {
    *Target=*Source;
   }
   Count=Original.Count;
  }
  else
  {
   Count=0;
  }
 }
 else
 {
  Data =NULL;
  Count=0;
 }
 return *this;
}
//-------------------------------------------------------------------------------------------------
template
<class TItem>
TItem               &
TArray <TItem> ::    operator []     (size_t            Index   )
{
 return Data[Index];
}
//-------------------------------------------------------------------------------------------------
template
<class TItem>
TArray <TItem> ::    operator bool   (                          )
{
 return (Count>0);
}
//-------------------------------------------------------------------------------------------------
template
<class TItem>
TArray <TItem> ::    operator size_t (                          )
{
 return Count;
}
//-------------------------------------------------------------------------------------------------
template
<class TItem>
bool
TArray <TItem> ::    ReSieze         (size_t            Count   )
{
 TItem  *Buffer;
 TItem  *Source;
 TItem  *Target;
 size_t  ForCopy;
 if (Count<(std::numeric_limits<size_t>::max()/sizeof(TItem)))
 {
  if (Count==0)
  {
   if (Data)
   {
    delete [] Data;
   }
         Data =0;
   this->Count=0;
   return true;
  }
  else
  {
   Buffer=new TItem [Count];
   if (Buffer)
   {
    if (Count>this->Count)
    {
     ForCopy=this->Count;
    }
    else
    {
     ForCopy=Count;
    }
    if (ForCopy>0)
    {
     for (Source=Data+ForCopy-1, Target=Buffer+ForCopy-1; Source>=Data; --Source, --Target)
     {
      *Target=*Source;
     }
    }
    if (Data)
    {
     delete [] Data;
    }
          Data =Buffer;
    this->Count=Count;
    return true;
   }
   else
   {
    return false;
   }
  }
 }
 return false;
}
//=================================================================================================
#endif // TARRAY_HPP_INCLUDED

TArray <TStaffList>         StaffLists;