_>#ifndef __z_size_inc__
_>#define __z_size_inc__

_>#include <cassert>
_>#include <algorithm> // for std::swap
_>#include <limits> // std::numeric_limits

_>namespace z { // очень содержательное имя у namespace :-\

_>template<typename>
_>class basic_size;

_>typedef basic_size<unsigned> size;

_>template<typename T>
_>class basic_size {
_>public:
_>    explicit basic_size(T w=0, T h=0): // имхо, это извращение.
_>        w_(w), h_(h) {}
        // нужно два конструктора - без параметров и почленный (оба члена обязательны)

_>    template<typename U>
_>    explicit basic_size(const basic_size<U>& s):
_>        w_(s.w_), h_(s.h_) {}

_>    template<typename U>
_>    basic_size& operator=(const basic_size<U>& s) { 
_>        basic_size<T>(s).swap(*this); 
_>        return *this; 
_>    }
        // зачем эксплицитный конструктор копирования из basic_size<U>,
        // если у тебя есть оператор присваивания этого типа?
        // Надо забить на оператор присваивания болт, пусть дефолтный работает.
        // И реализация через swap неэффективна.

_>    bool empty() const
_>        { return w_==0 && h_==0; }

_>    T w() const
_>        { return w_; }

_>    T h() const
_>        { return h_; }


_>    void setw(T w)
_>        { w_=w; }

_>    void seth(T h)
_>        { h_=h; }

_>    void set(T w, T h)
_>        { setw(w); seth(h); }

_>    template<typename U>
_>    bool operator==(const basic_size<U>& s) const
_>        { return w_==s.w_ && h_==s.h_; }
        // По смыслу неправомерно.
        // Если ты будешь сравнивать в плавающей арифметике или знаковые/беззнаковые, огребёшь проблемы.
        // С точки зрения безопасности программирования, нужно сравнивать только со своим типом
        // (да и то, с оговорками про плавающую арифметику)

_>    template<typename U>
_>    bool operator!=(const basic_size<U>& s) const 
_>        { return !(*this==s); }


_>    const basic_size& operator+=(T d) {
_>        assert((std::numeric_limits<T>::max()-d>=w_) &&
_>            (std::numeric_limits<T>::max()-d>=h_));
_>        w_+=d; h_+=d; 
_>        return *this; 
_>    }
        // Очень опасный по смыслу оператор: сумма вектора со скаляром.
        // Математически, это ботва. Хочешь явно инкрементировать все компоненты сразу -
        // напиши функцию (функции) с человеческим именем. Это будет наглядно
        // Например, extend_w(w), extend_h(h), extend_wh(w,h), extend_wh(wh)

        // Тем более, что можно складывать векторы разной природы - например, размеры и точки.
        // А у тебя точка здесь выступит как скаляр, что не есть правильно.

_>    template<typename U>
_>    const basic_size& operator+=(const basic_size<U>& s) {
_>        assert((std::numeric_limits<T>::max()-s.w_>=w_) &&
_>            (std::numeric_limits<T>::max()-s.h_>=h_));
_>        w_+=s.w_; h_+=s.h_; 
_>        return *this; 
_>    }

_>    const basic_size& operator-=(T d) { 
_>        assert(d<w_ && d<h_);
_>        w_-=d; h_-=d; 
_>        return *this; 
_>    }

_>    template<typename U>
_>    const basic_size& operator-=(const basic_size<U>& s) { 
_>        assert(s.w_<w_ && s.h_<h_);
_>        w_-=s.w_; h_-=s.h_;
_>        return *this; 
_>    }

_>    const basic_size& operator*=(T k) { 
_>        w_*=k; h_*=k; 
_>        return *this; 
_>    }

_>    template<typename U>
_>    const basic_size& operator*=(const basic_size<U>& s) { 
_>        w_*=s.w_; h_*=s.h_; 
_>        return *this; 
_>    }
        // Опять математическая ботва. Умножение векторов - это:
        // - скалярное умножение, на выходе скаляр
        // - векторное умножение, на выходе ортогональный обоим тензор (в 3-мерном пространстве - вектор)
        // - тензорное умножение, на выходе - матрица
        // - почленное умножение, на выходе - вектор
        // Почему ты здесь выбрал один из возможных? И как он соотносится с геометрическим смыслом типа?

_>    const basic_size& operator/=(T k) { 
_>        assert(k!=0);    
_>        w_/=k; h_/=k; 
_>        return *this; 
_>    }

_>    template<typename U>
_>    const basic_size& operator/=(const basic_size<U>& s) { 
_>        assert(s.w_!=0 && s.h_!=0);
_>        w_/=s.w_; h_/=s.h_; 
_>        return *this; 
_>    }


_>    void swap(basic_size& s) {
_>        std::swap(w_, s.w_);
_>        std::swap(h_, s.h_);
_>    }

_>private:

_>    template<typename U>
_>    friend class basic_size;
        // Если принять во внимание всё сказанное выше, то дружба с коллегами не нужна.
        // Тем более, что у них есть открытые члены для доступа - w(), h().

_>    T w_;
_>    T h_;
_>};

_>template<typename T>
_>basic_size<T> operator+(const basic_size<T>& s, T d) 
_>    { return basic_size<T>(s)+=d; }

_>template<typename T, typename U>
_>basic_size<T> operator+(const basic_size<T>& s1, const basic_size<U>& s2) 
_>    { return basic_size<T>(s1)+=s2; }

_>template<typename T>
_>basic_size<T> operator-(const basic_size<T>& s, T d) 
_>    { return basic_size<T>(s)-=d; }

_>template<typename T, typename U>
_>basic_size<T> operator-(const basic_size<T>& s1, const basic_size<U>& s2) 
_>    { return basic_size<T>(s1)-=s2; }

_>template<typename T>
_>basic_size<T> operator*(const basic_size<T>& s, T d) 
_>    { return basic_size<T>(s)*=d; }

_>template<typename T, typename U>
_>basic_size<T> operator*(const basic_size<T>& s1, const basic_size<U>& s2) 
_>    { return basic_size<T>(s1)*=s2; }

_>template<typename T>
_>basic_size<T> operator/(const basic_size<T>& s, T d) 
_>    { return basic_size<T>(s)/=d; }

_>template<typename T, typename U>
_>basic_size<T> operator/(const basic_size<T>& s1, const basic_size<U>& s2) 
_>    { return basic_size<T>(s1)/=s2; }

// Ты ещё забыл сделать внешний swap().
// Поскольку поиск Кёнига в некоторых компиляторах реализован половинчато
// то есть смысл вынести swap за пределы namespace.

_>} // namespace z

_>#endif //__z_size_inc__
_>

_>struct size {
_>  unsigned w;
_>  unsigned h;
_>}
_>