Searching a linked list, Different data types - c++

Question

I've been tasked with making a program that searches 400+ movies (linked together using a linked list) by title, genre, year, rating, lead actor, etc.
There is a catch though, we are only allowed ONE search function to preform the searches through the linked list. Also, within that search function, we are only allowed one while loop—which I assume in my case will be something like...
while (moviePtr != NULL)
Obviously their will be many different instances if its an actor search, or a genre search. In the case of actor, genre, rating, year, sub-genre, and supporting actor, it should output every single instance of it was found. (for example, if Kevin Bacon was in x-men and the notebook, it should output both not just one of them (to the output file not the screen)).
I've found myself completely stumped by these restrictions that we were given.
How will my search function handle different data types? (year and rating have to be declared as integers). How will it know what exactly I'm searching for? If I'm searching for actor, I don't want it to search for title as well.
Any suggestions on how to get started and get going are very appreciated.
EDIT:
Hi all thought id update you guys on what ive done. I have 3 different search functions. One for the numerical values (the year and the rating), 1 for the genre and actors, and lastly one for the title.
Here is the code for all three of them.
First off title seach.
void TitleSearched(MovieNode*head,
string titleSearched,
ofstream& outFile)
{
MovieNode* moviePtr;
bool found;
moviePtr = head;
found = false;
while (moviePtr !=NULL & !found)
{
if (moviePtr-> title == titleSearched)
{
found = true;
}
else
{
moviePtr = moviePtr -> next;
}
}
if (found)
{
cout << endl << titleSearched << " has been found!\n";
TitleOutput (moviePtr,outFile);
}
else
{
cout << endl << titleSearched << " was not found.\n";
}
}
now the year/ rating search.
int NumSearched(MovieNode* head, int numSearched)
{
int instances;
MovieNode* moviePtr;
ofstream outFile;
moviePtr = head;
instances = 0;
while (moviePtr !=NULL)
{
if (moviePtr-> year == numSearched)
{
instances = instances +1;
NumOutList(moviePtr,outFile,"year",numSearched,instances);
moviePtr = moviePtr -> next;
}
else if (moviePtr->rating == numSearched)
{
instances = instances +1;
NumOutList(moviePtr,outFile,"rating",numSearched,instances);
moviePtr = moviePtr -> next;
}
else
{
moviePtr = moviePtr ->next;
}
}
return instances;
}
lastly the genre/actors search.
int ItemSearch (MovieNode* head,string itemSearched, ofstream& outFile)
{
int instances;
MovieNode* moviePtr;
moviePtr = head;
instances = 0;
while (moviePtr !=NULL)
{
if (moviePtr-> genre == itemSearched || moviePtr ->subGenre == itemSearched)
{
instances = instances +1;
OutList(moviePtr,outFile,"Genre",itemSearched,instances);
moviePtr = moviePtr -> next;
}
else if (moviePtr->leadActor == itemSearched || moviePtr->supportActor == itemSearched)
{
instances = instances +1;
OutList(moviePtr,outFile,"Actor",itemSearched,instances);
moviePtr = moviePtr -> next;
}
else
{
moviePtr = moviePtr ->next;
}
}
return instances;
}
I wanted to remind you guys what my task was.
1. Combine these three search functions into one
2.have only ONE while loop in the search
3. only one return in any given function (however, id assume this would be a void function when combined)
My main issue i beileve is my ints and strings. I am not allowed to declare rating or year as strings. And just the format of the code in combing all three in general is giving me a head ache

Answer 1

You could write your search function in a way which accepts a predicate as a parameter. A predicate is some kind of "functionoid" (meaning, anything which has the ability to be "called" like a function - it could be a function, or a lambda, or a function object..)
in the C++ standard library, predicates are used for many of the standard algorithms, so it's common that you'll see code (using standard containers) like this:
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <cctype>
bool begins_with_s(std::string s)
{
return s.length() > 0 &&
std::toupper( s.at(0) ) == 'S';
}
bool contains_a_number(std::string s)
{
return std::find_if(s.begin(), s.end(), std::isdigit) != s.end();
}
int main()
{
std::string movies_array[] =
{
"King Kong",
"Singin in the Rain",
"Die Hard 2",
"Superman",
"Star Wars",
"Jaws 3"
};
std::vector<std::string> movies( std::begin(movies_array),
std::end(movies_array) );
// Use predicate - count if the movie name begins with "S"
std::cout << "Movies beginning with S: "
<< std::count_if(movies.begin(), movies.end(), begins_with_s)
<< std::endl;
// Use predicate - count if the movie name contains a number
std::cout << "Movies containing a number: "
<< std::count_if(movies.begin(), movies.end(), contains_a_number)
<< std::endl;
}
The way that C++ standard algorithms are implemented in this way is to accept a template argument representing the predicate, along the lines of
template< typename PredicateType >
void my_function(PredicateType predicate)
{
Movie my_movie;
predicate(my_movie);
}
It's a technique from the functional programming school of thinking - passing a function to a function (Treating a function as a "first class citizen").

Answer 2

You could have your search function take a "match" function as one its parameters, and call this match function on every movie to see whether the movie matches. You can then call your search function with different match functions.
Something like this:
template <typename MatchFunction>
void search_movies(movie* moviePtr, MatchFunction match)
{
while (moviePtr != NULL)
{
if (match(*moviePtr))
{
// output movie
}
moviePtr = moviePtr->next;
}
}
You could then declare match functions like this:
bool matches_actor(movie& m, const std::string& actor)
{
return m.actor == actor;
}
and call it with specific queries like this:
search_movies(moviePtr, std::bind(matches_actor, _1, "Morgan Freeman"));
(std::bind is a C++11 function from <functional>; you could equivalently use boost::bind or std::bind2nd)
Alternately, if you prefer a more C-style way of doing things, you could do something like this:
void search_movies(movie* moviePtr, bool (*match)(movie*, void*), void* match_arg)
{
while (moviePtr != NULL)
{
if (match(moviePtr, match_arg))
{
// output movie
}
moviePtr = moviePtr->next;
}
}
...
bool matches_actor(movie* m, void* actor)
{
return m.actor == *((std::string*)actor);
}
...
std::string actor = "Morgan Freeman";
search_movies(moviePtr, &matches_actor, (void*)(&actor));

Answer 3

Besides the option of passing a functor to check the match, there are other options. One such option would be taking a set of optional conditions to check (you can use boost::optional or a handcrafted approach, or use pointers. For example:
void print_matching( node* list, int * year, std::string * actor... ) {
// iterate over the list:
while (...) {
if ( ( !year || ptr->year == *year )
&& ( !actor || ptr->actor == *actor )
&& ...
)
{
// Film matches, print it
}
}
}
To simplify the function signature you can create a search_pattern type that encapsulates the fields that you want to test (example using a different approach: bools to determine optionality):
struct pattern {
bool check_actor;
std::string actor;
bool check_year;
int year;
};
void print_matching( node* list, pattern const & p ) {
// iterate over the list:
while (...) {
if ( ( !p.check_year || ptr->year == p.year )
&& ( !p.check_actor || ptr->actor == p.actor )
&& ...
)
{
// Film matches, print it
}
}
}
In this last case, you can actually move the test into the pattern object, and have a function:
bool pattern::matches( movie cosnt& m ) const {
return (!check_year || m.year == year )
&&(!check_actor || m.actor == actor );
}
void print_matching( node* list, pattern const & p ) {
// iterate over the list:
while (...) {
if ( p.matches( list->data ) )
{
// Film matches, print it
}
}
}