Можно ли определить, является ли аргумент, переданный в макро или функции, строковым литералом во время компиляции или времени выполнения?
Например,
#define is_string_literal(X)
...
...
is_string_literal("hello") == true;
const char * p = "hello";
is_string_literal(p) == false;
или
bool is_string_literal(const char * s);
is_string_literal("hello") == true;
const char * p = "hello";
is_string_literal(p) == false;
Спасибо.
ДА! (Спасибо Джеймс Макнеллис и GMan для исправлений. Обновлено для правильной обработки объединенных литералов типа "Hello, " "World!" которые вырезаются до конкатенации.)
#define is_literal_(x) is_literal_f(#x, sizeof(#x) - 1)
#define is_literal(x) is_literal_(x)
bool is_literal_f(const char *s, size_t l)
{
const char *e = s + l;
if(s[0] == 'L') s++;
if(s[0] != '"') return false;
for(; s != e; s = strchr(s + 1, '"'))
{
if(s == NULL) return false;
s++;
while(isspace(*s)) s++;
if(*s != '"') return false;
}
return true;
}
Это приведет к форматированию аргумента перед передачей его функции, поэтому, если аргумент был строковым литералом, аргумент, переданный нашей функции, будет окружен кавычками.
Если вы считаете это строковым литералом:
const char *p = "string";
// should is_literal(p) be true or false?
Я не могу вам помочь. Возможно, вы сможете использовать определенное (или * shudder * undefined) поведение, определяемое реализацией, для проверки того, хранится ли строка в постоянной памяти, но некоторые (возможно, более старые) системы p могут быть изменены.
Для тех, кто ставит под вопрос использование такой функции, рассмотрим:
enum string_type { LITERAL, ARRAY, POINTER };
void string_func(/*const? */char *c, enum string_type t);
Вместо того, чтобы явно указывать второй аргумент string_function для каждого вызова, is_literal позволяет нам обернуть его макросом:
#define string_func(s) \
(string_func)(s, is_literal(s) ? LITERAL :
(void *)s == (void *)&s ? ARRAY : POINTER)
Я не могу себе представить, почему это изменило бы ситуацию, за исключением простого C, где литералы не являются const и по какой-то причине вы не хотите/не можете записать функцию как взяв const char * вместо char. Но есть все основания, чтобы хотеть что-то сделать. Когда-нибудь вы тоже почувствуете необходимость прибегать к ужасному взлому.
Знание во время компиляции (как упоминалось в вопросе), со следующей методикой. Вы можете определить, является ли данный аргумент строковым литералом или нет. Если это какой-то массив или указатель вроде const char x[], *p; то это вызовет ошибку компилятора.
#define is_string_literal(X) _is_string_literal("" X)
bool _is_string_literal (const char *str) { return true; } // practically not needed
[Примечание: мой предыдущий ответ был отклонен экспертами, и он еще не принят или проголосовал после внесенных изменений. Я помещаю другой ответ с тем же контентом.]
Нет. Строковый литерал - это всего лишь массив char (в C) или const char (в С++).
Вы не можете различать строковый литерал и другой массив char, как этот (в С++):
const char x[] = "Hello, World!";
Попробуйте следующее:
#define is_string_literal(s) \
(memcmp(#s, "\"", 1) == 0)
В соответствии с соглашением об именовании переменных C/С++ имя переменной должно начинаться с "_" или алфавита.
У меня был аналогичный вопрос: я хотел сказать, что
MY_MACRO("compile-time string")
был законным и что
char buffer[200]="a string";
MY_MACRO(buffer)
является законным, но не позволяет
MY_MACRO(szArbitraryDynamicString)
Я использовал GCC __builtin_types_compatible_p и MSVC _countof, которые, похоже, работают правильно за счет отказа от коротких строковых литералов.
Поскольку строковый литерал в c++ может иметь разные префиксы, нет смысла проверять начальную цитату: https://en.cppreference.com/w/cpp/language/string_literal
Лучше проверить окончательную цитату:
msvc2015u3, gcc5.4, clang3.8.0
#include <type_traits>
#define UTILITY_CONST_EXPR_VALUE(exp) ::utility::const_expr_value<decltype(exp), exp>::value
// hint: operator* applies to character literals, but not to double-quoted literals
#define UTILITY_LITERAL_CHAR_(c_str, char_type) UTILITY_CONST_EXPR_VALUE(((void)(c_str * 0), ::utility::literal_char_caster<typename ::utility::remove_cvref<char_type>::type>::cast_from(c_str, L ## c_str, u ## c_str, U ## c_str)))
#define UTILITY_LITERAL_CHAR(c_str, char_type) UTILITY_LITERAL_CHAR_(c_str, char_type)
#define UTILITY_IS_LITERAL_STRING(c_str) UTILITY_CONST_EXPR_VALUE((sizeof(#c_str) > 1) ? #c_str [sizeof(#c_str) - 2] == UTILITY_LITERAL_CHAR('\"', decltype(c_str[0])) : false)
#define UTILITY_IS_LITERAL_STRING_A(c_str) UTILITY_CONST_EXPR_VALUE((sizeof(#c_str) > 1) ? #c_str [sizeof(#c_str) - 2] == '\"' : false)
#define UTILITY_IS_LITERAL_STRING_WITH_PREFIX(c_str, prefix) UTILITY_CONST_EXPR_VALUE((sizeof(#c_str) > 1) ? #c_str [sizeof(#c_str) - 2] == prefix ## '\"' : false)
namespace utility {
template <typename T, T v>
struct const_expr_value
{
static constexpr const T value = v;
};
// remove_reference + remove_cv
template <typename T>
struct remove_cvref
{
using type = typename std::remove_cv<typename std::remove_reference<T>::type>::type;
};
//// literal_char_caster, literal_string_caster
// template class to replace partial function specialization and avoid overload over different return types
template <typename CharT>
struct literal_char_caster;
template <>
struct literal_char_caster<char>
{
static inline constexpr char
cast_from(
char ach,
wchar_t wch,
char16_t char16ch,
char32_t char32ch)
{
return ach;
}
};
template <>
struct literal_char_caster<wchar_t>
{
static inline constexpr wchar_t
cast_from(
char ach,
wchar_t wch,
char16_t char16ch,
char32_t char32ch)
{
return wch;
}
};
template <>
struct literal_char_caster<char16_t>
{
static inline constexpr char16_t
cast_from(
char ach,
wchar_t wch,
char16_t char16ch,
char32_t char32ch)
{
return char16ch;
}
};
template <>
struct literal_char_caster<char32_t>
{
static inline constexpr char32_t
cast_from(
char ach,
wchar_t wch,
char16_t char16ch,
char32_t char32ch)
{
return char32ch;
}
};
}
const char * a = "123";
const char b[] = "345";
int main()
{
static_assert(UTILITY_IS_LITERAL_STRING_A(a) == 0, "Aa");
static_assert(UTILITY_IS_LITERAL_STRING(a) == 0, "a");
static_assert(UTILITY_IS_LITERAL_STRING_A(b) == 0, "Ab");
static_assert(UTILITY_IS_LITERAL_STRING(b) == 0, "b");
static_assert(UTILITY_IS_LITERAL_STRING_A("123") == 1, "A123");
static_assert(UTILITY_IS_LITERAL_STRING_WITH_PREFIX(L"123", L) == 1, "L123");
static_assert(UTILITY_IS_LITERAL_STRING_WITH_PREFIX(u"123", u) == 1, "u123");
static_assert(UTILITY_IS_LITERAL_STRING_WITH_PREFIX(U"123", U) == 1, "U123");
static_assert(UTILITY_IS_LITERAL_STRING("123") == 1, "123");
static_assert(UTILITY_IS_LITERAL_STRING(L"123") == 1, "L123");
static_assert(UTILITY_IS_LITERAL_STRING(u"123") == 1, "u123");
static_assert(UTILITY_IS_LITERAL_STRING(U"123") == 1, "U123");
}
Макрос UTILITY_CONST_EXPR_VALUE требуется, чтобы заставить компилятор генерировать код только во время компиляции.