Explanation:
#include <iostream>
#include <vector>
#include <iomanip>
using namespace std;
/*
Overloading means equal function name with different call prototype each.
It's a useful tool that lets you think once and write similar role code twice or more times keeping equal function name.
Please look at lines 12-14: they are overloaded call prototype versions of LinearSearch with identical mission (to know if a value is present in a set)
*/
//#define GENERICS
#ifndef GENERICS // Conditional compilation statement
bool LinearSearch(vector<int> ,int);
bool LinearSearch(vector<float> ,float);
bool LinearSearch(vector<double>,double);
#else // Conditional compilation statement (uncomment line 10 statement)
template <typename genType>
bool LinearSearch(vector<genType> v, genType value); // LinearSearch (generic type parameters version)
#endif
int main(int argc, char *argv[]) { // Test code follows:
vector<int> vInt {1, -2, 3, -4, 5}; // Test data (int)
vector<float> vFlo {1.23456f, -2.35f, 3.1416f, -4.7f, 5.55f}; // Test data (float)
vector<double> vDou {1.234567890123456789, -2.35, 3.1415927, -4.7, 5.55}; // Test data (double)
cout <<3 << " is " << (LinearSearch(vInt,3) ?"":"not ") << "in: {";for(auto x:vInt) cout << setw(11) << x;cout << "}\n";
cout <<3.1416f<< " is " << (LinearSearch(vFlo,3.1416f)?"":"not ") << "in: {";for(auto x:vFlo) cout << setw(11) << x;cout << "}\n";
cout <<3.14 << " is " << (LinearSearch(vDou,3.1416) ?"":"not ") << "in: {";for(auto x:vDou) cout << /*setprecision(9)<<*/setw(11) << x;cout << "}\n";
return 0;
}
#ifndef GENERICS
// Overloaded function code follows:
bool LinearSearch(vector<int> v, int value) { // LinearSearch (integer parameters version)
bool found = false; // Until now we haven't found the value we are searching for,
for(auto x:v) found = found || x == value; // but if it is here found becomes true.
return(found);
}
bool LinearSearch(vector<float> v, float value) { // LinearSearch (float parameters version)
bool found = false;
for(auto x:v) found = found || x == value;
return(found);
}
bool LinearSearch(vector<double> v, double value) { // LinearSearch (double float parameters version)
bool found = false;
for(auto x:v) found = found || x == value;
return(found);
}
/*
So far, so good. It works! But, despite there was little effort involved, redundant code remains.
Is there any solution? Yes! It's called generic programming.
*/
#else
/*
Consider the following code:
- Template statement at first accepts a generic type as a parameter (genType)
- genType is used for both parameters (array and value to search)
- Template statements located after generic version of LinearSearch instructs compiler to generate each type version
Conclusions:
- Compared with overloaded versions generic code is more elegant and avoids completely redundancy
- It enhances overloading while keeping its advantages
*/
template <typename genType>
bool LinearSearch(vector<genType> v, genType value) { // LinearSearch (generic type parameters version)
bool found = false; // Until now we haven't found the value we are searching for,
for(auto x:v) found = found || x == value; // but if it is here found becomes true.
return(found);
}
template bool LinearSearch(vector<int> ,int);
template bool LinearSearch(vector<float> ,float);
template bool LinearSearch(vector<double>,double);
#endif