Можно ли получить имя char* из типа шаблона в C++?
https://stackoverflow.com/questions/596185
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianВопрос
Я хочу получить имя строки (const char*) типа шаблона.К сожалению, у меня нет доступа к RTTI.
template< typename T >
struct SomeClass
{
const char* GetClassName() const { return /* magic goes here */; }
}
Так
SomeClass<int> sc;
sc.GetClassName(); // returns "int"
Это возможно?Я не могу найти выход и собираюсь сдаться.Спасибо за помощь.
Решение
Нет, и с typeid он также не будет работать надежно.Это даст вам некоторую внутреннюю строку, которая зависит от реализации компилятора.Что-то вроде «int», но также и «i» является общим для int.
Кстати, если вам нужно только сравнить, являются ли два типа одинаковыми, вам не нужно сначала преобразовывать их в строку.Ты можешь просто сделать
template<typename A, typename B>
struct is_same { enum { value = false }; };
template<typename A>
struct is_same<A, A> { enum { value = true }; };
А потом сделай
if(is_same<T, U>::value) { ... }
В Boost уже есть такой шаблон, и в следующем стандарте C++ он будет. std::is_same слишком.
Ручная регистрация типов
Вы можете специализироваться на таких типах:
template<typename>
struct to_string {
// optionally, add other information, like the size
// of the string.
static char const* value() { return "unknown"; }
};
#define DEF_TYPE(X) \
template<> struct to_string<X> { \
static char const* value() { return #X; } \
}
DEF_TYPE(int); DEF_TYPE(bool); DEF_TYPE(char); ...
Итак, вы можете использовать его как
char const *s = to_string<T>::value();
Конечно, вы также можете избавиться от определения основного шаблона (и оставить только предварительное объявление), если хотите получить ошибку времени компиляции, если тип неизвестен.Я просто включил его сюда для завершения.
Раньше я использовал статические элементы данных char const*, но они вызывают некоторые сложные проблемы, например, вопросы, где разместить их объявления и т. д.Специализации классов, подобные приведенным выше, легко решают эту проблему.
Автоматически, в зависимости от GCC
Другой подход — полагаться на внутренние возможности компилятора.В GCC следующее дает мне разумные результаты:
template<typename T>
std::string print_T() {
return __PRETTY_FUNCTION__;
}
Возвращаясь за std::string.
std::string print_T() [with T = std::basic_string<char, std::char_traits<char>, std::allocator<char> >]
Некоторый substr магия, смешанная с find даст вам строковое представление, которое вы ищете.
Другие советы
Действительно простое решение: Просто передайте строковый объект конструктору SomeClass, который сообщает его тип.
Пример:
#define TO_STRING(type) #type
SomeClass<int> s(TO_STRING(int));
Просто сохраните его и отобразите в реализации GetClassName.
Немного более сложное решение, но все же довольно простое:
#define DEC_SOMECLASS(T, name) SomeClass<T> name; name.sType = #T;
template< typename T >
struct SomeClass
{
const char* GetClassName() const { return sType.c_str(); }
std::string sType;
};
int main(int argc, char **argv)
{
DEC_SOMECLASS(int, s);
const char *p = s.GetClassName();
return 0;
}
Шаблонное нетиповое решение:
Вы также можете создать свои собственные идентификаторы типов и иметь функцию для преобразования в и из идентификатора и строкового представления.
Затем вы можете передать идентификатор при объявлении типа как нетипового параметра шаблона:
template< typename T, int TYPEID>
struct SomeClass
{
const char* GetClassName() const { return GetTypeIDString(TYPEID); }
};
...
SomeClass<std::string, STRING_ID> s1;
SomeClass<int, INT_ID> s2;
Вы можете попробовать что-то вроде этого (предупреждение, что это просто пришло мне в голову, поэтому могут быть ошибки компиляции и т. д.)
template <typename T>
const char* GetTypeName()
{
STATIC_ASSERT(0); // Not implemented for this type
}
#define STR(x) #x
#define GETTYPENAME(x) str(x) template <> const char* GetTypeName<x>() { return STR(x); }
// Add more as needed
GETTYPENAME(int)
GETTYPENAME(char)
GETTYPENAME(someclass)
template< typename T >
struct SomeClass
{
const char* GetClassName() const { return GetTypeName<T>; }
}
Это будет работать для любого типа, который вы добавляете GETTYPENAME(type) линия для.Его преимущество заключается в том, что он работает без изменения интересующих вас типов и будет работать со встроенными типами и типами указателей.У него есть явный недостаток: вам нужна строка для каждого типа, который вы хотите использовать.
Без использования встроенного RTTI вам придется куда-то добавлять информацию самостоятельно, либо Брайан Р.Ответ Бонди или Диркджентли сработает.Помимо моего ответа, у вас есть три разных места, где можно добавить эту информацию:
- Во время создания объекта с использованием
SomeClass<int>("int") - В классе, использующем RTTI времени компиляции dirkgently или виртуальные функции.
- С шаблоном, использующим мое решение.
Все три будут работать, вопрос лишь в том, где в вашей ситуации вы столкнетесь с наименьшими головными болями по обслуживанию.
Если у вас нет доступа к RTTI, значит ли это, что вы не можете использовать typeid(T).name()?Потому что это практически единственный способ сделать это с помощью компилятора.
Очень ли важно, чтобы типы имели уникальные имена, или имена будут каким-то образом сохраняться?Если это так, вам следует подумать о том, чтобы предоставить им что-то более надежное, чем просто имя класса, объявленное в коде.Вы можете дать двум классам одно и то же неполное имя, поместив их в разные пространства имен.Вы также можете поместить два класса с одним и тем же именем (включая уточнение пространства имен) в две разные библиотеки DLL в Windows, поэтому вам также необходимо включить в имя идентификатор DLL.
Конечно, все зависит от того, что вы собираетесь делать со струнами.
Вы можете добавить немного волшебства самостоятельно.Что-то вроде:
#include <iostream>
#define str(x) #x
#define xstr(x) str(x)
#define make_pre(C) concat(C, <)
#define make_post(t) concat(t, >)
#define make_type(C, T) make_pre(C) ## make_post(T)
#define CTTI_REFLECTION(T, x) static std::string my_typeid() \
{ return xstr(make_type(T, x)); }
// the dark magic of Compile Time Type Information (TM)
#define CTTI_REFLECTION(x) static const char * my_typeid() \
{ return xstr(make_type(T, x)); }
#define CREATE_TEMPLATE(class_name, type) template<> \
struct class_name <type>{ \
CTTI_REFLECTION(class_name, type) \
};
// dummy, we'll specialize from this later
template<typename T> struct test_reflection;
// create an actual class
CREATE_TEMPLATE(test_reflection, int)
struct test_reflection {
CTTI_REFLECTION(test_reflection)
};
int main(int argc, char* argv[])
{
std::cout << test_reflection<int>::my_typeid();
}
Я сделаю инспектора static функция (и, следовательно, не-const).
Нет извините.
И RTTI даже не скомпилируется, если вы попытаетесь использовать его для int.
