C++ - Vorlagen: Wählen Sie verschiedene Typen basierend auf dem Wert der template-parameter

Wie kann ich Folgendes in C++, und was ist zu tun, solche Dinge genannt?

template <bool S>
class NuclearPowerplantControllerFactoryProviderFactory {
  //if S == true
  typedef int data_t;
  //if S == false
  typedef unsigned int data_t;
};

Es gibt zwei viele Factory Wörter in diese Klasse der name, ich glaube, du denkst in Java.
Nein, Sie müssen Ihren controller die Fabrik-provider Fabriken in allen Sprachen.

InformationsquelleAutor porgarmingduod | 2011-11-23

c++templates

16

Durch Spezialisierung:
```
template <bool> class Foo;

template <> class Foo<true>
{
  typedef int data_t;
};

template <> class Foo<false>
{
  typedef unsigned int data_t;
};
```
Können Sie wählen, um einem der beiden Fälle die primäre Vorlage und der andere Spezialisierung, aber ich bevorzuge diese eher symmetrischen version, da bool können nur zwei Werte haben.

_{Wenn dies das erste mal, wenn Sie sehen können, können Sie auch wie zu denken teilweise Spezialisierung:}
```
template <typename T> struct remove_pointer     { typedef T type; };
template <typename U> struct remove_pointer<U*> { typedef U type; };
```
Als @Nawaz sagt, der einfachste Weg ist wahrscheinlich zu #include <type_traits> und sagen:
```
typedef typename std::conditional<S, int, unsigned int>::type data_t;
```
- template <typename U> struct remove_pointer<T*> { typedef U type; }; ?
- Hoppla, danke!
- Jedes mal Lerne ich neue C++ - syntax, die die Lesbarkeit aller zukünftigen code Schreibe ich leiden...
- Im Gegenteil! Schauen Sie auf meine Letzte Zeile in der aktualisierten post: Eine Linie, und es ist völlig selbst-beschreibend. Wenn Sie die richtigen Werkzeuge und Bausteine, die Ihr code tatsächlich zu der mehr lesbar und weniger ausführlich. Sie ersetzen undurchsichtige syntax Unsinn mit sich selbst beschreibende one-Liner.
- Sie haben Recht, ich war ein Scherz. Ich bin schon mit std::conditional stark vereinfacht haarigen Klasse; macht es mehr generische und nützliche mit weniger code.
InformationsquelleAutor Kerrek SB
6

@Kerrek hat, beantwortet die Frage ausreichend, aber das kann auch mehr sein, allgemein wie folgt:
```
template<bool b, typename T, typename U>
struct select
{
    typedef T type;
};
template<typename T, typename U>
struct select<false, T, U>
{
    typedef U type;
};
```
Und Verwendung als:
```
template <bool S>
class NuclearPowerplantControllerFactoryProviderFactory 
{
  typedef typename select<S, int, unsigned int>::type data_t;
  //use data_t as data type
};
```
Wenn S stimmt, die ersten Typ-argument in select ausgewählt werden, sonst zweite argument type ausgewählt werden. Es ist generisch, weil Sie angeben, beide Arten in select<>, und basierend auf dem Wert des boolean select<b,T,U>::type gibt entweder den ersten Typ oder einem zweiten Typ.
- Dies ist auch bekannt als std::conditional 🙂
- std::conditional war genau das, was ich brauchte. Wenn Ihre Antwort ist mehr allgemein, so werde ich wählen, dass für die Nachwelt.
- Die goldene Regel ist, dass Sie bewusst, wie man mithilfe von template-Spezialisierung zu machen compile-Zeit Entscheidungen zu treffen, und dann betrachten Sie die <type_trait> Bibliothek und sehen Sie all die wunderbaren Werkzeuge, die sind schon gemacht für Sie zu nutzen 🙂
InformationsquelleAutor Nawaz

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.