erkennen typedef zur compile-Zeit (Schablone metaprogramming)

Ich bin derzeit dabei einige template-metaprogramming. In meinem Fall kann ich mit jedem "iteratable" geben, d.h. jede Art, für die eine typedef foo const_iterator existiert in der gleichen Weise. Ich habe versucht, verwenden Sie die neue C++11 template metaprogramming für diese, dennoch konnte ich nicht finden, eine Methode zu erkennen, ob eine bestimmte Art fehlt.

Weil ich brauche auch ein - /ausschalten andere template-Spezialisierungen auf der Grundlage von anderen Eigenschaften, ich bin derzeit mit einer Vorlage mit zwei Parametern, und die zweite bekommt man produziert über std::enable_if. Hier ist, was ich bin derzeit dabei:

template <typename T, typename Enable = void>
struct Foo{}; //default case is invalid

template <typename T>
struct Foo< T, typename std::enable_if<std::is_fundamental<T>::value>::type>{ 
   void do_stuff(){ ... }
};

template<typename T>
struct exists{
   static const bool value = true;
};

template<typename T>
struct Foo<T, typename std::enable_if<exists< typename T::const_iterator >::value >::type> {
    void do_stuff(){ ... }
};

Ich war nicht in der Lage, so etwas zu tun, ohne die exists Helfer-Vorlage. Zum Beispiel einfach tun

template<typename T>
struct Foo<T, typename T::const_iterator> {
    void do_stuff(){ ... }
};

nicht funktioniert, weil in jenen Fällen, wo diese Spezialisierung benutzt werden sollte, wird die ungültige Standard-Fall instanziiert wurde, statt.

Aber ich konnte nicht finden, diese exists irgendwo in der neuen C++11 standard ist, soweit ich weiß, einfach ist die Einnahme von boost::type_traits für diese Art von Sachen. Aber auf der homepage für boost::type_traits zeigt keinerlei Referenz auf etwas, dass könnte stattdessen verwendet werden.

Ist diese Funktionalität fehlt, oder habe ich das übersehen einige andere offensichtliche Weg, um zu erreichen das gewünschte Verhalten?

InformationsquelleAutor LiKao | 2011-10-20
  1. 14

    Wenn Sie wollen einfach nur, ob eine bestimmte Art enthält const_iterator dann folgende ist eine vereinfachte version des Codes:

    template<typename T>
struct void_ { typedef void type; };

template<typename T, typename = void>
struct Foo {};

template<typename T>
struct Foo <T, typename void_<typename T::const_iterator>::type> {
      void do_stuff(){ ... }
};

    Sehen diese Antwort für eine Erklärung, wie diese Technik funktioniert.

    • Sie sollten vielleicht einen link posten, um Ihre Fragen auf, wie dieses funktioniert. 🙂 Also, es scheint du hast eine Vorliebe für diese ein, sehen Sie, was darauf hindeutet, es mehrere Male schon.
    • ja, das ist ziemlich einfach und straight forward. Aber ich din ' T Ihr den ersten Teil You should maybe post a link to your questions on how this one works. 🙂 ... meinst du bei der Beantwortung darf ich einen link auf meine vorherigen Fragen (statt auf den code selbst) ? Ich vermute, dass wird nicht empfohlen, auf SO.
    • Nono, was ich meinte war, dass Ihr post einen link zu Ihre Frage, wo Sie gefragt, wie das funktioniert, da es wirklich nicht offensichtlich auf den ersten. Woops, und ich habe gerade festgestellt ich schrieb 'Fragen', meinte nur, dass man die Frage natürlich.
    • eigentlich waren Sie Recht für questions. Da meine letzten Fragen waren etwas im Zusammenhang mit diesem Mechanismus nur. So, jetzt habe ich einen guten halt.
    • warum sollten wir die "struct " void_" hier? warum können wir nicht einfach übergeben Sie den typename T::const_iterator in der Spezifikation?
    • Grundsätzlich, wenn Sie haben, SFINAE, die nachgeben Typ sollte gleich sein. Zum Beispiel, in diesem Fall die "Entscheidung geben" ist void als 2. Standard-Typ für Standard -struct Foo. Jetzt werden alle die nachfolgenden Spezialisierungen von Foo müssen den gleichen Typ 2. Zu diesem Zweck müssen wir void_ Mechanismus. Siehe auch den link von Xeo oben. Ich hatte die gleiche Frage gestellt wie deins: Unterschiedliche template-syntax zu finden, wenn argument eine Klasse ist oder nicht.

    InformationsquelleAutor iammilind
  2. 7

    Können Sie erstellen, die ein Merkmal has_const_iterator liefert einen booleschen Wert, und verwenden Sie, dass in der Spezialisierung.

    Sowas könnte funktionieren:

    template <typename T>
struct has_const_iterator {
private:
    template <typename T1>
    static typename T1::const_iterator test(int);
    template <typename>
    static void test(...);
public:
    enum { value = !std::is_void<decltype(test<T>(0))>::value };
};

    Und dann kann man sich spezialisieren, wie diese:

    template <typename T,
          bool IsFundamental = std::is_fundamental<T>::value,
          bool HasConstIterator = has_const_iterator<T>::value>
struct Foo; //default case is invalid, so no definition!

template <typename T>
struct Foo< T, true, false>{ 
   void do_stuff(){//bla }
};

template<typename T>
struct Foo<T, false, true> {
    void do_stuff(){//bla}
};
    • Gibt es einen Grund, warum Sie wählte test(int) statt, z.B. test()?Nur sicherstellen, dass ich verstehe, wie die überlast-Auflösung hier funktioniert. Danke!
    • Grund: um den Anruf zu test eindeutig.
    InformationsquelleAutor R. Martinho Fernandes
  3. 4

    Hier ist eine andere version eines Mitglieds Typ-trait-check:

    template<typename T>
struct has_const_iterator
{
private:
    typedef char                      yes;
    typedef struct { char array[2]; } no;

    template<typename C> static yes test(typename C::const_iterator*);
    template<typename C> static no  test(...);
public:
    static const bool value = sizeof(test<T>(0)) == sizeof(yes);
};
    InformationsquelleAutor Kerrek SB
  4. 1

    Gibt es ein paar Möglichkeiten, dies zu tun. In C++03, Sie könnten Schub und enable_if definieren das Merkmal (docs, Quelle):

    BOOST_MPL_HAS_XXX_TRAIT_DEF(const_iterator);

template <typename T, typename Enable = void>
struct Foo;

template <typename T>
struct Foo< T, typename boost::enable_if<boost::is_fundamental<T> >::type>{ 
   void do_stuff(){ ... }
};

template<typename T>
struct Foo<T, typename boost::enable_if<has_const_iterator<T> >::type> {
    void do_stuff(){ ... }
};

    In C++11, die Sie nutzen könnten Tick wie diese:

    TICK_TRAIT(has_const_iterator)
{
    template<class T>
    auto require(const T&) -> valid<
        has_type<typename T::const_iterator>
    >;
};

template <typename T, typename Enable = void>
struct Foo;

template <typename T>
struct Foo< T, TICK_CLASS_REQUIRES(std::is_fundamental<T>::value)>{ 
   void do_stuff(){ ... }
};

template<typename T>
struct Foo<T, TICK_CLASS_REQUIRES(has_const_iterator<T>())> {
    void do_stuff(){ ... }
};

    Auch mit Tick können Sie weiter zu verbessern die Eigenschaft, die tatsächlich erkennen, dass die const_iterator ist tatsächlich ein iterator, als auch. Also sagen wir, wir definieren eine einfache is_iterator Merkmal wie dieses:

    TICK_TRAIT(is_iterator,
    std::is_copy_constructible<_>)
{
    template<class I>
    auto require(I&& i) -> valid<
        decltype(*i),
        decltype(++i)
    >;
};

    Können wir dann definieren has_const_iterator Merkmal, um zu überprüfen, dass die const_iterator Typ mit dem is_iterator Merkmal wie dieses:

    TICK_TRAIT(has_const_iterator)
{
    template<class T>
    auto require(const T&) -> valid<
        has_type<typename T::const_iterator, is_iterator<_>>
    >;
};
    InformationsquelleAutor Paul Fultz II
Schreibe einen Kommentar