模板参数推导不一致

Template argument deduction inconsistent

本文关键字：不一致 参数      更新时间：2023-10-16

以下代码在 MSVC 2019 和 Clang 主干上编译并运行。(我认为它至少需要 C++17(。它不能在 gcc-trunk 上运行，我相信共识是这是由于 gcc 中的一个错误。

但是，当任何元素被用户类型或指针类型替换时，它将在所有编译器上失败。若要查看此信息，请在末尾取消注释tuple_c定义。

我实际上有点惊讶这完全有效，因为它似乎专门化了一个具有通用 ref 参数的函数和一个具有 r-value-ref 参数的函数。也许没关系？如果是，为什么结构失败？

有没有更好的写法？我的意思是一般。我很清楚std::tuple.

#include <iostream>
using namespace std;
template <typename... TP> class Tuple
{
};
template <> class Tuple <>
{
};
template <typename Head, typename... Tail> class Tuple <Head, Tail...>
{
Head head;
Tuple <Tail...> tail;
public:
Tuple ()
{
}
Tuple (const Head& head_in, const Tail&...tail_in)
: head (head_in), tail (tail_in...)
{
}
template <int i> auto Get ()
{
return tail.template Get <i-1> ();
}
template <> auto Get <0> ()
{
return head;
}
template <int i, typename T> void Set (T&& v) // T&& is a universal ref
{
tail.template Set <i-1, T> (static_cast <T&&> (v));
}
template <int i, typename T> void Set (const T& v)
{
tail.template Set <i-1, T> (v);
}
template <> void Set <0, Head> (Head&& v) // Head&& is an rv-ref
{
head = v;
}
template <> void Set <0, Head> (const Head& v)
{
head = v;
}
};
template <typename Head, typename... Tail> Tuple <Head, Tail...> MakeTuple (Head&& head, Tail&&...tail)
{
Tuple <Head, Tail...> result (head, tail...);
return result;
}
struct S
{
int x;
int y;
};
ostream& operator << (ostream& out, const S& s)
{
out << "{" << s.x << "," << s.y << "}";
return out;
}
int main(int argc, char* argv[])
{
auto tuple_a = MakeTuple (1,2,3,4);
tuple_a.Set <1,int> (42);
cout << tuple_a.Get <0> () << 'n';
cout << tuple_a.Get <1> () << 'n';
cout << tuple_a.Get <2> () << 'n';
cout << tuple_a.Get <3> () << 'n';
auto tuple_b = MakeTuple (1,2.3f,3,4);
tuple_b.Set <1,float> (42.3f);
cout << tuple_b.Get <0> () << 'n';
cout << tuple_b.Get <1> () << 'n';
cout << tuple_b.Get <2> () << 'n';
cout << tuple_b.Get <3> () << 'n';
S s {4,5};
//auto tuple_c = MakeTuple (1,2.3f,3,s);
return 0;
}

首先，在 CWG 727 之前，不允许在类作用域内专用成员函数模板。您必须使用constexpr-if、标签调度或 SFINAE 来处理i==0情况。

在 c++14 中使用std::enable_if_t这将是：

template <int i, typename T>
std::enable_if_t<i != 0> Set(T&& v)
{
tail.template Set<i-1>(static_cast<T&&>(v));
}
template <int i, typename T>
std::enable_if_t<i == 0> Set(T&& v)
{
head = static_cast<T&&>(v);
}

在 c++17 中使用constexpr-if它变成：

template <int i, typename T>
void Set(T&& v)
{
if constexpr (i == 0) head = static_cast<T&&>(v);
else tail.template Set<i-1>(static_cast<T&&>(v));
}

其次，一旦编译器允许您在类 cope 中专门化函数模板，您当前的方法就会出现另一个问题。由于模板参数推导如何转发引用，您的MakeTuple实现会创建一个引用类型的元组，这些引用类型对应于那些MakeTuple参数(左值(：

template <typename Head, typename... Tail>
Tuple<Head, Tail...> MakeTuple(Head&& head, Tail&&... tail);

这使您的评论/假设：

void Set<0, Head>(Head&& v) // Head&& is an rv-ref

无效。

也就是说，对于左值表达式s：

S s{ 4, 5 };
MakeTuple(s);

推导出的Head是S&(这也是引用折叠后的head类型(。然后编译器尝试实例化Tuple<S&>并生成以下两个声明：

void Set<0, S&>(S& && v); 
void Set<0, S&>(S& const& v);

引用折叠后，它最终为：

void Set<0, S&>(S& v);
void Set<0, S&>(S& v);

此时，不仅两个定义相同，而且编译器无法决定哪个主要函数模板：

template <int i, typename T>
void Set(T&& v);
template <int i, typename T>
void Set(const T& v);

它们是专业化的，因为使用T=S&两者匹配。这可以通过在将每种类型存储在元组中之前对其进行衰减来解决：

template <typename Head, typename... Tail>
Tuple<std::decay_t<Head>, std::decay_t<Tail>...> MakeTuple(Head&& head, Tail&&... tail);

我的问题在上面得到了回答，但我认为包含解决方案的完整代码可能很有用。它现在适用于除数组和字符串文本之外的所有类型。

#include <iostream>
using namespace std;
template <typename... TP> class Tuple
{
};
template <> class Tuple <>
{
};
template <typename Head, typename... Tail> class Tuple <Head, Tail...>
{
Head head;
Tuple <Tail...> tail;
public:
Tuple ()
{
}
Tuple (const Head& head_in, const Tail&...tail_in)
: head (head_in), tail (tail_in...)
{
}
template <int i> auto Get ()
{
return tail.template Get <i-1> ();
}
template <> auto Get <0> ()
{
return head;
}
template <int i, typename T> void Set (T&& v) 
{
tail.template Set <i-1, T> (static_cast <T&&> (v));
}
template <int i, typename T> void Set (const T& v)
{
tail.template Set <i-1, typename std::decay<T>::type> (v);
}
template <> void Set <0, typename std::decay<Head>::type> (Head&& v) 
{
head = v;
}
template <> void Set <0, typename std::decay<Head>::type> (const Head& v)
{
head = v;
}
};
template <typename Head, typename...Tail> Tuple <typename std::decay <Head>::type, typename std::decay<Tail>::type...> MakeTuple (Head&& head, Tail&&...tail)
{
Tuple <typename std::decay <Head>::type, typename std::decay<Tail>::type...> result (head, tail...);
return result;  
}
struct S
{
int x;
int y;
};
ostream& operator << (ostream& out, const S& s)
{
out << "{" << s.x << "," << s.y << "}";
return out;
}
int main(int argc, char* argv[])
{
const char* p = "hello";
S s;
int v = 32;
auto tuple_a = MakeTuple (1.0,v,p,s);
cout << tuple_a.Get <0> () << endl;
cout << tuple_a.Get <1> () << endl;
cout << tuple_a.Get <2> () << endl;
cout << tuple_a.Get <3> () << endl;
S s_update {10,12};
tuple_a.Set <3> (s_update);
const char* p_update = "goodbye";
tuple_a.Set <2> (p_update);
cout << tuple_a.Get <0> () << endl;
cout << tuple_a.Get <1> () << endl;
cout << tuple_a.Get <2> () << endl;
cout << tuple_a.Get <3> () << endl;
}
相关文章：