Описать класс “множество”

#include <iostream>
#include <cstdlib>
 
template<typename T>
class tset {
    enum { max_init = 16 };
private:
    T*     arr;
    size_t cnt;
    size_t mem;
public:
    tset(void):arr(NULL), cnt(0), mem(max_init){}
    tset(const tset&);
    ~tset(){
        this->clear();
    }
public:
    //вставка уникальных элементов
    bool add(const T& val){
        size_t i = __index(val);
        if(i == (size_t)~0)
            return false;
 
        if(! __alloc())
            return false;
 
        if(i < cnt){
            for(size_t p = cnt; p > i; --p)
                arr[p] = arr[p - 1];
        }
        arr[i] = val;
        ++cnt;
        return true;
    }
 
    //двоичный поиск вхождения элемента
    bool is_find(const T& val) const {
        return (__index(val) == (size_t)~0);
    }
 
    //удаление по-индексу
    void erase(size_t i){
        if(i < cnt){
            --cnt;
            for(size_t p = i; p < cnt; ++p)
                arr[p] = arr[p + 1];
 
            if(! cnt)
                clear();
        }
    }
 
    //удаление всех
    void clear(void){
        if(arr != NULL)
            delete[] arr;
        arr = NULL;
        cnt = 0;
        mem = max_init;
    }
 
    //пересечение
    static void intersect(const tset& sa, const tset& sb, tset& res){
        const T* p1 = sa.begin(), *e1 = sa.end();
        const T* p2 = sb.begin(), *e2 = sb.end();
        res.clear();
        while((p1 != e1) && (p2 != e2)){
            if(*p1 < *p2)
                ++p1;
            else if(*p2 < *p1)
                ++p2;
            else {
                res.add(*p1++);
                ++p2;
            }
        }
    }
    
    //разность
    static void difference(const tset& sa, const tset& sb, tset& res){
        const T* p1 = sa.begin(), *e1 = sa.end();
        const T* p2 = sb.begin(), *e2 = sb.end();
        res.clear();
        while((p1 != e1) && (p2 != e2)){
            if(*p1 < *p2)
                res.add(*p1++);
            else if(*p2 < *p1)
                ++p2;
            else {
                ++p1;
                ++p2;
            }
        }
 
        while(p1 != e1)
            res.add(*p1++);
    }
 
    //объединение
    static void set_union(const tset& sa, const tset& sb, tset& res){
        const T* p1 = sa.begin(), *e1 = sa.end();
        const T* p2 = sb.begin(), *e2 = sb.end();
        res.clear();
        while((p1 != e1) && (p2 != e2)){
            if(*p1 < *p2)
                res.add(*p1++);
            else if(*p2 < *p1)
                res.add(*p2++);
            else {
                res.add(*p1++);
                ++p2;
            }
        }
 
        while(p1 != e1)
            res.add(*p1++);
        while(p2 != e2)
            res.add(*p2++);
    }
 
    //обращение как к обычному массиву [x]
    const T& operator [] (size_t i) const {
        return arr[i];
    }
 
    const T* begin(void) const { return arr; }
    const T* end(void)   const { return arr + cnt; }
 
    bool   empty(void) const { return (arr == NULL);}
    size_t size(void)  const { return cnt; }
    tset&  operator = (const tset&);
private:
    //реаллокация
    bool __alloc(void){
        if(arr == NULL){
            arr = new (std::nothrow) T[mem];
            if(arr == NULL)
                return false;
        } else if((cnt + 1) >= mem){
            size_t num = cnt + 1 + mem / 2;
            T*     tmp = new (std::nothrow) T[num];
            if(tmp == NULL)
                return false;
 
            for(size_t i = 0; i < cnt; ++i)
                tmp[i] = arr[i];
 
            delete[] arr;
            arr = tmp;
            mem = num;
        }
        return true;
    }
 
    //двоичный поиск
    size_t __index(const T& val) const {
        size_t a, b, m;
        if(!cnt || (val < arr[0]))
            return 0;
        else if(arr[cnt - 1] < val)
            return cnt;
 
        for(a = m = 0, b = cnt; a < b; ){
            m = a + ((b - a) >> 1);
            if(val < arr[m])
                b = m;
            else if(arr[m] < val)
                a = ++m;
            else {
                m = ~0;
                break;
            }
        }
        return m;
    }
};
 
//печать
template<typename T>
void output_set(std::ostream& _out, const tset<T>& ss, const char* delim = " "){
    for(size_t i = 0; i < ss.size(); ++i)
        _out << ss[i] << delim;
    _out << std::endl;
}
 
 
int main(void){
    tset<int> s1, s2, res;
 
    size_t i;
    for(i = 0; i < 10; ++i){
        s1.add(rand() % 10);
        s2.add(rand() % 12);
    }
    std::cout << "count s1: [" << s1.size() << "]: ";
    output_set(std::cout, s1);
 
    std::cout << "count s2: [" << s2.size() << "]: ";
    output_set(std::cout, s2);
 
    //пересечение
    tset<int>::intersect(s1, s2, res);
    std::cout << "set intersection: ";
    output_set(std::cout, res);
 
    //разность
    tset<int>::difference(s1, s2, res);
    std::cout << "set difference: ";
    output_set(std::cout, res);
 
    //объединение
    tset<int>::set_union(s1, s2, res);
    std::cout << "set union: ";
    output_set(std::cout, res);
 
    if(res.is_find(7))
        std::cout << "Цифра семь входит." << std::endl;
 
    s1.clear();
    s2.clear();
    res.clear();
    return 0;
}