sbu21TemplateAutoDeclType

#include <iostream>

void testFun()
{
    std::cout << "TestFun is here!!!\n";
}

void print()
{
    testFun();
    std::cout << "Print function test!\n";
    return;
    testFun();
}

int random(int start, int end, bool withEnd = false)
{
    //int end{ 0 };
    //std::cout << "Enter upper limit\n";
    //std::cin >> end;
    //std::cout << (rand() % 10 + 0.125) << '\n';

    return (rand() % ((end - start) + withEnd) + start);
}

void swap(int a, int b)
{
    std::cout << "SWAP: a = " << a << ' ' << " b = " << b << '\n';
    int tmp{ a };
    a = b;
    b = tmp;
    std::cout << "SWAP: a = " << a << ' ' << " b = " << b << '\n';
}

void printArr(int arr[], int arrSize)
{
    for (int i{ 0 }; i < arrSize; ++i)
    {
        std::cout << arr[i] << ' ';
    }
    std::cout << '\n';
}

void printArr(float arr[], int arrSize)
{
    for (int i{ 0 }; i < arrSize; ++i)
    {
        std::cout << arr[i] << ' ';
    }
    std::cout << '\n';
}

void printArr(char arr[], int arrSize)
{
    for (int i{ 0 }; i < arrSize; ++i)
    {
        std::cout << arr[i] << ' ';
    }
    std::cout << '\n';
}
void print2DArr(int arr[][4], int arrSizeY, int arrSizeX)
{
    for (int y{ 0 }; y < arrSizeY; ++y)
    {
        for (int x{ 0 }; x < arrSizeX; ++x)
        {
            std::cout << arr[y][x] << ' ';
        }
        std::cout << '\n';
    }
    std::cout << '\n';
}

int global{ 55 };

//int max(int a, int b) { return a > b ? a : b; };
//int max(int a, int b, int c) { return max(a, max(b, c)); };
//int max(int a, int b, int c, int d) { return max(max(a, b), max(c, d)); }
//
//int max(int arr[], int arrSize)
//{
//    int maxEl{ arr[0] };
//    for (int i{ 0 }; i < arrSize; ++i)
//    {
//        //maxEl = maxEl < arr[i] ? arr[i] : maxEl;
//        maxEl = max(maxEl, arr[i]);
//    }
//    return maxEl;
//}
//int max(int arr[][5], int arrSizeY, int arrSizeX)
//{
//    int maxEl{ arr[0][0] };
//
//    for (int y{ 0 }; y < arrSizeY; ++y)
//    {
//        maxEl = max(maxEl, max(arr[y], arrSizeX));
//    }
//    return maxEl;
//}
//
//double max(double a, double b) { return a > b ? a : b; };
//double max(double a, double b, double c) { return max(a, max(b, c)); };
//double max(double a, double b, double c, double d) { return max(max(a, b), max(c, d)); }
//
//char max(char a, char b) { return a > b ? a : b; };
//char max(char a, char b, char c) { return max(a, max(b, c)); };
//char max(char a, char b, char c, char d) { return max(max(a, b), max(c, d)); }
//
//float max(float a, float b) { return a > b ? a : b; };
//float max(float a, float b, float c) { return max(a, max(b, c)); };
//float max(float a, float b, float c, float d) { return max(max(a, b), max(c, d)); }

template <typename T>
T max(T a, T b) { return a > b ? a : b; };
template <typename T>
T max(T a, T b, T c) { return max(a, max(b, c)); };
template <typename T>
T max(T a, T b, T c, T d) { return max(max(a, b), max(c, d)); }

template <typename T>
T max(T arr[], int arrSize)
{
    T maxEl{ arr[0] };
    for (int i{ 0 }; i < arrSize; ++i)
    {
        maxEl = max(maxEl, arr[i]);
    }
    return maxEl;
}

template <typename T>
T max(int arr[][5], int arrSizeY, int arrSizeX)
{
    T maxEl{ arr[0][0] };

    for (int y{ 0 }; y < arrSizeY; ++y)
    {
        maxEl = max(maxEl, max(arr[y], arrSizeX));
    }
    return maxEl;
}

int count()
{
    static int cnt{ 0 };
    return ++cnt;
}

template <typename T, typename T1>
auto max(T a, T1 b)->decltype(a+b) { return a > b ? a : b; };

//int max() {};
//auto max()->int {};

int main()
{
    const int arrSize{ 10 };
    int arr[arrSize]{};
    float massiv[10]{ 11.34,2.64,3.22,44.2,5.90,23.1,4.11,8.56,1.6,0.125 };
    char str[5]{ 'a','s','d','f','g' };
    bool mainFlag{ true };
    int begin{};
    int end{};
    const int arrSizeY{ 3 };
    const int arrSizeX{ 4 };
    int arr2D[arrSizeY][arrSizeX]{ {1,2,3,4}, {5,6,7,8}, {9,10,11,12} };

    //auto num{ 42 };
    ////int num{42};

    //auto temperature{ 36 };
    //temperature = 37.75;
    //std::cout << temperature << '\n';
    //int x{ 0 };
    //float z{ 36.6 };

    //decltype((x++ + ++x) / z + 124 * (z += 6)) temp;




    //printArr(str, 5);
    //print2DArr(arr2D, arrSizeY, arrSizeX);

    // double max(double,double)
    std::cout << max(24.5, (double)25) << '\n';
    // double max(double,double)
    std::cout << max<double>(24.5, 25) << '\n';


    /*template <typename T, typename T1>
    T max(T a, T1 b) { return a > b ? a : b; };*/

    //double max(double , int)
    std::cout << max(24.5, 24) << '\n';

    //double max(int,double)
    std::cout << max(24, 24.5) << '\n';

    return 0;
    /*for (int i{ 0 }; i < 5; ++i)
    {
        std::cout << count() << ' ';
    }
    std::cout << '\n';

    return 0;*/

    /*int x{ 10 };
    int y{ 20 };

    std::cout << "x = " << x << ' ' << " y = " << y << '\n';
    swap(x, y);
    std::cout << "x = " << x << ' ' << " y = " << y << '\n';*/


    /*std::cout << "Enter bottom limit\n";
    std::cin >> begin;
    std::cout << "Enter upper limit\n";
    std::cin >> end;*/

    for (int i{ 0 }; i < arrSize; ++i)
    {
        //  std::cout << begin <<".." << end << " - " << random(begin,end) << '\n';
        //std::cout << "50..99 - " << random(50,100) << '\n';
        arr[i] = random(20, 100);
        std::cout << arr[i] << ' ';
    }
    std::cout << '\n';

    //printArr(massiv, 10);

    std::cout << '\n';

    return 0;
}