Using ternary operator on std::map with std::greater additional argument - c++

Question

I have two std::maps. One uses std::greater in the constructor so it is sorted the opposite direction:
std::map<key, value> map1;
std::map<key, value, std::greater> map2;
Currently I have two functions, one per map, each iterating over the elements and processing. However, given the processing logic is the same (only the map iteration direction is different) I wanted to replace these two functions with one:
template<bool useMap1>
void combinedFunc()
{
std::map<key, value>& map = useMap1 ? map1 : map2;
std::map<key, value>::iterator iter = map.begin();
// A fair amount of code iterating over the elements, hence wishing to combine
}
However, the compiler is rightfully saying that map1 and map2 are incompatible types.
Is there a way to reuse the code, even with std::greater?

Answer 1

Is there a way to reuse the code, even with std::greater?
Here's one way.
Create two overloaded functions for dealing with the two maps.
Move the core logic of dealing with the items of the maps to another function that works with iterators.
template <typename Iterator>
void coreFunction(Iterator start, Iterator end) { ... }
// For map1
void functionForMap(std::true_type dummyArgument)
{
coreFunction(map1.begin(), map1.end());
}
// for map2
void functionForMap(std::false_type dummyArgument)
{
coreFunction(map2.begin(), map2.end());
}
template<bool useMap1>
void combinedFunc()
{
functionForMap(std::integral_constant<bool, useMap1>());
}
Still simpler -- this requires only the first function.
template<bool useMap1>
void combinedFunc()
{
useMap1 ? coreFunction(map1.begin(), map1.end()) : coreFunction(map2.begin(), map2.end());
}

Answer 2

Instead of a template argument that implies what type to use, why not be direct and specify which type to use? Something like:
template<class M>
void combinedFunc(const M & map) // Drop "const" if necessary
{
M::iterator iter = map.begin();
// A fair amount of code iterating over the elements, hence wishing to combine
}
The caller is then responsible for specifying the map.
combinedFunc(map1); // The template parameter should be deducible.
This has the benefit of not locking your template to only two specific maps. On the downside, the caller has to know about map1 and map2. This might be undesirable if combinedFunc is part of a public interface, while the maps are not. In that case, you could write a wrapper function for the interface. Something simple like the following should work.
void publicFunc(bool useMap1)
{
if ( useMap1 )
combinedFunc(map1);
else
combinedFunc(map2);
}
Note that this calls two distinct functions even though the syntax makes it look like the same one. (You cannot do something like combinedFunc(useMap1 ? map1 : map2);.)