C ++: type_info для различения типов

Бегло взглянув на документацию, я бы сказал, что:

1. std :: type_info :: name всегда возвращает две разные строки для двух разных типов, в противном случае это означает, что компилятор потерял себя при разрешении типов, и вам больше не следует его использовать.

2. Ссылка сообщает: «before возвращает истину, если тип предшествует типу rhs в порядке сопоставления. Порядок сопоставления - это просто внутренний порядок, поддерживаемый конкретной реализацией и не обязательно связанный с отношениями наследования или порядком объявления». Таким образом, у вас есть гарантия, что ни один из типов не будет иметь одинаковый ранг в порядке сортировки.

3. Каждый экземпляр класса шаблона относится к разному типу. Специализация не делает исключений.

4. Я не совсем понимаю, что ты имеешь в виду. Если вы имеете в виду что-то вроде того, что typedef foo bar; в двух отдельных единицах компиляции, и эта полоса одинакова в обоих, это работает именно так. Если вы имеете в виду typedef foo bar; typedef int bar;, это не работает (кроме случаев, когда foo имеет значение int).

По поводу других вопросов:

• Вы должны хранить ссылки на std :: type_info, или как-то обернуть его.
• Совершенно не знаю о производительности, я предполагаю, что операторы сравнения имеют постоянное время, несмотря на сложность типа. Раньше должен иметь линейную сложность в зависимости от количества различных типов, используемых в вашем коде.
• Это действительно странно, имхо. Вам следует перегрузить свой operator== вместо того, чтобы делать его виртуальным и отменять его.

Стандарт 18.5.1 (информация о типе класса):

Класс type_info описывает информацию о типе, сгенерированную реализацией. Объекты этого класса эффективно хранят указатель на имя типа и закодированное значение, подходящее для сравнения двух типов на равенство или порядок сортировки. Имена, правила кодирования и последовательность сортировки для типов не указаны и могут различаться в разных программах.

Насколько я понимаю:

1. У вас нет этой гарантии в отношении std:type_info::name. В стандарте только указано, что name возвращает NTBS, определяемую реализацией, и я считаю, что соответствующая реализация вполне может вернуть одну и ту же строку для каждого типа.
2. Я не знаю, и стандарт на этот счет не ясен, поэтому я бы не стал полагаться на такое поведение.
3. Это должно быть для меня определенным да.
4. Это должно быть для меня определенным да.

По поводу второго блока вопросов:

• Нет, вы не можете хранить type_info. Андрей Александреску предлагает TypeInfo оболочку в своей книге Современный дизайн C ++. Обратите внимание, что объекты, возвращаемые typeid, имеют статическое хранилище, поэтому вы можете безопасно хранить указатели, не беспокоясь о времени жизни объекта.
• Я полагаю, вы можете предположить, что type_info сравнения чрезвычайно эффективны (сравнивать особо нечего).

Вы можете хранить это так.

class my_type_info
{
public:
     my_type_info(const std::type_info& info) : info_(&info){}
     std::type_info get() const { return *info_;}
private:
     const std::type_info* info_;
};

РЕДАКТИРОВАТЬ:

Стандарт C ++ 5.2.8.

Результатом выражения typeid является lvalue статического типа const std :: type_info ...

Это означает, что вы можете использовать его вот так.

my_type_info(typeid(my_type));

Функция typeid возвращает lvalue (это не временное значение), и поэтому адрес возвращаемого type_info всегда действителен.

Текущие ответы на вопросы 1 и 2 совершенно правильны, и по сути они просто детали для класса type_info - нет смысла повторять эти ответы.

Что касается вопросов 3 и 4, важно понимать, что именно является типом в C ++ и как они соотносятся с именами. Во-первых, существует множество предопределенных типов, и у них есть имена: int, float, double. Далее, есть несколько сконструированных типов, которые не имеют собственных имен: const int, int*, const int*, int* const. Существуют типы функций int (int) и типы указателей функций int (*)(int).

Иногда бывает полезно дать имя безымянному типу, что можно сделать с помощью typedef. Например, typedef int* pint или typedef int (*pf)(int);. Это вводит имя, а не новый тип.

Далее следуют определяемые пользователем типы: структуры, классы, объединения. Есть хорошая традиция давать им имена, но это не обязательно. Не добавляйте такое имя с typedef, вы можете сделать это напрямую: struct Foo { }; вместо typedef struct {} Foo;. Обычно определения классов находятся в заголовках, которые заканчиваются \ в нескольких единицах перевода. Это означает, что класс определен более одного раза. Это все того же типа, и поэтому вам не разрешается использовать макросы для изменения определений членов класса.

Класс шаблона - это не тип, это рецепт типов. Два экземпляра одного шаблона класса являются разными типами, если аргументы шаблона имеют разные типы (или значения). Это работает рекурсивно: учитывая template <typename T> struct Foo{};, Foo<Foo<int> > имеет тот же тип, что и Foo<Foo<Bar> >, тогда и только тогда, когда Bar - другое имя для типа int.

Type_info - это реализация, определенная, поэтому я бы не стал на нее полагаться. Однако, основываясь на моем опыте использования g ++ и MSVC, предположения 1,3 и 4 верны ... не совсем уверен насчет №2.

Есть ли причина, по которой вы не можете использовать другой подобный метод?

template<typename T, typename U>
struct is_same       { static bool const result = false; };

template<typename T>
struct is_same<T, T> { static bool const result = true;  };

template<typename S, typename T>
bool IsSame(const S& s, const T& t) {   return is_same<S,T>::result; }