template <typename T, std::size_t Maxsize> 
class Stack {
private:
  std::array<T, Maxsize> elems; // elements
  std::size_t numElems;         // current number of elements
public:
  Stack();                  // constructor
  void push(T const &elem); // push element
  void pop();               // pop element
  T const &top() const;     // return top element
  bool empty() const {      // return whether the stack is empty
    return numElems == 0;
  }
  std::size_t size() const { // return current number of elements
    return numElems;
  }
};

template <typename T, std::size_t Maxsize>
Stack<T, Maxsize>::Stack() : numElems(0)  {
  // nothing else to do
}

template <typename T, std::size_t Maxsize>
void Stack<T, Maxsize>::push(T const &elem) {
  assert(numElems < Maxsize);
  elems[numElems] = elem; 
  ++numElems;        
}

Stack<int,20> int20Stack;       // stack of up to 20 ints
Stack<int,40> int40Stack;       // stack of up to 40 ints
Stack<std::string,40> stringStack;     // stack of up to 40 strings 

template<int Val, typename T>
T addValue (T x) {
return x + Val;
}

std::transform(source.begin(), source.end(), dest.begin(), addValue<5, int>);

template <bool _Bp, class _If, class _Then>
    struct _LIBCPP_TEMPLATE_VIS conditional {typedef _If type;};

template <bool, class _Tp = void> struct _LIBCPP_TEMPLATE_VIS enable_if {};

template <auto value> void f() { }

f<10>();               // deduces int

template <typename Type, Type value> constexpr Type TConstant = value;

constexpr auto const MySuperConst = TConstant<int, 100>;

template <auto value> constexpr auto TConstant = value;

constexpr auto const MySuperConst = TConstant <100>;

template<auto Val, typename T = decltype(Val)>
T foo();

template<auto Val> struct Value {
   using ArgType = decltype(Val);
};

template<decltype(auto) N>
class C {
...
};
int i;
C<(i)> x;      // N is int&