Действительно ли возможно получить символ* имя от шаблонного типа в C++

Действительно легкое решение: Просто передайте строковый объект конструктору 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>; }
}

Это будет работать на любой тип, что Вы добавляете a GETTYPENAME(type) строка для. Это имеет преимущество, что это работает, не изменяя типы, Вы интересуетесь и будете работать со встроенными и типами указателей. Это действительно имеет отличный недостаток, что Вы должны строка для каждого типа, который Вы хотите использовать.

Не используя встроенный RTTI, Вы оказываетесь перед необходимостью добавлять информацию сами где-нибудь, или ответ Brian R. Bondy или dirkgently's будет работать. Наряду с моим ответом, у Вас есть три различных места, чтобы добавить что информация:

1. Во время создания объекта с помощью SomeClass<int>("int")
2. В классе с помощью времени компиляции dirkgently RTTI или виртуальные функции
3. С шаблоном с помощью моего решения.

Все три будут работать, это - просто вопрос того, где Вы закончите с наименьшим количеством головных болей обслуживания в своей ситуации.

Разве Вами доступ к RTTI не имеет, который означает, что Вы не можете использовать идентификатор типа (T) .name ()? Поскольку это - в значительной степени единственный способ сделать это со справкой компилятора.

Нет, извините.

И RTTI даже не скомпилирует, при попытке использовать его на интервале.

Можно добавить немного волшебства сами. Что-то как:

#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();
}

Я сделаю инспектора a static функция (и следовательно не -const).

Для типов действительно ли очень важно иметь уникальные имена, или имена собираются быть сохраненными так или иначе? Если так, необходимо считать предоставление им чем-то более устойчивым, чем просто название класса, как объявлено в коде. Можно дать двум классам то же неполное имя путем помещения их в различные пространства имен. Можно также поместить два класса с тем же именем (включая квалификацию пространства имен) в двух различных DLLs в Windows, таким образом, Вам нужно определение DLL, который будет включен в имя также.

Все это зависит от того, что Вы собираетесь сделать со строками, конечно.