使用“自动”类型推导-如何找出编译器推导的类型？

我如何找出使用auto关键字时编译器推断出的类型？

示例1：更简单

auto tickTime = 0.001;

是推导为afloat还是adouble?

示例2：更复杂（和我目前的头痛）：

typedef std::ratio<1, 1> sec;
std::chrono::duration<double, sec > timePerTick2{0.001};
 auto nextTickTime = std::chrono::high_resolution_clock::now() + timePerTick2;

什么类型的nextTickTime？

我遇到的问题是尝试发送nextTickTime给时std::cout。我收到以下错误：

./main.cpp: In function ‘int main(int, char**)’:
./main.cpp:143:16: error: cannot bind ‘std::basic_ostream<char>’ lvalue to ‘std::basic_ostream<char>&&’
  std::cout << std::setprecision(12) << nextTickTime << std::endl; // time in seconds
            ^
In file included from /usr/include/c++/4.8.2/iostream:39:0,
             from ./main.cpp:10:
/usr/include/c++/4.8.2/ostream:602:5: error:   initializing argument 1 of ‘std::basic_ostream<_CharT, _Traits>& std::operator<<(std::basic_ostream<_CharT, _Traits>&&, const _Tp&) [with _CharT = char; _Traits = std::char_traits<char>; _Tp = std::chrono::time_point<std::chrono::_V2::system_clock, std::chrono::duration<double, std::ratio<1l, 1000000000l> > >]’
 operator<<(basic_ostream<_CharT, _Traits>&& __os, const _Tp& __x)

我喜欢使用Effective Modern C ++中的想法，该想法使用未实现的模板；输出的类型带有编译器错误：

 template<typename T> struct TD;

现在对于auto variable var，在其定义后添加：

 TD<decltype(var)> td;

并注意您的编译器的错误消息，其中将包含类型var。

一个不需要任何预先帮助者定义的lo-fi技巧是：

typename decltype(nextTickTime)::_

编译器会抱怨它_不是任何类型的成员nextTickTime。

这是一个typeid用于boost::core::demangle在运行时获取类型名称的版本。

#include <string>
#include <iostream>
#include <typeinfo>
#include <vector>
using namespace std::literals;

#include <boost/core/demangle.hpp>

template<typename T>
std::string type_str(){ return boost::core::demangle(typeid(T).name()); }

auto main() -> int{
    auto make_vector = [](auto head, auto ... tail) -> std::vector<decltype(head)>{
        return {head, tail...};
    };

    auto i = 1;
    auto f = 1.f;
    auto d = 1.0;
    auto s = "1.0"s;
    auto v = make_vector(1, 2, 3, 4, 5);

    std::cout
    << "typeof(i) = " << type_str<decltype(i)>() << '\n'
    << "typeof(f) = " << type_str<decltype(f)>() << '\n'
    << "typeof(d) = " << type_str<decltype(d)>() << '\n'
    << "typeof(s) = " << type_str<decltype(s)>() << '\n'
    << "typeof(v) = " << type_str<decltype(v)>() << '\n'
    << std::endl;
}

哪个在我的系统上打印此：

typeof(i) = int
typeof(f) = float
typeof(d) = double
typeof(s) = std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >
typeof(v) = std::vector<int, std::allocator<int> >

typeid通常可以用来获取变量的类型。它取决于编译器，我已经看到它给出了奇怪的结果。g ++默认情况下启用RTTI，但不确定Windows端。

#include <iostream>
#include <typeinfo>
#include <stdint.h>
#include <chrono>
#include <ctime>

typedef std::ratio<1, 1> sec;
int main()
{
    auto tickTime = .001;
    std::chrono::duration<double, sec > timePerTick2{0.001};
    auto nextTickTime = std::chrono::high_resolution_clock::now() + timePerTick2;
    std::cout << typeid(tickTime).name() << std::endl;
    std::cout << typeid(nextTickTime).name() << std::endl;

    return 0;
}

./a.out | c++filt

double
std::__1::chrono::time_point<std::__1::chrono::steady_clock, std::__1::chrono::duration<long long, std::__1::ratio<1l, 1000000000l> > >

正如Daniel Jour所说，请阅读错误消息：

... _Tp = std::chrono::time_point<
           std::chrono::_V2::system_clock,
           std::chrono::duration<
             double, std::ratio<1l, 1000000000l> > > ...

低技术的解决方案是将鼠标悬停nextTickTime在某些图形用户界面给人的类型，否则设置一.后nextTickTime的cout，选择一个合理的期待值或功能。

通常，如果您知道什么类型，就可以使用；auto如果您不知道，请不要使用它。这有点直观。

因此，如果您知道它是一个插入器，则只需使用auto来减少咒语，如果结果是某种未知类型，则必须在使用之前先找出它的含义auto。

另请参见Herb，Andrei和Scott的讨论auto

这样的答案为打印类型名称提供了一个不错的功能（实际上是几个实现）。

此外，这个免费的，开源的，仅标头的库提供了一种打印s的值和类型的好方法chrono::duration。

将这两个实用程序放在一起：

#include "chrono_io.h"
#include "type_name.h"
#include <iomanip>
#include <iostream>

int
main()
{
    using namespace date;
    typedef std::ratio<1, 1> sec;
    std::chrono::duration<double, sec > timePerTick2{0.001};
    auto nextTickTime = std::chrono::high_resolution_clock::now() + timePerTick2;
    std::cout << type_name<decltype(nextTickTime)>() << '\n';
    std::cout << std::setprecision(12) << nextTickTime.time_since_epoch() << '\n';
}

此输出对我来说：

std::__1::chrono::time_point<std::__1::chrono::steady_clock, std::__1::chrono::duration<double, std::__1::ratio<1, 1000000000> > >
4.8530542088e+14ns

错误消息中由编译器推断出的类型：

/usr/include/c++/4.8.2/ostream:602:5: error:   initializing argument 1 of ‘std::basic_ostream<_CharT, _Traits>& std::operator<<(std::basic_ostream<_CharT, _Traits>&&, const _Tp&) [with _CharT = char; _Traits = std::char_traits<char>;
 _Tp = std::chrono::time_point<std::chrono::_V2::system_clock, std::chrono::duration<double, std::ratio<1l, 1000000000l> > >]’
  ^^   <-------- the long type name --------------------------------------------------------------------------------------->

它是一个复杂的类型名称，但是在错误消息中却存在。

附带说明，要有效地打印出其中的值，nextTickTime应显式转换为合适的值std::chrono::duration并输出的结果duration::count。

using std::chrono::duration_cast;
using std::chrono::seconds;

auto baseTime = ...;
std::cout << std::setprecision(12) << duration_cast<seconds>(nextTickTime - baseTime).count()
    << std::endl; // time in seconds

这是一种强制执行编译错误的方法，它显示了以下类型tickTime：

struct {} baD = tickTime;

@ jonathan-oconnor指出，您可以使用[[deprecated]]C ++ 14中引入的属性来产生非常干净的解决方案：

template<typename T>
[[deprecated]] constexpr void printType(T const&) {}

但是遗憾的是，MSVC发出的诊断未提及类型。（示例）