// 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.
 
#include <iostream>
#include <cstdlib>
#include <ctime>
 
using namespace std;
 
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.
 
#include <iostream>
 
using namespace std;
 
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;
}