Verwenden Sie static_assert, um die an das Makro übergebenen Typen zu überprüfen

Leider habe ich mehrere Makros von der ursprünglichen Version meiner Bibliothek übrig, die ziemlich verrücktes C verwendet. Insbesondere habe ich eine Reihe von Makros, die erwarten, dass bestimmte Typen an sie übergeben werden. Ist es möglich, etwas in der Art zu tun:

static_assert(decltype(retval) == bool);

Und wie? Gibt es clevere Alternativen?

Ja, mir ist bewusst, dass Makros schlecht sind. Ich bin mir bewusst, dass C++ nicht C ist usw.

Update0

Hier ist etwas zugehöriger Code, und das Quelldatei. Vorschläge sind willkommen. Die ursprüngliche Frage bleibt dieselbe.

Ich fand dies mit dem Vorschlag von @UncleBens am saubersten:

#include <type_traits>

static_assert(std::is_same<decltype(retval), bool>::value, "retval must be bool");

Haftungsausschluss: Dies ist eine schlechte Antwort, es gibt definitiv weitaus bessere Lösungen. Nur ein Beispiel 🙂

Es ist sicherlich bereits implementiert, aber es ist trivial, es selbst zu implementieren;

template <class T1, class T2> struct CheckSameType; //no definition
template <class T> struct CheckSameType<T,T>{}; //

template <class T1, class T2>
AssertHasType(T2)
{
   CheckSameType<T1, T2> tmp; //will result in error if T1 is not T2
}

So zu verwenden:

AssertHasType<bool>(retval);

Alternative (von GMan vorgeschlagen):

template <class T1, class T2> struct SameType
{
    enum{value = false};
}
template <class T> struct SameType<T,T>
{
    enum{value = true};
}; 

Zu verwenden wie

static_assert(SameType<decltype(retval), bool>::value);

Es scheint, dass Sie brauchen decltype weil Sie einen Ausdruck haben, aber einen Typ überprüfen möchten. Dafür gibt es jetzt schon genug Möglichkeiten (C++03). Um zum Beispiel einen bool zu überprüfen

inline void mustBeBool(bool) { }
template<typename T> inline void mustBeBool(T t) { & (&t); } // Takes address of rvalue (&t)

// Use:
#define DifficultMacro(B) do { mustBeBool(B); foo(B); } while (false)

Wenn dir das wichtig ist const und volatile Qualifikanten und möchten sicherstellen, dass die const und volatile Teile der Typen stimmen auch genau mit dem Typ überein, mit dem Sie vergleichen, machen Sie es wie @Matt Joiner sagt:

#include <type_traits>

static_assert(std::is_same<decltype(my_variable), uint64_t>::value, 
              "type must be `uint64_t`"); 

Ich interessiere dich NICHT const, und möchten einfach sicherstellen, dass der Typ ein bestimmter Typ ist, ohne Rücksicht auf const, gehen Sie stattdessen wie folgt vor. Beachten Sie, dass std::remove_const<>::type wird hier benötigt:

static_assert(std::is_same<std::remove_const<decltype(my_variable)>::type, uint64_t>::value, 
              "type must be `uint64_t` OR `const uint64_t`");   

Das gleiche gilt für volatile. Falls dir das egal ist volatile Teil des Typs entweder, Sie können es ignorieren mit std::remove_volatile<>::type:

static_assert(std::is_same<std::remove_volatile<decltype(my_variable)>::type, uint64_t>::value, 
              "type must be `uint64_t` OR `volatile uint64_t`");

Wenn dir das egal ist const ODER volatile, du kannst sie beide mit entfernen std::remove_cv<>::type:

static_assert(std::is_same<std::remove_cv<decltype(my_variable)>::type, uint64_t>::value, 
              "type must be `uint64_t` OR `const uint64_t` OR `volatile uint64_t` OR `volatile const uint64_t`");

Beachten Sie auch, dass Sie ab C++17 Folgendes tun können:

1. std::remove_cv_t<decltype(my_variable)> anstelle von std::remove_cv<decltype(my_variable)>::type, und:
2. std::is_same_v<some_type, another_type> anstelle von std::is_same<some_type, another_type>::value.

Verweise:

1. Verwenden Sie static_assert, um die an das Makro übergebenen Typen zu überprüfen
2. https://en.cppreference.com/w/cpp/types/is_same
3. https://en.cppreference.com/w/cpp/language/decltype
4. https://en.cppreference.com/w/cpp/header/type_traits
5. https://en.cppreference.com/w/cpp/types/remove_cv – std::remove_cv<>, std::remove_const<>, std::remove_volatile<>

Verwandt:

1. [another answer of mine where I use the above static_assert tricks] Wie man Spannweiten macht
2. Statische Behauptung in C [my own answer]
3. So verwenden Sie statisches Assert in C, um die Parametertypen zu überprüfen, die an ein Makro übergeben werden [my own question]
4. Typüberprüfung von Makroargumenten in C
5. *****C++ Vorlagentyp auf Zahlen beschränken

Die meisten Makros können ersetzt werden durch inline Funktionen und/oder Vorlagen. Ein typisches Beispiel dafür ist die allzu clevere Argument-Größen-Überprüfung von Posix isnan Makro ist eine Vorlage in C++0x. Oh, schlechtes Beispiel, aber Sie bekommen die Idee.

Die wichtigsten Ausnahmen von dieser Regel sind Makros, die im Wesentlichen eine höhere Ebene implementieren Sprache Merkmale. Zum Beispiel eine intelligentere Ausnahmebehandlung oder Kovarianz oder ein parametrisierter Satz von Deklarationen.

In einigen Fällen können die Makros, die nicht vernünftig ausgedrückt werden können, als inline Funktionen oder Templates, durch eine intelligentere Art der Vorverarbeitung, nämlich die Codegenerierung, ersetzt werden. Dann haben Sie irgendwo ein Skript, das den notwendigen Code generiert. Zum Beispiel ist es möglich, Optionsklassen in reinem C++ mit Makros und Templates zu erstellen, aber es ist umständlich, und als einfacher zu verstehende und vielleicht wartungsfreundlichere Alternative könnte man ein Skript verwenden, das die erforderlichen Klassen gegen Aufpreis generiert Build-Schritte und Umgang mit mehreren Sprachen.

Prost & hth.,