c++ - 何时使用 "identity"tmp 技巧？

Question

我见过使用此元函数，但从未真正理解为什么需要它以及在什么情况下需要它。谁能举例说明一下？

template <typename T>
struct identity
{
    using type = T;
};

Answer 1

技巧#1

防止模板参数推导:

template <typename T>
void non_deducible(typename identity<T>::type t) {}

non_deducible(1);      // error
non_deducible<int>(1); // ok

template <typename T>
void first_deducible(T a, typename identity<T>::type b) {}

first_deducible(5, 'A'); // ok

---

技巧#2

禁用不安全/不需要的隐式推导指南 (c++17):

template <typename T>
struct smart_ptr {
    smart_ptr(typename identity<T>::type* ptr) {}
};

smart_ptr{new int[10]};  // error
smart_ptr<int>{new int}; // ok

---

技巧#3

使定义类型特征(和其他元函数)更容易:

template <typename T>
struct remove_pointer : identity<T> {};

template <typename T>
struct remove_pointer<T*> : identity<T> {};

---

技巧#4

可用于标签调度:

void foo(identity<std::vector<int>>) {}
void foo(identity<std::list<int>>) {}

template <typename T>
void bar(T t) {
    foo(identity<T>{});
}

---

技巧#5

可用于返回类型:

template <int I>
constexpr auto foo() {
    if constexpr (I == 0)
        return identity<int>{};
    else
        return identity<float>{};
}

decltype(foo<1>())::type i = 3.14f;

---

技巧#6

帮助专门化接受转发引用的函数:

template <typename T, typename U>
void foo(T&& t, identity<std::vector<U>>) {}

template <typename T>
void foo(T&& t) { foo(std::forward<T>(t), identity<std::decay_t<T>>{}); }

foo(std::vector<int>{});

---

技巧#7

为声明类型提供替代语法，例如指针/引用:

int foo(char);
identity<int(char)>::type* fooPtr = &foo; // int(*fooPtr)(char)

identity<const char[4]>::type& strRef = "foo"; // const char(&strRef)[4]

---

技巧#8

可用作期望嵌套 T::type 存在或延迟其评估的代码的包装器:

struct A {};
struct B { using type = int; };

std::conditional<has_type<A>, A, identity<float>>::type::type; // float
std::conditional<has_type<B>, B, identity<float>>::type::type; // B

---

技巧#9

过去，它曾经作为 decltype() 说明符中缺少范围运算符的解决方法:

std::vector<int> v;
identity<decltype(v)>::type::value_type i;
// nowadays one can say just decltype(v)::value_type

---

identity 实用程序是 proposed待添加到 c++20 :

namespace std {
    template <typename T>
    struct type_identity { using type = T; };

    template <typename T>
    using type_identity_t = typename type_identity<T>::type;
}