Why do we use a wrapper function for a recursive function? - c++

Question

What is the purpose of a wrapper over recursive function?
Why can't we directly call the recursive function from the main function?
I've come across some explanations saying that wrapper function helps in better parameter passing - I don't understand this.
EDIT:
Consider the example of a binary search based function that returns the index of a peak element:
int findPeakUtil(int arr[], int low,
int high, int n)
{
// Find index of middle element
int mid = low + (high - low)/2;
// Compare middle element with its neighbours (if neighbours exist)
if ((mid == 0 || arr[mid - 1] <= arr[mid]) &&
(mid == n - 1 || arr[mid + 1] <= arr[mid]))
return mid;
// If middle element is not peak and its
// left neighbour is greater than it,
// then left half must have a peak element
else if (mid > 0 && arr[mid - 1] > arr[mid])
return findPeakUtil(arr, low, (mid - 1), n);
// If middle element is not peak and its
// right neighbour is greater than it,
// then right half must have a peak element
else return findPeakUtil(arr, (mid + 1), high, n);
}
// A wrapper over recursive function findPeakUtil()
int findPeak(int arr[], int n)
{
return findPeakUtil(arr, 0, n - 1, n);
}
Why is it recommended to use the wrapper function?

Answer 1

A wrapper function can prepare a call of a recursive function. For example a recursive function has more parameters then initially the user supplies. Or can make a preliminary checks of the validity of arguments and tests pre-conditions.
Here is a simple example provided for the demonstrative purpose.
#include <iostream>
#include <cstring>
char * recursive_reverse( char *s, size_t n )
{
if ( n < 2 ) return s;
char c = s[0];
s[0] = s[n-1];
s[n-1] = c;
recursive_reverse( s + 1, n - 2 );
return s;
}
char * reverse( char *s )
{
return recursive_reverse( s, std::strlen( s ) );
}
int main()
{
char s[] = "Hello DEBNATH KUNDU";
std::cout << s << '\n';
std::cout << reverse( s ) << '\n';
return 0;
}
The program output is
Hello DEBNATH KUNDU
UDNUK HTANBED olleH
Another example is when a class has a non-static public member function that calls a static (private/protected) recursive member function passing to it required data members of the object of the class. So in this case the non-static member function provides the public interface and the non-static recursive function provides the implementation of the interface.
Here is one more demonstrative program.
#include <iostream>
#include <utility>
#include <cstring>
class String
{
private:
enum Size : size_t { N = 100 };
char s[N];
static void recursive_reverse( char *s, size_t n )
{
if ( not ( n < 2 ) )
{
std::swap( s[0], s[n-1] );
recursive_reverse( s + 1, n - 2 );
}
}
public:
explicit String( const char *s )
{
strncpy( this->s, s, N );
this->s[N-1] = '\0';
}
void reverse() { recursive_reverse( s, std::strlen( s ) ); }
friend std::ostream & operator <<( std::ostream &os, const String &s )
{
return os << s.s;
}
};
int main()
{
String s( "Hello DEBNATH KUNDU" );
std::cout << s << '\n';
s.reverse();
std::cout << s << '\n';
return 0;
}
Its output is the same as shown above.
However it does not mean that a wrapper function is always required.