Одномерный массив

#include <algorithm>
#include <iostream>
#include <cassert>
#include <cstdlib>
#include <cmath>
using namespace std;
 
template<typename T>
class array
{
    typedef unsigned int uint;
public:
    array():used(0),allocated(0),arr(0){}
    array(uint s_count):used(0),allocated(0),arr(0){
        reallocate(s_count);
    }
    array(const array<T> &rhs):arr(0){
        *this = rhs;
    }
 
    ~array(){
        clear();
    }
    void reallocate(uint n_size){
        T* old_arr = arr;
        arr = new T[n_size];
        allocated = n_size;
 
        uint end = used < n_size ? used : n_size;
 
        for(uint i = 0; i < end; ++i)
            arr[i] = old_arr[i];
 
        if(allocated > end)
            for(uint i = end; i < allocated; ++i)
                arr[i] = 0;
 
        used = allocated;
        delete[] old_arr;
    }
 
    void push_back(const T &rhs){
        reallocate(used + 1);
        arr[used - 1] = rhs;
    }
 
    void operator=(const array<T>& rhs){
        if (arr)
            delete[] arr;
 
        if (rhs.allocated == 0)
            arr = 0;
        else
            arr = new T[rhs.allocated]; 
 
        used = rhs.used;
        allocated = rhs.allocated;
 
        for (uint i=0; i<rhs.used; ++i)
            arr[i] = rhs.arr[i];
    }
 
    bool operator == (const array<T>& rhs) const{
        if (used != rhs.used)
            return false;
 
        for (uint i = 0; i < rhs.used; ++i)
            if (arr[i] != rhs[i])
                return false;
        return true;
    }
 
    bool operator != (const array<T>& rhs) const{
        return !(*this == rhs);
    }
 
    T& operator [](uint index){
        assert(index < used);
        return arr[index];
    }
 
    const T& operator [](uint index) const{
        assert(index < used); 
        return arr[index];
    }
 
    const uint size() const{
        return used;
    }
    void clear(){
        if(arr)
            delete[] arr;
        arr = 0;
        used = allocated = 0;
    }
 
    void Input(){
        for(uint i = 0; i < used; ++i){
            cout<<"arr["<<i<<"]: ";
            cin>>arr[i];
        }
    }
 
    void Random(uint max){
        for(uint i = 0; i < used; ++i)
            arr[i] = rand()%max;
    }
 
    void sort_arr(bool (*foo)(int,int))
    {
        std::sort(arr,arr+used,foo);
    }
    const T max_element()
    {
        T max = arr[0];
        for(uint i = 1; i < used; ++i)//!i = 1;
            if(max < arr[i])
                max = arr[i]; //max elem
        return max;
    }
 
    const T max_abs()
    {
        T max = arr[0];
        for(uint i = 1; i < used; ++i)//!i = 1;
            if(abs(max) < abs(arr[i]))
                max = arr[i]; //max elem
        return max;
    }
 
    const T min_element()
    {
        T min = arr[0];
        for(uint i = 1; i < used; ++i)//!i = 1;
            if(min > arr[i])
                min = arr[i]; //min elem
        return min;
    }
 
    const size_t count_element(const T& elem)
    {
        return std::count(arr,arr+used,elem);
    }
    friend ofstream& operator<<(ofstream& stream, const array<T> &rhs);
private:
    T* arr;
    uint used;//
    uint allocated;
 
};
template<typename T>
ostream& operator<<(ostream& stream, const array<T> &rhs){
    stream<<"[ ";
    for(unsigned i = 0; i < rhs.size(); ++i)
        stream<<rhs[i]<<" ";
    stream<<"]";
    return stream;
}
 
bool foo(int i,int j){ return i > j; }
 
int main()
{
    array<int> arr;
    arr.push_back(10);
    arr.push_back(20);
    arr.push_back(30);
    arr.push_back(40);
    cout<<arr.size();
    cout<<endl<<arr[0]<<endl;
    cout<<arr<<endl;
    arr.Random(10);
    arr.sort_arr(foo);
    cout<<arr<<endl;
    cout<<arr.max_element()<<endl;
    cout<<arr.min_element()<<endl;
    cout<<arr.count_element(0)<<endl;
    arr.push_back(-8);
    cout<<arr.max_abs()<<endl;
    return 0;
}