Genericka niza

Генеричка низа Problem 1 (2 / 8)
Да се креира генеричка класа Array за работа со низи. Класата треба во себе да ги вклучи:

покажувач кон елементи од соодветниот тип
број на елементи во рамките на низата
Елементите во рамките на објектот треба динамички да се алоцираат. Класата треба да ги поддржува следниве методи:

void Erase() - ги брише сите елементи од низата
Т operator[](int i) - за пристап до соодветниот елемент во низата (вклучувајќи и проверка дали индексот е во границите)
int GetLength() - го враќа бројот на елементите во низата
Да се преоптовари operator<< (ostream) за работа со класата (да се претпостави дека елементите од низата го имаат преоптоварено операторот <<).

Надвор од класата да се напишат следниве функции:

void BubbleSort(Array<T> t&)  - ги сорира елементите користејќи го BubbleSort алгоритмот (да се претпостави дека операторот > e преоптоварен за елементите од класата).

Т Sum(Array<T> &) - ги сумира елементите (да се претпостави дека операторот += e преоптоварен за елементите од класата).

Т Average(Array<T>&) - користејќи ја функцијата за сума пресметува просечна вредност на елементите ( операторот / е преоптоварен за елементите)

bool Equal (Array<T>&, Array<M>&) - проверува дали низите се еднакви (се претпоставува дека операторот == е преоптоварен за соодветните класи)

bool Equal (Array <T>&, Array<double>& ) - која ќе изврши пацијална специјализација и ќе смета дека:
 - два елементи се исти ако и само ако се разликуваат за помалку од 0.1
 - разликата од просечната вредност на низите мора да е помала од 0.5.

#include <iostream>
#include <cmath>
#include <cstdlib>

using namespace std;

template <typename T>
class Array {
private:
    int n; // broj na elementi na nizata
    T *elementi; // pokazhuvach kon elementi od tip T
public:
    Array<T> (int n) {
        elementi = new T[n];
        this->n=n;
    }
    void Erase () {
        for(int i=0; i<n; i++)
            delete elementi[i];
        delete [] elementi;
    }
    T &operator[] (int i) { // const
        if(i>=0&&i<n)
            return elementi[i];
    }

    int getLength() {
        return n;
    }

    friend ostream& operator<< (ostream &out, const Array<T> &a) {
        for (int i=0; i<a.n; i++)
            if(i==a.n-1) out<<"Array["<<i<<"] = "<<a.elementi[i];
            else out<<"Array["<<i<<"] = "<<a.elementi[i]<<", ";
        return out;
    }
};

template <typename T>
void BubbleSort(Array<T> &t) { // ги сорира елементите користејќи го BubbleSort алгоритмот
    T temp;
    for(int i=0; i<t.getLength(); i++) // t<dolzinata
        for(int j=i; j<t.getLength()-1; j++) //t<dolzinata-1 *so isklucok na posledniot clen na nizata)
            if(t[i]>t[j]) {
                temp=t[i];
                t[i]=t[j];
                t[j]=temp;
            }
}

template <typename T>
T Sum(Array<T> &t) { // ги сумира елементите (да се претпостави дека операторот += e преоптоварен за елементите од класата).
    T vk = 0;
    for(int i=0; i<t.getLength(); i++)
        vk+=t[i];
    return vk;
}

template <typename T>
double Average(Array<T> &t) { // користејќи ја функцијата за сума пресметува просечна вредност на елементите
    return Sum(t)/t.getLength();
}

template <typename T,typename M>
bool Equal (Array<T> &t, Array<M> &m) { // проверува дали низите се еднакви
    if(t.getLength()!=m.getLength())
        return false;
    bool flag=false;
    for(int i=0; i<t.getLength(); i++)
        if(t[i]==m[i])
            flag=true;
        else {
            flag=false;
            break;
        }
    return flag;
}
template <typename T>
bool Equal (Array <T> &t, Array<double> &d) // која ќе изврши пацијална специјализација и ќе смета дека:
// два елементи се исти ако и само ако се разликуваат за помалку од 0.1
// разликата од просечната вредност на низите мора да е помала од 0.5.
{
    if(t.getLength()!=d.getLength()) return false;
    bool flag1=false,flag2=false;
    for(int i=0; i<t.getLength(); i++)
        if(abs(t[i]-d[i])<0.1) flag1=true;
        else {
            flag1=false;
            break;
        }
    if(abs(Average(t)-Average(d))<0.5)
        flag2=true;
    else flag2=false;
    if(flag1&&flag2) // akko se true dvete
        return true;
    else return false;
}

int main()
{

    int n;
    double r;

    cin>>r;
    cin>>n;

    Array<int> anArray(n);
    Array<double> adArray(n);
    Array<int> intArray2(n);

    for (int nCount = 0; nCount < n; nCount++)
    {

        cin>>anArray[nCount];
        adArray[nCount] = anArray[nCount] + r;
    }

    BubbleSort(anArray);

    intArray2 = anArray;

    cout<<"The arrays: "<<endl;
    cout<<anArray;
    cout<<endl<<"and "<<endl;
    cout<<intArray2;
    cout<<endl;
    cout<<((Equal(anArray,intArray2))?" ARE":" ARE NOT")<<" same!"<<endl;
    cout<<"The Average of the array adArray is: "<<Average(adArray)<<endl;

    cout<<"The arrays: "<<endl;
    cout<<anArray;
    cout<<endl<<"and "<<endl;
    cout<<adArray;
    cout<<endl;
    cout<<((Equal(anArray,adArray))?" ARE":" ARE NOT")<<" same!";


    return 0;
}