Отсутствие оператора typeof в С++ 03?

Он просто использует магию компилятора. Например, GCC __typeof__. Для компиляторов, которые не предоставляют такой магии, он предоставляет эмуляцию, которая может определять тип некоторых выражений, но не работает с полностью неизвестными типами.

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

template<typename> struct type2num;
template<int> struct num2type;
template<typename T> typename type2num<T>::dim &dispatch(T const&);

Затем он переходит от этого числа обратно к типу, чтобы наш EMUL_TYPEOF мог напрямую назвать тип. Итак, чтобы зарегистрировать тип, мы пишем

#define REGISTER_TYPE(T, N) \
  template<> \
  struct type2num<T> { \
    static int const value = N; \
    typedef char dim[N]; \
  }; \
  template<> \
  struct num2type<N> { typedef T type; }

Имея это на месте, вы можете написать

#define EMUL_TYPEOF(E) \
  num2type<sizeof dispatch(E)>::type

Всякий раз, когда вам нужно зарегистрировать тип, вы пишете

REGISTER_TYPE(int, 1);
REGISTER_TYPE(unsigned int, 2);
// ...

Конечно, теперь вы обнаружите, что вам нужен механизм для принятия vector<T>, где вы не знаете T заранее, а затем это становится произвольно сложным. Вы можете создать систему, в которой числа означают больше, чем просто тип. Вероятно, это может сработать:

#define EMUL_TYPEOF(E) \
  build_type<sizeof dispatch_1(E), sizeof dispatch_2(E)>::type

Это может обнаруживать такие типы, как int, а также такие типы, как shared_ptr<int>, другими словами, типы, которые не являются специализациями шаблона класса, и специализации шаблона класса с одним аргументом шаблона, выполняя какое-то систематическое сопоставление.

• Если первое число дает 1, второе число определяет тип; в противном случае
• первое число указывает шаблон, а второе число — аргумент шаблона первого типа.

Так что это становится

template<int N, int M>
struct build_type {
  typedef typename num2tmp<N>::template apply<
    typename num2type<M>::type>::type type;
};

template<int N>
struct build_type<1, N> {
  typedef num2type<N>::type type;
};

Нам также нужно изменить шаблон dispatch и разделить его на две версии, показанные ниже, вместе с REGISTER_TEMP1 для регистрации шаблонов с одним аргументом.

template<typename T> typename type2num<T>::dim1 &dispatch_1(T const&);
template<typename T> typename type2num<T>::dim2 &dispatch_2(T const&);

#define REGISTER_TYPE(T, N) \
  template<> \
  struct type2num<T> { \
    static int const value_dim1 = 1; \
    static int const value_dim2 = N; \
    typedef char dim1[value_dim1]; \
    typedef char dim2[value_dim2]; \
  }; \
  template<> \
  struct num2type<N> { typedef T type; }

#define REGISTER_TMP1(Te, N) \
  template<typename T1> \
  struct type2num< Te<T1> > { \
    static int const value_dim1 = N; \
    static int const value_dim2 = type2num<T1>::value_dim2; \
    typedef char dim1[value_dim1]; \
    typedef char dim2[value_dim2]; \
  }; \
  template<> struct num2tmp<N> { \
    template<typename T1> struct apply { \
      typedef Te<T1> type; \
    }; \
  }

Регистрация шаблона std::vector и обоих вариантов int теперь выглядит так

REGISTER_TMP1(std::vector, 2);
// ... REGISTER_TMP1(std::list, 3);

REGISTER_TYPE(int, 1);
REGISTER_TYPE(unsigned int, 2);
// ... REGISTER_TYPE(char, 3);

Вероятно, вы также захотите зарегистрировать несколько чисел для каждого типа, по одному числу для каждой комбинации const/volatile, или вам может понадобиться более одного числа для каждого типа для записи *, & и т. д. Вы также хотите поддерживать vector< vector<int> >, поэтому вам нужно более одного числа для аргумента шаблона, заставляя build_type вызывать себя рекурсивно. Поскольку вы можете создать произвольный длинный список целых чисел, вы в любом случае можете закодировать что угодно в этой последовательности, так что только ваше творчество в том, как представить эти вещи.

В конце концов, вы, вероятно, повторно реализуете BOOST_TYPEOF :)

Насколько я помню, boost::typeof реализован с помощью некоторых ?: хаков. Во-первых, вы начинаете с класса, который можно преобразовать в любой другой класс, например

class something {
public:
    template<typename T> operator const T&() {
        return *(T*)0;
    }
};

Правила ?: гласят, что если обе стороны имеют одинаковый тип, то результатом является этот тип. В противном случае, если один тип может быть преобразован в другой тип, это тип результата. Таким образом, делая

true ? something() : expr;

тип результата (константная ссылка на) тип expr-, но expr фактически никогда не оценивается, потому что он находится на ложной ветви. Затем вы передаете его в какое-то место, где уже есть вывод аргументов, например аргументы функции.

template<typename T> void x(const T& t) {
    // T is the type of expr.
}

Это несколько сложнее, потому что, судя по памяти, C++03 не имеет свертывания ссылок, поэтому он, вероятно, несколько более запутан, чем этот пример, скорее всего, с использованием SFINAE и признаков типа.

Как это преобразуется в фактический тип времени компиляции, который вы можете передать в шаблон, я понятия не имею. Что касается C++03, предоставляющего decltype(), то с языком C++03 есть гораздо большие проблемы, такие как ODR и порядок объявления/определения, отсутствие семантики перемещения и т. д., которые намного хуже, чем отсутствие decltype.

Он определяется как:

#define BOOST_TYPEOF(Expr) \
boost::type_of::decode_begin<BOOST_TYPEOF_ENCODED_VECTOR(Expr) >::type

Я не знаю подробностей, но, похоже, он ищет тип в какой-то таблице и расширяется до (запись в таблице):: тип

Нет, невозможно узнать размер, не зная типа. Просто никто не подумал добавить typeof в C++03.

Поскольку boost распространяется в виде исходного кода (а BOOST_TYPEOF в любом случае является реализацией заголовочного файла), вы, конечно, можете просто взглянуть. Он имеет много специфичных для компилятора условных компиляций, поэтому ответ заключается в том, что он специфичен для компилятора.

Хотя это и не совсем то же самое, что typeof, в C++0x есть decltype.