Auswählen einer Funktionsimplementierung basierend auf iterator::value_type
Frage
Ich suche nach einer vernünftigen Möglichkeit, einen Sortieralgorithmus basierend auf dem Werttyp des Containers auszuwählen.
In seiner jetzigen Form kann ich die richtige ableiten sort(a, b)
für ganzzahlige / nicht ganzzahlige Daten.
#include <cstdlib>
#include <type_traits>
#include <algorithm>
#include <vector>
#include <iostream>
namespace sort_selector{
template<typename T>
void _radix_sort(T begin, T end){
// radix implementation
}
template<typename T>
typename std::enable_if<
std::is_integral<typename T::value_type>::value>::type
sort(T begin, T end){
std::cout << "Doing radix" << std::endl;
sort_selector::_radix_sort(begin, end);
}
template<typename T>
typename std::enable_if<
!std::is_integral<typename T::value_type>::value>::type
sort(T begin, T end){
std::cout << "Doing sort" << std::endl;
std::sort(begin, end);
}
}
int main(int argc, char** argv) {
std::vector<double> for_stdsort = {1, 4, 6, 2};
std::vector<int32_t> for_radixsort = {1, 4, 6, 2};
//std::array<int32_t, 4> array_for_radixsort = {1, 4, 6, 2};
sort_selector::sort(std::begin(for_stdsort), std::end(for_stdsort));
sort_selector::sort(std::begin(for_radixsort), std::end(for_radixsort));
//sort_selector::sort(std::begin(array_for_radixsort),
// std::end(array_for_radixsort));
return 0;
}
- Ich würde gerne Array-ähnliche Iteratoren verwenden können.(sie haben keinen ::value_type).
- Ich würde gerne zwischen int32_t und int64_t unterscheiden können.
Ich bin völlig ratlos, wie ich das auf einigermaßen einfache Weise erreichen kann.Z.B.nicht für jeden Fall spezialisiert.
Lösung
Verwenden std::iterator_traits<T>::value_type
so rufen Sie den Werttyp eines Iterators ab;es funktioniert sowohl für Zeiger als auch für Klassentyp-Iteratoren.
Für den Versand würde ich die Template-Spezialisierung verwenden, um die richtige Implementierung auszuwählen (Live-Vorführung):
namespace sort_selector {
// Default to using std::sort
template <typename T, typename = void>
struct dispatcher {
template <typename Iterator>
static void sort(Iterator begin, Iterator end) {
std::cout << "Doing std::sort\n";
std::sort(begin, end);
}
};
// Use custom radix sort implementation for integral types
template <typename T>
struct dispatcher<T, typename std::enable_if<std::is_integral<T>::value>::type> {
template <typename Iterator>
static void sort(Iterator, Iterator) {
std::cout << "Doing radix\n";
// radix implementation
}
};
// Use some other specific stuff for int32_t
template <>
struct dispatcher<int32_t, void> {
template <typename Iterator>
static void sort(Iterator, Iterator) {
std::cout << "Specific overload for int32_t\n";
// Do something
}
};
// Dispatch appropriately
template <typename Iterator>
inline void sort(Iterator begin, Iterator end) {
dispatcher<typename std::iterator_traits<Iterator>::value_type>::sort(begin, end);
}
} // namespace sort_selector
Sie sollten wahrscheinlich einschränken sort_selector::sort
iteratoren mit wahlfreiem Zugriff zu benötigen, damit Ihre Fehlermeldungen besser verdaulich sind, wenn jemand unweigerlich versucht, einen falschen Iteratortyp zu übergeben:
namespace sort_selector {
// Dispatch appropriately
template <typename Iterator>
inline void sort(Iterator begin, Iterator end) {
using traits = std::iterator_traits<Iterator>;
static_assert(
std::is_base_of<
std::random_access_iterator_tag,
typename traits::iterator_category
>::value, "sorting requires random access iterators");
dispatcher<typename traits::value_type>::sort(begin, end);
}
} // namespace sort_selector