Wie erkennt man ein String-Literal mit type_traits?

Question

Wie verlasse ich mich zuverlässig auf alles, was kein String-Literal ist? Beispiel: Im folgenden Code habe ich versucht, das Standard-Asser-Makro zu umbrechen, aber alles für die Nachricht, die kein String-Literal ist, statisch abzulehnen (da bei der Assertion alles außer einem String-Literal zur Laufzeit nicht angezeigt wird) löst aus).

#include <cassert> 
#include <string> 
#include <type_traits> 

#define my_assert(test, message)\ 
    static_assert(\ 
     (\ 
      !std::is_pointer<decltype(message)>::value &&\ 
      !std::is_array<decltype(message)>::value\ 
     ),\ 
     "literal string required"\ 
    );\ 
    assert((message, (test))); 

int main() { 
    my_assert(1 == 1, "one equals one"); 
    my_assert(1 == 2, "one equals two"); 

    { 
     const char *msg = "one equals one"; 
     //my_assert(1 == 1, msg); // triggers static_assert 
    } 

    { 
     const char msg[] = "one equals one"; 
     //my_assert(1 == 1, msg); // triggers static_assert 
    } 

    { 
     const std::string msg = "one equals one"; 
     //my_assert(1 == 1, msg.c_str()); // triggers static_assert 
    } 

    { 
     const int msg = 3; 
     my_assert(1 == 1, msg); // should trigger static_assert 
    } 
} 

Wie Sie sehen können, ist die Prüfung über die von dem type_traits Header versehen Tests durchgeführt, und, meist, dieser Code funktioniert wie vorgesehen (mit gcc 4.7.2 getestet). Es sucht jedoch nicht so sehr nach Zeichenfolgenliteralen, sondern lehnt auch gewöhnliche Dinge ab, die ein Programmierer verwenden könnte.

Die Lösung, die ich habe, mag für das obige Beispiel gut genug sein, aber ich würde diese oder eine ähnliche Technik auch in anderen Situationen verwenden.

Also die Frage ist, wie verwende ich zuverlässig type_traits (oder einen anderen Standard-Mechanismus) zu static_sert auf alles außer einem String-Literal?

Answer 1

Hier ist das Beste, was ich bekommen konnte, die alles, was ich an ihm werfen abzulehnen scheint, akzeptiert aber noch Literalzeichenfolgen:

#define my_assert(test, message)\ 
    static_assert(\ 
     (\ 
      std::is_convertible  <decltype(message), const char *>::value &&\ 
      !std::is_rvalue_reference <decltype(message)>::value &&\ 
      !std::is_pointer   <decltype(message)>::value &&\ 
      !std::is_array   <decltype(message)>::value &&\ 
      !std::is_class   <decltype(message)>::value\ 
     ),\ 
     "string literal required"\ 
    );\ 
    assert((message, (test))) 

wäre ich sehr daran interessiert zu wissen, ob dies tatsächlich erschöpfend ist richtig und/oder wenn es einen einfacheren Weg gibt, diese Erkennung durchzuführen.

Answer 2

'decltype ("einige Zeichenfolge")' eines String-Literals gibt "const char (&) [n]" Typ zurück. So scheint es, gibt prägnanter ist, im Vergleich zu the following answer, wie es zu erkennen: Sie eine Nachricht tatsächlich angezeigt werden sollen

template<typename T> 
struct IsStringLiteral : 
    std::is_same< 
     T, 
     std::add_lvalue_reference_t<const char[std::extent_v<std::remove_reference_t<T>>]> 
    > 
{}; 

(online demo)