Шаблоны и переопределение функции swap

#ifndef SALES_ITEM_H
 
#define SALES_ITEM_H
 
#include <memory>
#include <initializer_list>
#include <iterator>
#include <utility>
 
namespace my
{
    // объявления
    template <typename T> class Stack;
 
    template <typename T>
    void swap (Stack<T>&, Stack<T>&);
 
    template <typename T>
    bool operator == (const Stack<T>&, const Stack<T>&);
 
    template <typename T>
    bool operator != (const Stack<T>&, const Stack<T>&);
 
    template <typename T>
    bool operator < (const Stack<T>&, const Stack<T>&);
 
    template <typename T>
    bool operator > (const Stack<T>&, const Stack<T>&);
 
    template <typename T>
    bool operator <= (const Stack<T>&, const Stack<T>&);
 
    template <typename T>
    bool operator >= (const Stack<T>&, const Stack<T>&);
 
    // класс Stack
    template <typename T>
    class Stack
    {
    public:
    // типы
        using size_type = size_t;
        using value_type = T;
 
    //************************************************
    // данные
    private:
        T* beg = nullptr;
        T* lst = nullptr;
        std::allocator<T> alloc;
 
        void free ();
        void alloc_and_copy (const T*, const T*);
        void reallocate ();
    //************************************************
 
    // интерфейс
    public:
    // конструкторы и функции управления копированием
        Stack () = default;
        Stack (std::initializer_list<T>);
        Stack (const Stack&);
        Stack (Stack&&) noexcept;
        Stack& operator = (const Stack&);
        Stack& operator = (Stack&&) noexcept;
        ~Stack ();
 
    // функции интерфейса
        bool empty () const
        { return lst - beg == 0; }
 
        size_t size () const
        { return lst - beg; }
 
        void push (const T&);
        void pop ();
        T& top ();
        const T& top () const;
        void swap (Stack&);
 
        template <typename ... Args>
        void emplace (Args&& ...);
 
        friend void swap (Stack<T>&, Stack<T>&);
        friend bool operator == <T> (const Stack<T>&, const Stack<T>&);
        friend bool operator != <T> (const Stack<T>&, const Stack<T>&);
        friend bool operator < <T> (const Stack<T>&, const Stack<T>&);
        friend bool operator > <T> (const Stack<T>&, const Stack<T>&);
        friend bool operator <= <T> (const Stack<T>&, const Stack<T>&);
        friend bool operator >= <T> (const Stack<T>&, const Stack<T>&);
    };
 
    // определение функций реализации
    template <typename T>
    void Stack<T>::free ()
    {
        if (lst)
        {
            while (lst != beg)
                alloc.destroy(--lst);
            alloc.deallocate(beg, size());
        }
    }
 
    template <typename T>
    void Stack<T>::alloc_and_copy (const T* frst, const T* scnd)
    {
        beg = alloc.allocate(scnd - frst);
        lst = std::uninitialized_copy(frst, scnd, beg);
    }
 
    template <typename T>
    void Stack<T>::reallocate ()
    {
        auto newbeg = alloc.allocate(size() + 1);
        auto newend = std::uninitialized_copy(std::make_move_iterator(beg),
                                              std::make_move_iterator(lst),
                                              newbeg);
        free();
        beg = newbeg;
        lst = newend;
    }
 
    // определение конструкторов и функций управления копирование
    template <typename T>
    inline Stack<T>::Stack (std::initializer_list<T> il)
    { alloc_and_copy(il.begin(), il.end()); }
 
    template <typename T>
    inline Stack<T>::Stack (const Stack& s)
    { alloc_and_copy(s.beg, s.lst); }
 
    template <typename T>
    inline Stack<T>::Stack (Stack&& s) noexcept: beg(s.beg), lst(s.lst)
    { s.beg = s.lst = nullptr; }
 
    template <typename T>
    Stack<T>& Stack<T>::operator = (const Stack& s)
    {
        if (this != &s)
        {
            free();
            alloc_and_copy(s.beg, s.lst);
        }
        return *this;
    }
 
    template <typename T>
    Stack<T>& Stack<T>::operator = (Stack&& s) noexcept
    {
        if (this != &s)
        {
            free();
            beg = s.beg;
            lst = s.lst;
            s.beg = s.lst = nullptr;
        }
        return *this;
    }
 
    template <typename T>
    inline Stack<T>::~Stack()
    { free(); }
 
    // определение функций интерфейса
    template <typename T>
    void Stack<T>::push (const T& t)
    {
        reallocate();
        alloc.construct(lst++, t);
    }
 
    template <typename T>
    void Stack<T>::pop ()
    {
        if (size() == 0)
            throw std::logic_error("pop() on empty Stack");
        auto newbeg = alloc.allocate(size() - 1);
        auto newtop = std::uninitialized_copy(std::make_move_iterator(beg),
                                              std::make_move_iterator(lst - 1),
                                              newbeg);
        free();
        beg = newbeg;
        lst = newtop;
    }
 
    template <typename T>
    T& Stack<T>::top ()
    { 
        if (size() == 0)
            throw std::logic_error("top() on empty Stack");
        return *(beg + size() - 1);
    }
 
    template <typename T>
    const T& Stack<T>::top () const 
    { 
        if (size() == 0)
            throw std::logic_error("top() on empty Stack");
        return *(beg + size() - 1);
    }
 
    template <typename T>
    template <typename ... Args>
    void Stack<T>::emplace (Args&& ... args)
    {
        reallocate();
        alloc.construct(lst++, std::forward<Args>(args)...);
    }
 
    template <typename T>
    void swap (Stack<T>& s1, Stack<T>& s2)
    {
        using std::swap;
        swap(s1.beg, s2.beg);
        swap(s1.lst, s2.lst);
    }
 
    template <typename T>
    void Stack<T>::swap (Stack& s)
    { 
        using std::swap;
        swap(*this, s);
    }
 
    template <typename T>
    bool operator == (const Stack<T>& s1, const Stack<T>& s2)
    {
        if (s1.size() == s2.size())
        {
            auto ptr1 = s1.beg, ptr2 = s2.beg;
            while (ptr1 != s1.lst)
                if (*ptr1++ != *ptr2++)
                    return false;
            return true;
        }
        return false;
    }
 
    template <typename T>
    bool operator != (const Stack<T>& s1, const Stack<T>& s2)
    { return !(s1 == s2); }
 
    template <typename T>
    bool operator < (const Stack<T>& s1, const Stack<T>& s2)
    {
        if (s1 != s2)
        {
            auto minSize = s1.size() < s2.size() ? s1.size() : s2.size();
            auto ptr1 = s1.beg, ptr2 = s2.beg;
            while (ptr1 != s1.beg + minSize)
            {
                if (*ptr1 != *ptr2 && *ptr1 < *ptr2)
                    return true;
                else if (*ptr1 != *ptr2 && *ptr2 < *ptr1)
                    return false;
                ++ptr1;
                ++ptr2;
            }
 
            if (minSize == s1.size())
                return true;
            else
                return false;
        }
        return false;
    }
 
    template <typename T>
    bool operator > (const Stack<T>& s1, const Stack<T>& s2)
    { return s1 != s2 && !(s1 < s2); }
 
    template <typename T>
    bool operator <= (const Stack<T>& s1, const Stack<T>& s2)
    { return s1 < s2 || s1 == s2;  }
 
    template <typename T>
    bool operator >= (const Stack<T>& s1, const Stack<T>& s2)
    { return s1 > s2 || s1 == s2;  }
}
 
 
#endif