How to use recursion in std::list? - c++

Question

I am having trouble executing this block of code. The first base condition of this code(for searching a string in a list of strings) does not work. Thanks.
int string_check(list<string> l,list<string>::iterator it,string s)
{
if(it==l.end()) return 0;
if(*it==s) return 1;
return(string_check(l,++it,s));
}

Answer 1

You're passing the list by value, so l.end() is the end of a different list each time, and never the one that it came from.
Either pass the list by reference; or pass the end iterator rather than the list itself. That would be a more flexible solution, allowing you to decouple the function from a specific container type and support any range of input iterators:
template <typename InIter, typename T>
bool contains(InIter begin, InIter end, T const & value) {
if (begin == end) return false;
if (*begin == value) return true;
return contains(++begin, end, value);
}
Recursion is often a bad idea, as the stack is typically fairly small and causes horrible bugs if it overflows. Unless this is an exercise in implementing such a function, use iteration:
for (; begin != end; ++begin) {
if (*begin == value) return true;
}
return false;
or the standard library:
return std::find(begin, end, value) != end;

Answer 2

You need to write int string_check(const list<string>& l, const list<string>::iterator it&, const string& s) instead.
Else you're taking a value copy of the std::list and the iterator, so any modifications to them will not be reflected in the caller.
I'm passing the objects by constant reference. This helps program stability since the function body cannot modify the parameters passed. I'm also passing the string in this way too in order to prevent an unnecessary value copy.

Answer 3

I would define the function differently. It is enough to specify a pair of iterators that specify the target range in the list.
bool string_check( std::list<std::string>::const_iterator first,
std::list<std::string>::const_iterator last,
const std::string &s )
{
return ( first != last ) &&
( *first == s || string_check( ++first, last, s ) );
}
That is there is no need to pass also the list itself.
The same way you could define a template function that could deal with any type of the list. Only the name of the function you should select more suitable.
For example
template <class InputIterator, class T>
bool find( InputIterator first,
InputIterator last,
const T &value )
{
return ( first != last ) &&
( *first == value || string_check( ++first, last, value ) );
}
As for your function implementation then the first parameter that is the list shall be be declared as reference
list<string> &l
Moover it should be declared as a const reference
const list<string> &l
that the function could be called for constant list. In this case you have also to change the type of the iterator.