Durchsetzung der Vorlage durch static_assert

Ich versuche zu verstehen, die Nützlichkeit der static_assert, und ich möchte wissen, ob es mir helfen kann bei der Vollstreckung einer design, und wenn ja, wie.

Ich habe eine Allgemeine Vorlage-Klasse, die blendet seine eigene Implementierung in einer anderen template-Klasse, die teilweise spezialisiert, basierend auf der Größe der template-Typ. Hier ein kurzer überblick über das design:

template <class T, size_t S = sizeof(T)>
struct Helper;

template <class T>
struct Helper<T, sizeof(long)>
{
    static T bar();
};

//... other specializations ...

template <class T>
class Foo
{
public:

    T bar()
    {
        return Helper<T>::bar();
    }
};

Foo wird nur unterstützt, wenn die Größe der T wird unterstützt durch eine Spezialisierung Helfer. Zum Beispiel Foo<long> und Foo<unsigned long> werden beide unterstützt. Jedoch angenommen, der Benutzer versucht, zu erstellen eine Foo<bool>. Normalerweise würde dies die Fehler erzeugen, weil die Spezialisierung von Helfer für bool ist nicht definiert, das dazu bestimmt ist, Verhalten.

Gibt es eine Möglichkeit zu nutzen static_assert in diesem design, um mehr hilfreich, die Fehler der Benutzer dieser Schnittstelle?

Darüber hinaus möchte ich auch restric den Benutzer von der Nutzung eines bestimmten Typs, obwohl die Größe richtig sein. Zum Beispiel Foo<float> nicht erlaubt werden sollte. Gerade jetzt, die einzige Möglichkeit, die ich kenne die Durchsetzung dieser wird durch einen Fett Kommentar in der Dokumentation. 🙂

  • Denke generell ist es nur integer-Typen werden unterstützt? Keine char, bool, float, et al?
  • Suche ALSO für eine Vorlage-Typ-Einschränkungen oder "Konzepte". Eine Einrichtung, um dies zu tun entfernt wurde aus C++11 in der letzten minute. Es gibt weniger automatische Möglichkeiten, um ähnliche Ergebnisse erzielen, wenn.
  • char, int, und long zusammen mit Ihren unsigned Versionen sollten unterstützt werden. Der code wäre identisch für int, long, und unsigned long wenn sizeof(int) == sizeof(long) == sizeof(unsigned long).
InformationsquelleAutor Zeenobit | 2013-07-16
  1. 19

    Wenn es nur funktionieren kann, für die eine Spezialisierung der template-Klasse, dann haben die Standard-template-Klasse heben, statische assert:

    template <class T, size_t S = sizeof(T)>
struct Helper
{
   static_assert(sizeof(T) == -1, "You have to have a specialization for Helper!" );
}

    Die Standard-template-Klasse wird nur dann gewählt, wenn es nicht eine bessere Spezialisierung, daher der behaupten wird, gestiegen.

    Können Sie verwenden die gleiche Technik zu verbieten Typen, aber Sie müssen eine andere template-parameter, die verwendet werden, für die statische assert prüfen.

    template <class T, class G = T, size_t S = sizeof(T)>
struct Helper
{
   static_assert(sizeof(G) == -1, "You have to have a specialization for Helper!" );
}

template <class G>
struct Helper<float,G>
{
   static_assert(sizeof(G) == -1, "You can't use float !" );
}

template <>
struct Helper<int>
{
 //This is a good specialization
};

    Dann können Sie versuchen, es mit diesen Variablen:

    Helper<bool> a;  //"You have to have a specialization for Helper!"
Helper<float> b; //"You can't use float !"
Helper<int> c;   //compiles OK
    • Ich glaube, Sie wollen static_assert(false,...), damit es immer die Ausflüge. static_assert druckt der Fehler ist, wenn das erste argument falsch ist.
    • +1 für die pragmatische Antwort
    • Das wird nicht funktionieren, wie es ist - Sie brauchen, um die Behauptung abhängig (wie static_assert(sizeof(T) == 0, ...);), sonst wird es zur Verarbeitung an die Stelle der Erklärung, nicht der Instanziierung.
    • hast du überprüft? Ich würde erwarten, dass es, um Feuer auf seichten Instanziierung auf den ersten. N. m. Ich überprüft: du hast Recht 🙂
    • Ich habe gerade versucht diese Lösung, und es funktioniert nicht. Es wirft immer eine Behauptung, ob oder nicht die Standard-Spezialisierung verwendet wird. Nicht sicher, ob dies behvaiour ist abhängig von dem compiler.
    • siehe die Diskussion direkt über deinen Kommentar 🙂
    • Yup, habe ich gerade getan hast. Es sieht aus wie die überprüfung der Größen ist der Weg zu gehen. Sie sollten es als Teil der Antwort. 🙂
    • Recht, müssen die Instanziierung angewiesen, da sonst der compiler wird nur ausgeführt, die geltend machen, sowieso.
    • Du hast Recht. Also musste ich öffnen Sie visual studio für eine bessere Lösung.
    • Ich habe mich verändert die Lösung, um richtig zu arbeiten. Hinzufügen müssen, um ein weiteres "unsichtbar" template-argument

    InformationsquelleAutor Yochai Timmer
  2. 5

    http://en.cppreference.com/w/cpp/header/type_traits

    std::is_base_of und std::is_convertible helfen konnte mit Ihrer ersten Ausgabe und als für die zweite,

    static_assert(!std::is_same<float,T>(),"type can't be float");

    hoffentlich hilft jemand anderes, der stößt auf diese Frage, vorausgesetzt, OP wahrscheinlich eine Antwort gefunden in den 4 Jahren seit es gefragt wurde 🙂

    InformationsquelleAutor Austin_Anderson
  3. 1

    Dachte ich, eine bessere Lösung für dieses problem durch die Kombination der Antworten und Kommentare hier.

    Kann ich definieren Sie eine statische type checker so:

    template <class A, class B>
struct CheckTypes
{
    static const bool value = false;
};

template <class A>
struct CheckTypes<A, A>
{
    static const bool value = true;
};

    Nicht sicher, ob eine solche Struktur ist bereits in der standard-Bibliothek. Anyways, dann in Foo, kann ich für Typen und Größen mit:

    static_assert((sizeof(T) == sizeof(long) || sizeof(T) == sizeof(int)) && !CheckTypes<T, float>::value, "Error!");
    • tut es, std::is_same
    • Verwendung von sizeof ist nicht sicher. es ist nur die Größe. long und int können die gleiche Größe und eine zufällige Struktur, die hält nur ein int haben auch die gleiche Größe.
    InformationsquelleAutor Zeenobit
Schreibe einen Kommentar