Using C++ templates to switch algorithms - c++

Question

I have a C++ class that has a pointQuery function. Currently, when I have to switch between linear and binary search, I comment the other part of the code. I saw this post, and tried to refactor my code. My code goes something as:
namespace searchStrategy{
struct linearSearch{};
struct binarySearch{};
}
template<typename T, typename LookupStrategy> class leaf:public rtNode<T>{
public:T points[maxCapLeaf][d]; // search to be done on this array
// some other class members, most of which used in the search
template<typename searchStrategy::linearSearch> bool pointQuery(const T* f) const{
// some code
}
template<typename searchStrategy::binarySearch> bool pointQuery(const T* f) const{
// some code
}
};
The class' objects are created as:
leaf<T, LookupStrategy>* temp = new leaf<T, LookupStrategy>(some_input_params);
where LookupStrategy is searchStrategy::binarySearch or searchStrategy::linearSearch.
When I compile it, I get the following error:
/file_address/template.cpp:164:39: error: non-type template parameters of class type only available with ‘-std=c++2a’ or ‘-std=gnu++2a’
164 | template<typename searchStrategy::linearSearch> bool pointQuery(const T* f) const{
| ^~~~~~~~~~~~
/file_address/template.cpp:200:39: error: non-type template parameters of class type only available with ‘-std=c++2a’ or ‘-std=gnu++2a’
200 | template<typename searchStrategy::binarySearch> bool pointQuery(const T* f) const{
| ^~~~~~~~~~~~
/file_address/template.cpp:200:58: error: ‘template<class T, class LookupStrategy> template<<typeprefixerror><anonymous> > bool leaf<T, LookupStrategy>::pointQuery(const T*) const’ cannot be overloaded with ‘template<class T, class LookupStrategy> template<<typeprefixerror><anonymous> > bool leaf<T, LookupStrategy>::pointQuery(const T*) const’
200 | template<typename searchStrategy::binarySearch> bool pointQuery(const T* f) const{
| ^~~~~~~~~~
/file_address/template.cpp:164:58: note: previous declaration ‘template<class T, class LookupStrategy> template<<typeprefixerror><anonymous> > bool leaf<T, LookupStrategy>::pointQuery(const T*) const’
164 | template<typename searchStrategy::linearSearch> bool pointQuery(const T* f) const{
|
Can someone please explain what am I doing wrong, and how can I fix this? (Please note that the function needs to remain in the class itself, I can't shift it to the namespace because a lot of class members are used in the search functions) Thanks...

Answer 1

namespace searchStrategy {
struct linearSearch{};
struct binarySearch{};
}
template<typename T, typename LookupStrategy> class leaf: public rtNode<T> {
private:
// Overload 1
bool pointQuery(const T* f, linearSearch) const {
// some code
}
// Overload 2
bool pointQuery(const T* f, binarySearch) const {
// some code
}
public:
T points[maxCapLeaf][d];
bool pointQuery(const T* f) const {
return pointQuery(points, LookupStrategy{});
}
};

Answer 2

(partial) specialization might be a solution, but member/function cannot be partial specialized, you might then partial specialize the whole class.
As alternatives,
In C++17, you might use if constexpr:
bool pointQuery(const T* f) const
{
if constexpr (std::is_same_v<LookupStrategy, searchStrategy::linearSearch>)
// some code
} else { // searchStrategy::binarySearch
// some code
}
}
In C++20, requires:
bool pointQuery(const T* f) const
requires(std::is_same_v<LookupStrategy, searchStrategy::linearSearch>)
{
// some code
}
bool pointQuery(const T* f) const
requires(std::is_same_v<LookupStrategy, searchStrategy::binarySearch>)
{
// some code
}
In previous standard, you might use tag dispatching:
private:
bool pointQuery(searchStrategy::linearSearch, const T* f) const
{
// some code
}
bool pointQuery(searchStrategy::binarySearch, const T* f) const
{
// some code
}
public:
bool pointQuery(const T* f) const
{
return pointQuery(LookupStrategy{}, f);
}