Angenommen, ich habe sechs Typen, die jeweils einer konzeptionellen Kategorie angehören.
Hier ist ein Diagramm, das dies zeigt:

Oder vielleicht ein konkretes Beispiel für Sie:

Ich möchte zwei Funktionen schreiben, die alle 6 Typen behandeln.
Typen in "Kategorie 1" werden auf eine bestimmte Art und Weise behandelt, und Typen in "Kategorie 2" werden auf eine andere Art und Weise behandelt.

Kommen wir zum Code. Zuerst erstelle ich die sechs Typen.

//Category 1 Types
class Type_A{};
class Type_B{};
class Type_C{};

//Category 2 Types
class Type_D{};
class Type_E{};
class Type_F{};

Als Nächstes erstelle ich zwei Typmerkmale, damit die Kategorie des Typs beim Kompilieren ermittelt werden kann.

/* Build The Category 1 Type Trait */

//Type_A Type Trait
template <typename T>
struct Is_Type_A {
  static const bool value = false;
};
template <>
struct Is_Type_A<Type_A> {
  static const bool value = true;
};

//Type_B Type Trait
template <typename T>
struct Is_Type_B {
  static const bool value = false;
};
template <>
struct Is_Type_B<Type_B> {
  static const bool value = true;
};

//Type_C Type Trait
template <typename T>
struct Is_Type_C {
  static const bool value = false;
};
template <>
struct Is_Type_C<Type_C> {
  static const bool value = true;
};

//Category 1 Type Trait
template <typename T>
struct Is_Type_From_Category_1 {
  static const bool value = Is_Type_A<T>::value || Is_Type_B<T>::value || Is_Type_C<T>::value;
};

/* Build The Category 2 Type Trait */

//Type_D Type Trait
template <typename T>
struct Is_Type_D {
  static const bool value = false;
};
template <>
struct Is_Type_D<Type_D> {
  static const bool value = true;
};

//Type_E Type Trait
template <typename T>
struct Is_Type_E {
  static const bool value = false;
};
template <>
struct Is_Type_E<Type_E> {
  static const bool value = true;
};

//Type_F Type Trait
template <typename T>
struct Is_Type_F {
  static const bool value = false;
};
template <>
struct Is_Type_F<Type_F> {
  static const bool value = true;
};

//Category 1 Type Trait
template <typename T>
struct Is_Type_From_Category_2 {
  static const bool value = Is_Type_D<T>::value || Is_Type_E<T>::value || Is_Type_F<T>::value;
};

Nun, da ich zwei Typmerkmale habe, um zu unterscheiden, in welche Kategorie jeder der sechs Typen fällt, möchte ich zwei Funktionen schreiben. Eine Funktion akzeptiert alles aus Kategorie 1, und die andere Funktion akzeptiert alles aus Kategorie 2. Gibt es eine Möglichkeit, dies zu tun, ohne eine Art Dispatching-Funktion zu erstellen? Kann ich einen Weg finden, um nur zwei Funktionen zu haben? eine für jede Kategorie?

BEARBEITEN: Ich habe versucht, enable_if wie folgt zu verwenden, aber ein solcher Versuch führt zu einem Compilerfehler.

//Handle all types from Category 1
template<class T ,class = typename std::enable_if<Is_Type_From_Category_1<T>::value>::type >
void function(T t){
    //do category 1 stuff to the type
    return;
}

//Handle all types from Category 2
template<class T ,class = typename std::enable_if<Is_Type_From_Category_2<T>::value>::type >
void function(T t){
    //do category 2 stuff to the type
    return;
}

Bearbeiten 2: Ich habe den im Link angegebenen Code ausprobiert, aber dies ist keine Ja- oder Nein-Entscheidung, ob die Funktion aufgerufen werden soll oder nicht. Es ist die Funktion, die ich mit zwei Typmerkmalen aufrufe. Dies wäre ein Neudefinitionsfehler.

//Handle all types from Category 2
template<class T, class dummy = typename std::enable_if< Is_Type_From_Category_1<T>::value, void>::type>
void function(T t){
    //do category 1 stuff to the type
    return;
}
//Handle all types from Category 2
template<class T, class dummy = typename std::enable_if< Is_Type_From_Category_2<T>::value, void>::type>
void function(T t){
    //do category 2 stuff to the type
    return;
}