Как я могу определить фактический тип переменной «auto»

Почему вы хотите поместить этот тип в структуру? На самом деле он не предназначен для такого использования (я должен знать, я его написал!), но при необходимости вы можете использовать decltype и std::declval для определения типа (который все равно даст правильный ответ, если я изменю реализацию redi::zip)

struct EventData
{
  // type returned by redi::zip
  typedef decltype(redi::zip(std::declval<V1>(), std::declval<V2>())) zipper_type;

  // type referred to by zipper_type::iterator
  typedef std::iterator_traits<zipper_type::iterator>::value_type zipped_type;

  zipper_type m_zipper;
};

Н.Б. почему вы создаете typedef для struct? Это C++, а не C, хватит.

Я понятия не имею, что такое auto i, что затрудняет повторное использование опыта и обучение на примерах.

Привыкайте к этому. Вы знаете тип, который возвращает std::bind? Вы знаете тип, который возвращает std::mem_fn? Знаете ли вы, какой тип создает лямбда-выражение? Нет, вам не нужно знать, все, что вам нужно знать, это какие свойства у него есть и что вы можете с ним делать, а не то, как он называется или какие типы он содержит.

Попробуйте заменить auto на char и прочитать сообщение об ошибке.

Вы бы нашли

for (boost::iterator_facade<
       boost::zip_iterator<
         boost::tuples::tuple<std::vector<int>::iterator,
                              std::vector<int>::iterator>
       >,
       boost::tuples::cons<int&, boost::tuples::cons<int&, boost::tuples::null_type> >,
       boost::random_access_traversal_tag,
       boost::tuples::cons<int&, boost::tuples::cons<int&, boost::tuples::null_type> >,
       long int
     >::reference i : redi::zip(vi, vs))
    std::cout << i.get<0>() << ' ' << i.get<1>() << ' ';

легче понять?

Лучший способ выяснить, что возвращает redi::zip(), — посмотреть, что возвращает redi::zip(). =) Моя IDE позволяет мне перейти прямо к ней, удерживая Ctrl и нажимая zip(). Разве ваш не предлагает аналогичные функции? Я могу даже просто навести курсор на zip() в цикле for() и получить всплывающую подсказку, которая дает сигнатуру функции, включая тип возвращаемого значения.

В любом случае вам нужно будет посмотреть на него, чтобы напечатать то, что вы вручную заменили бы «auto», и auto дает большое преимущество, позволяя вам объявлять типы, которые невозможно объявить иначе (например, лямбда-возвраты, если только не делать сложные вещи, такие как decltype, который имеет тот же недостаток, который вам не нравится в auto).

Когда IDE будут больше поддерживать C++11, ваш intellisense сработает лучше, и будет понятнее, что это за тип. Я уверен, что через год или меньше большинство современных IDE сообщат вам истинный тип auto при наведении курсора.

Преимущества auto намного перевешивают потери, хотя да, есть небольшая потеря, которая станет еще меньше при хорошей поддержке IDE. Почти у всего есть плюсы и минусы.

Я не согласен с вашим утверждением, что незнание типа i «усложняет повторное использование опыта и обучение на примерах». Тип i - это "то, что возвращает zip". Почему этого недостаточно?

Помимо других ответов, мне нравится использовать <boost/type_index.hpp>:

int main()
{
    using namespace std;
    using namespace boost::typeindex;

    auto p = std::make_pair(1, 2);
    cout << type_id_with_cvr<decltype(p)>().pretty_name();
}

Что выводит:

std::pair<int, int>

Вы также можете использовать typeid() из <typeinfo>:

auto p = std::make_pair(1, 2);
cout << typeid(p).name() << '\n';

Вывод не такой понятный, как в первом примере, но все же:

St4pairIiiE

Ответ для

Как определить фактический тип переменной auto во время компиляции

Отвечать:

Попробуйте скомпилировать что-то вроде этого:

auto foo = function_that_returns_unknown_type() // "what type could foo be?"
int a = foo;

Сообщение об ошибке компилятора сообщит вам, что тип XXX (что бы это ни было) не может быть преобразован в int. Там у вас есть ваш тип

Windows: встроенный отладчик в Visual Studio предоставит вам информацию о типе.

Linux: отладьте код в gdb и отправьте ptype <varname>, когда exe прерывается с переменной в области видимости. Пример вывода - в этом случае я мог бы заменить auto на vector<uint8_t>::const_iterator, но это не особенно очевидно из этого:

type = class __gnu_cxx::__normal_iterator
                  <unsigned char const*,
                   std::vector<unsigned char,
                               std::allocator<unsigned char>
                              > 
                  >
       [with _Iterator = const unsigned char *, 
       _Container = std::vector<unsigned char, std::allocator<unsigned char> >] 
        {
   protected:
       _Iterator _M_current;

   public:
     __normal_iterator(void);
     __normal_iterator(const unsigned char * const&);
     reference operator*(void) const;
     _Iterator operator->(void) const;
     __gnu_cxx::__normal_iterator<unsigned char const*, _Container> & operator++(void);
     __gnu_cxx::__normal_iterator<unsigned char const*, _Container> operator++(int);
     __gnu_cxx::__normal_iterator<unsigned char const*, _Container> & operator--(void);
     __gnu_cxx::__normal_iterator<unsigned char const*, _Container> operator--(int);
     reference operator[](difference_type) const;
     __gnu_cxx::__normal_iterator<unsigned char const*, _Container> & operator+=(difference_type);
     __gnu_cxx::__normal_iterator<unsigned char const*, _Container> operator+(difference_type) const;
     __gnu_cxx::__normal_iterator<unsigned char const*, _Container> & operator-=(difference_type);
    __gnu_cxx::__normal_iterator<unsigned char const*, _Container> operator-(difference_type) const;

     const unsigned char * const& base(void) const;
     void __normal_iterator<unsigned char*>(const
                        __gnu_cxx::__normal_iterator<unsigned char*, _Container> &);

     typedef std::iterator_traits<unsigned char const*>::reference reference;
     typedef _Iterator pointer;
     typedef std::iterator_traits<unsigned char const*>::difference_type difference_type;
     typedef std::iterator_traits<unsigned char const*>::iterator_category iterator_category;
 }