[OOP] LV4 - Zadaci + Analiza

// Zadaci
// 1. zadatak
template <typename Type>
void swap(Type *xp, Type *yp)
{
    Type temp = *xp;
    *xp = *yp;
    *yp = temp;
}

template <typename Type>
void sort(Type arr[], int n) {
    int i, j;
    for (i = 0; i < n - 1; i++) {
        for (j = 0; j < n - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                swap(&arr[j], &arr[j + 1]);
            }
        }
    }
}

template <typename Type>
void print(Type arr[], int n) {
    int i;
    for (i = 0; i < n; i++) {
        cout << arr[i] << "\t";
    }
    cout << endl;
}

int main() {
    int i;
    std::srand((unsigned int)std::time(0));

    int *a = new int[10];
    for (i = 0; i < 10; i++) {
        a[i] = (int)rand() * 10 / (int)RAND_MAX;
    }
    sort(a, 10);
    print(a, 10);

    double *b = new double[10];
    for (i = 0; i < 10; i++) {
        b[i] = (double)rand() * 10 / (double)RAND_MAX;
    }
    sort(b, 10);
    print(b, 10);

    char *c = new char[10];
    for (i = 0; i < 10; i++) {
        c[i] = (char)rand() * 10 / (char)RAND_MAX;
    }
    sort(c, 10);
    print(c, 10);

    delete[] a;
    delete[] b;
    delete[] c;

    return 0;
}

// 2. zadatak
template <typename Type>
class Stack {
private:
    Type* mData;
    int mSize;
    int mTop;
public:
    Stack(int size) : mSize(size) {
        mTop = -1;
        mData = new Type[mSize];
    }

    Stack(const Stack& ref) {
        mTop = ref.mTop;
        mSize = ref.mSize;
        mData = new Type[mSize];
        for (int i = 0; i < mSize; i++) {
            mData[i] = ref.mData[i];
        }
    }

    ~Stack() {
        delete[] mData;
    }

    Type& operator[](int idx) {
        return mData[idx];
    }

    Stack& operator=(const Stack& ref) {
        if (this != &ref) {
            mSize = ref.mSize;
            mData = new Type[mSize];
            for (int i = 0; i < mSize; i++) {
                mData[i] = ref.mData[i];
            }
        }
        return *this;
    }

    bool push(const Type& x) {
        if (mTop >= (mSize - 1)) {
            cout << "Stack Overflow";
            return false;
        }
        else {
            mData[++mTop] = x;
            cout << x << " pushed into stack\n";
            return true;
        }
    }

    Type pop() {
        if (mTop < 0) {
            cout << "Stack Underflow";
            return 0;
        }
        else {
            Type x = mData[mTop--];
            return x;
        }
    }

    void top() {
        cout << mData[mTop] << endl;
    }
};


int main() {
    Stack<int> first(10);
    Stack<double> second(7);
    Stack<int> third = first;
    std::srand((unsigned int)time(0));
    for (int i = 0; i < 10; i++) {
        int random = (int)rand() * 10 / (int)RAND_MAX;
        first.push(random);
    }
    cout << first.pop() << endl;
    first.top();

    for (int i = 0; i < 7; i++) {
        double random = (double)rand() * 10 / (double)RAND_MAX;
        second.push(random);
    }
    cout << second.pop() << endl;
    second.top();

    for (int i = 0; i < 10; i++) {
        int random = (int)rand() * 10 / (int)RAND_MAX;
        third.push(random);
    }
    cout << third.pop() << endl;
    third.top();

    return 0;
}

// Analiza
// 1. Napiši predloške funkcija Max() i Min() koje kao parametre primaju
// jednodimenzionalna polja i broj elemenata u polju.Funkcije pronalaze i kao
// rezultat vraćaju najveći odnosno najmanji element polja.Funkciju testirati na
// tri dinamički alocirana polja različitog tipa.

template <typename Type>
Type Max(Type arr[], int n) {
    int i;
    Type max = arr[0];
    for (i = 0; i < n; i++) {
        if (arr[i] > max) {
            max = arr[i];
        }
    }

    return max;
}

template <typename Type>
Type Min(Type arr[], int n) {
    int i;
    Type min = arr[0];
    for (i = 0; i < n; i++) {
        if (arr[i] < min) {
            min = arr[i];
        }
    }

    return min;
}

int main() {
    int i;

    int *a = new int[10];
    for (i = 0; i < 10; i++) {
        a[i] = (int)rand() * 10 / (int)RAND_MAX;
    }
    cout << "Max: " << Max(a, 10) << "\tMin: " << Min(a, 10) << endl;

    double *b = new double[10];
    for (i = 0; i < 10; i++) {
        b[i] = (double)rand() * 10 / (double)RAND_MAX;
    }
    cout << "Max: " << Max(b, 10) << "\tMin: " << Min(b, 10) << endl;

    char *c = new char[10];
    for (i = 0; i < 10; i++) {
        c[i] = (char)rand() * 10 / (char)RAND_MAX;
    }
    cout << "Max: " << Max(c, 10) << "\tMin: " << Min(c, 10) << endl;

    return 0;
}

// 2. Napiši predložak klase UređeniPar() koja predstavlja uređeni par dvaju
// objekata.Podatkovni članovi su dva dinamički alocirana objekta, a klasa mora
// imati konstruktore(default, parametarski i kopije), destruktor, operator = i
// operatore usporedbe.U glavnoj funkciji testirati funkcionalnost klase za tri
// različita tipa podatka.

template <typename Type>
class OrderedPair {
private:
    Type *mFirst;
    Type *mSecond;
public:
    OrderedPair() : mFirst(new Type()), mSecond(new Type()) {}

    OrderedPair(Type First, Type Second) : mFirst(new Type(First)), mSecond(new Type(Second)) {}

    OrderedPair(const OrderedPair& Ref) {
        mFirst = new Type();
        mSecond = new Type();
        *mFirst = *Ref.mFirst;
        *mSecond = *Ref.mSecond;
    }

    ~OrderedPair() {
        delete mFirst;
        delete mSecond;
    }

    OrderedPair& operator= (const OrderedPair& Ref) {
        if (&Ref == this) return *this;

        *mFirst = *Ref.mFirst;
        *mSecond = *Ref.mSecond;
        return *this;
    }

    friend bool operator== (const OrderedPair& lhs, const OrderedPair& rhs)
    {
        return *lhs.mFirst == *rhs.mFirst && *lhs.mSecond == *rhs.mSecond;
    }

    friend bool operator!= (const OrderedPair& lhs, const OrderedPair& rhs)
    {
        return !operator==(lhs, rhs);
    }
};


int main()
{
    OrderedPair<double> A(5.123, 6.187);
    OrderedPair<double> B(A);

    cout << (A == B) << endl;

    OrderedPair<int> C(1, 6);
    OrderedPair<int> D(-6, 8);
    OrderedPair<int> E;
    E = D;

    cout << (D != E) << endl;

    OrderedPair<char> F;
    OrderedPair<char> G('z', 'v');
    F = G;

    cout << (F == G) << endl;

    return 0;
}