Рекурсивная функция для вычисления индекса максимального элемента массива

void max_search(const int * nums_ptr, unsigned index, const unsigned size, int max)
{
    if (index < size) {
        
        if (nums_ptr[index] > max)
            max = nums_ptr[index];
 
        max_search(nums_ptr, ++index, size, max);
    }       
}
 
 
unsigned max_search(const int * nums_ptr, const unsigned size, int max)
{
    static unsigned call = 1;
    unsigned res = 0;
 
    if (call < size) {
    
        if (*nums_ptr > max)
            max = *nums_ptr;
        
        call += 1;
        res += max_search(++nums_ptr, size, max);
 
        return res;
    }
    else
        return 0;
}
 
 
int main()
{
    const unsigned size = 10;
    int nums[size] = {4, 2, 8, -3, 0, 2, 8, 6, 4, 1};
    unsigned index = 0;
    int max = nums[index];
  
    max_search(nums, ++index, size, max);
    ....                                                     // дальнейшие операции
 
    // или
    const int * nums_ptr = nums;
 
    index = max_search(++nums_ptr, size, max);
    ....
 
    return 0;
}

void max_search(const int * nums_ptr, unsigned index, const unsigned size, unsigned& max)
{
    if (index < size) {
 
        if (nums_ptr[index] > nums_ptr[max])
            max = index;
 
    max_search(nums_ptr, ++index, size, max);
    }
}
 
 
unsigned max_search(const int * nums_ptr, const unsigned size, int max)
{
    static unsigned call = 1;
    unsigned res = 0;
 
    if (call < size) {
 
        int left = nums_ptr[call];
        int right = nums_ptr[max];
 
        if (left > max)
            max = call;
 
        call += 1;
        res = max_search(nums_ptr, size, max);
 
        return res;
    }
    else
        return max;
}

unsigned max_search(const int * nums_ptr, const unsigned size, int max)
{
    static unsigned call = 1;
    unsigned res = 0;
 
    if (call < size) {
        int left = nums_ptr[call];
        int right = nums_ptr[max];
 
        if (left > right)
            max = call;
 
        call += 1;
        res = max_search(nums_ptr, size, max);
 
        return res;
    }
    else
        return max + 1;
}

#include <iostream>
 
 
int FindMax(int* arr, int arrSize, int currPos = 0)
{
    if(currPos >= arrSize)
        return 0;
    int temp = FindMax(arr, arrSize, currPos+1);
    return(arr[temp] > arr[currPos] ? temp : currPos);
}
 
 
int main()
{
    int arr[] = {6, 7, 3, 4, -16, 2};
    std::cout << FindMax(arr, sizeof(arr) / sizeof(int));
    return 0;
}

/////////////////////////////////////////////////////////////////////////////////////////
//Написать рекурсивную функцию для вычисления индекса максимального элемента массива из n элементов.
/////////////////////////////////////////////////////////////////////////////////////////
#include <conio.h>
#include <iostream>
/////////////////////////////////////////////////////////////////////////////////////////
int get_max_of_arr
    (
        int     *   arr,
        int         size
    )
{
    return  --size
                ?   std::max
                        (
                            arr[size],
 
                            get_max_of_arr
                                (
                                    arr,
                                    size
                                )
                        )
 
                :   *arr;
}
/////////////////////////////////////////////////////////////////////////////////////////
int main()
{
    int arr[] = {6, 7, 3, 4, -16, 2};
 
    std::cout   <<  get_max_of_arr
                        (
                            arr,
                            sizeof(arr) / sizeof( *arr )
                        )
 
                <<  std::endl;
 
    getch();
}