Home / Questions / 74710
Accepted
cheroky
Asked: 2020-06-01 06:54:07 +0800 CST 2020-06-01 06:54:07 +0800 CST

何时使用 decltype 和 auto？

  • 772

你好，我知道两者都进行类型推导，但是两者有什么区别呢？decltype什么时候使用信封更方便，auto反之亦然？

c++

2 Answers

  1. Best Answer

    auto允许您从变量开始的值推断类型：

    auto i = 5;   // int
auto f = 4.5; // double

    但是，auto它无法涵盖所有​​可能性……

    想象一下，您必须编写一个模板，这样：

    tipo1 func(objeto)
{ return objeto.otraFunc(); }

    您如何对该模板进行编程？

    版本 1

    auto func(auto objeto)
{
  return objeto.otraFunc();
}

    在 C++17 中有效，在 C++11 中无效

    第 2 版

    template<class T, class U>
T func(U objeto)
{ return objeto.otraFunc(); }

    与所有版本兼容，但使用起来有点麻烦，因为虽然U可以自动推断类型，但T必须明确指出类型：

    struct POO
{
  int otraFunc()
  { return 5; }
};

POO MiObjeto;
std::cout << func<int>(MiObjeto);

    2.1版

    为了推导出这两个值，我们创建了一个中间结构作为特征：

    struct POO
{
  int otraFunc()
  { return 5; }
};

// Implementación por defecto = no valida
template<class T>
struct traits;

template<>
struct traits<POO>
{
  typedef int returnType;
};

template<class T>
typename traits<T>::returnType func(T objeto)
{ return objeto.otraFunc(); }


int main()
{
  POO MiObjeto;
  std::cout << func(MiObjeto);
}

    尽管很容易理解，这种解决方案开始变得相当繁琐。

    第 3 版

    ...或者我们也可以使用decltype

    struct POO
{
  int otraFunc()
  { return 5; }
};

template<class T>
decltype(T().otraFunc()) func(T objeto)
{ return objeto.otraFunc(); }

    int main()
{
  POO MiObjeto;
  std::cout << func(MiObjeto);
}

    在这种情况下，它decltype计算的表达式T().otraFunc()只不过是：

    • T()：模拟创建类型的新对象T
    • T().otraFunc()模拟调用并为该类型保留函数的返回otraFunc类型T

    可能会发生默认构造函数T不适用于给定类型...在这种情况下无法评估上述表达式...我们可以使用指针获得更通用的版本：

    template<class T>
decltype(((T*)nullptr)->otraFunc()) func(T objeto)
{ return objeto.otraFunc(); }

    由于decltype 它不执行代码而只是对其进行评估，因此不存在内存泄漏或调用无效对象的风险......当然我们不能使用new......

    顺便说一句，有些人更喜欢 C++11 中其他完全有效的命名法

    template<class T>
auto func(T objeto) -> decltype(((T*)nullptr)->otraFunc())
{ return objeto.otraFunc(); }

    当然decltype它也可以用来评估更简单的表达式：

    decltype(5) var = 4; // decltype(5) == int
std::cout << var;    // imprime 4

float foo();
decltype(foo()) var2 = 4.5// float

decltype(var2) var3 = 3; // float

    编辑

    另一种使用方式decltype，与declval. 所以我们不必担心应该如何创建对象T：

    template<class T>
auto func(T objeto) -> decltype(std::declval<T&>().otraFunc())
{ return objeto.otraFunc(); }
    • 3

  2. decltype什么时候使用信封更方便，auto反之亦然？

    decltype而且auto它们不可互换或等效，它们的用途、行为和目的是不同的。

    auto是一个声明器，它在可以通过初始化进行声明的地方推断类型：

    • 如果初始值设定项是文字，它将推导出文字的（非常​​量）类型。
    • 如果初始化器是一个引用，它将忽略该引用。
    • 如果初始化器使用constorvolatile限定，则如果应用于对象（第一级限定符），这些限定符将被忽略。
    • 如果初始值设定项是一个表达式，它将推导出计算表达式产生的（非常量）类型（考虑到前面的几点）。
    • 如果初始化器是一个函数，它将推断出函数的返回类型（牢记以上几点）。

    decltype(...)是一个复制已经存在的东西类型的声明器：

    • 如果它的括号之间有一个文字，它将推断它的类型（不是常量）。
    • 如果括号之间有表达式或函数，它将推断出通过评估所述表达式（不实际评估它）或函数（不进行调用）产生的类型。
    • 如果其括号之间的括号中有表达式，则将其视为左侧值并推断引用。

    至于何时使用它们，就像任何工具一样：必要时。

    什么时候需要？

    auto没有和的帮助，有些事情是无法编程的decltype；它们通常是程序员不可能（或很难）知道但对编译器来说微不足道的事情，例如未知类型之间的操作：

    template <typename I, typename D>
auto suma(I i, D d) -> decltype(i + d)
{
    return i + d;
}

    在模板函数的上下文中，suma程序员不可能知道函数的返回类型，我们不知道它是I什么类型以及它是什么类型，D直到我们实例化模板时我们才会知道，但是我们不能在 ! 编译时更改模板！

    幸运的是，编译器拥有程序员缺少的信息，并且在实例化模板时知道它们是什么类型，I并且D在这种情况下auto，它告诉编译器：“我不知道函数的返回类型是什么但稍后会推导出“同时decltype它会告诉你”推导出表达式的类型i + d并将其分配给函数的返回值suma“。

    以便：

    • suma(1, 2.f)有作为返回类型float。
    • suma<std::string>("patatas", " fritas!")有作为返回类型std::string。

    由于同样的原因导致我们忽略了这个函数的返回类型，我们不能创建一个变量来捕获它的值：

    template <typename I, typename D>
auto suma(I i, D d) -> decltype(i + d)
{
    return i + d;
}

template <typename I, typename D, typename ... T>
auto super_suma(I i, D d, T ... tipos)
{
    ???? sub_suma = suma(i, d);
 // ~~~~ <--- que tipo debo usar aqui?

    if constexpr (sizeof...(tipos) >= 2)
        return sub_suma + super_suma(tipos ...);
    if constexpr (sizeof...(tipos) == 1)
        return sub_suma + std::get<0>(std::make_tuple(tipos ...));
    if constexpr (sizeof...(tipos) == 0)
        return sub_suma;
}

    sub_suma在函数变量中super_suma返回静态类型推导（auto）来救援：

    template <typename I, typename D, typename ... T>
auto super_suma(I i, D d, T ... tipos)
{
    auto sub_suma = suma(i, d);
 // ~~~~ <--- Deja que el compilador lo deduzca por ti!

    if constexpr (sizeof...(tipos) >= 2)
        return sub_suma + super_suma(tipos ...);
    if constexpr (sizeof...(tipos) == 1)
        return sub_suma + std::get<0>(std::make_tuple(tipos ...));
    if constexpr (sizeof...(tipos) == 0)
        return sub_suma;
}

    注意super_suma它在定义之后不使用-> decltype；这是 C++14 的一个特性，称为函数返回类型推导。

    的限制auto和decltype

    它的工作方式auto使得无法派生引用，除非你明确地这样做：

    const std::string TEXTO_CONSTANTE("Hola mundo!");

auto f1() { return TEXTO_CONSTANTE; } // auto deduce std::string
auto &f2() { return TEXTO_CONSTANTE; } // auto deduce const std::string &

    如果我们想隐含地将返回值推断为const（这是实际类型），我们应该依赖decltype：

    const std::string TEXTO_CONSTANTE("Hola mundo!");
// auto deduce const std::string
auto f1() -> decltype(TEXTO_CONSTANTE) { return TEXTO_CONSTANTE; }

    从 C++14 开始，可以使用以下方法组合decltype并auto更直接地推断函数的实际返回类型decltype(auto)：

    const std::string TEXTO_CONSTANTE("Hola mundo!");
// Estilo C++11 auto deduce const std::string
auto f1() -> decltype(TEXTO_CONSTANTE) { return TEXTO_CONSTANTE; }
// Estilo C++14 auto deduce const std::string
decltype(auto) f2() { return TEXTO_CONSTANTE; }

    有时这不是必需的，但它很有用。

    声明auto器允许我们在通常需要复制它的地方忽略类型，例如：

    auto monstruosidad = new std::map<std::pair<std::size_t, std::uint64_t>, std::u32string>();

    阅读起来比这更舒服：

    std::map<std::pair<std::size_t, std::uint64_t>, std::u32string> *monstruosidad = new std::map<std::pair<std::size_t, std::uint64_t>, std::u32string>;

    它还允许我们完全忽略类型，因此：

    auto insercion = monstruosidad->insert({{0, 0}, u32"Patata frita!"});

    阅读起来比这更舒服：

    std::pair<std::map<std::pair<std::size_t, std::uint64_t>, std::u32string>::iterator, bool> insercion = monstruosidad->insert({{0, 0}, u32"Patata frita!"});

    这种类型的使用auto引起了一种称为“几乎总是auto”的趋势（英文为“ Almost Always Auto ”或 AAA，由Herb Sutter创造的术语），它建议我们auto在几乎所有情况下都使用它。专门针对 AAA的文章非常好1，我只会翻译我认为最相关的部分：

    懒惰和承诺

    首先是懒惰：“键入auto来声明一个变量主要是少键入”是一个常见的问题。但是，这是对 的目的的误解auto。[...]，使用声明变量的主要原因auto是正确性、性能、可维护性、健壮性，是的，方便，但它在列表中的最后一个。

    二、commit：“但在某些情况下我想commit到一个特定的类型，而不是自动推导出来，所以我不能使用auto.” 确实，有时您需要提交特定类型，但即便如此，您也可以使用auto. [...]，您不仅可以编写诸如auto x = tipo{ inicializador };( 而不是tipo x{inicializador};) 之类的声明来提交特定类型，而且这样做也有充分的理由，例如auto，这意味着您不能忘记初始化变量。

    (一)可读性

    最常见的 [...] 论点是关于可读性的：“除非我扫描函数或表达式的返回，否则当我不知道变量的确切类型时，我的代码很快就会变得不可读，所以我不能总是使用auto。” 这是有道理的，包括能够使用无类型语法搜索特定类型的可能性auto x = expresion;[...] 所以这似乎是一个很好的论点。确实，任何功能都可能被过度使用。然而，我认为这个论点比看起来要弱，有四个原因，两个小，两个主要。

    两个小的反驳是：

    • “不能使用auto”部分是不正确的，因为正如我们之前所见，您可以使类型显式并仍然使用auto，这有很好的好处。
    • 如果您使用的是EDI ，则此参数不适用，因为您始终可以知道确切的类型，例如通过将鼠标悬停在变量上。当然，当您离开 EDI（例如打印代码时）时，这会丢失。

    两个主要的反驳是：

    • 它显示了对编程实现的偏好，而不是接口。过度使用显式类型会使代码的通用性降低，相互依赖程度更高，因此更加脆弱和受限。[...]
    • 我们（指您）已经连续忽略特定类型……

    1虽然我并不完全同意。

    • 2