Перегрузка - C++ - Ответ 1973924

#ifndef SET_H
#define SET_H
 
#include <memory>
#include <functional>
#include <deque>
 
namespace ext {
 
using namespace std;
 
template   <typename T>
class  set  {
public:
 
    //construct/copy/destroy:
    explicit   set();
 
    set(const set<T>& x);
 
    set<T>& operator=(set<T> const& x);
 
    ~set();
 
    // capacity:
    bool                empty()   const { return cont.empty(); }
    size_t              size()  const { return cont.size(); }
 
    //operators:
    set<T> const& operator+(set<T> const& rhs);
    set<T> const& operator-(set<T> const& rhs);
    set<T> const& operator*(set<T> const& rhs);
    bool operator==(set<T> const& rhs);
 
    //modifiers:
    void  swap(set<T>&);
    void  clear();
    void  add(T const&);
    bool  find(T const&);
    void  remove(T const&);
 
private:
    deque<T> cont;
 
};
 
 
 
 
 
//construct/copy/destroy:
template <typename T> set<T>::set()
{
 
}
 
 
template <typename T> set<T>::set(set<T> const& x)
    :
      cont(x.cont)
{
 
}
 
 
template <typename T> set<T>::~set()
{
 
}
 
 
template <typename T> set<T>::set<T>& set<T>::operator=(set<T> const& x)
{
    cont = x.cont;
}
 
 
//modifiers:
 
template <typename T> void set<T>::clear()
{
    cont.clear();
}
 
 
template <typename T> void set<T>::swap(set<T>& rhs)
{
    cont.swap(rhs);
}
 
 
template <typename T> void set<T>::add(T const& newItem)
{
    if (cont.size() == 0)
    {
        cont.push_back(newItem);
        return;
    }
 
    for (typename deque<T>::iterator it = cont.begin(); it != cont.end(); ++it)
    {
        if (*it < newItem)
            cont.insert(it, newItem);
        if (*it == newItem)
            return;
    }
}
 
template <typename T> bool set<T>::find(T const& item)
{
    for (typename deque<T>::const_iterator it = cont.begin(); *it <= item; ++it)
        if (*it == item)
            return true;
 
}
 
 
 
template <typename T> void set<T>::remove(T const& item)
{
    for (typename deque<T>::const_iterator it = cont.begin(); *it <= item; ++it)
        if (*it == item)
            cont.erase(it);
}
 
 
//operators:
template <typename T> set<T>::set<T> const& set<T>::operator+(set<T> const& rhs)
{
    set<T> newSet(*this);
    
    for (typename deque<T>::const_iterator it = rhs.begin(); it != rhs.end(); ++it)
        newSet.add(*it);
    
    return newSet;
}
 
 
template <typename T> set<T>::set<T> const& set<T>::operator-(set<T> const& rhs)
{
   set<T> newSet(*this);
   
   for (typename deque<T>::const_iterator it = cont.begin(); it != cont.end() ; ++it)
       if (!rhs.find(*it))
           newSet.add(*it);
   
   return newSet;
}
 
 
 
 
 
}
 
#endif // SET_H