boost::hana tag_of 实施
boost::hana tag_of implementation
我想知道 when
专业化在 boost::hana::when<false>
案例没有案例库的情况下如何工作。
boost::hana::tag_of
实施:
template<bool condition>
struct when; // forward declaration only
template<typename T, typename = void>
struct tag_of;
template<typename T, typename>
struct tag_of : tag_of<T, when<true> >
{};
template<typename T, bool condition>
struct tag_of<T, when<condition> >
{
using type = T;
};
和一个测试例子:
struct my_tag {};
struct my_tag2 {};
namespace boost {
namespace hana {
template<class T>
struct tag_of<T, when<std::is_same<T, int>{}()> >
{
using type = my_tag;
};
template<class T>
struct tag_of<T, when<std::is_same<T, unsigned>{}()> >
{
using type = my_tag2;
};
}
}
int main()
{
using type = boost::hana::tag_of<int>::type;
std::cout << std::is_same<type, my_tag>{} << std::endl;
}
我想知道为什么 std::is_same<T, int>{}()
(或 ::value
是相同的)是比 std::is_same<T, unsigned>{}()
更专业的偏特化,以及为什么,如果条件为假在这两种情况下,when<condition>
更专业。
我已经完成了很多元函数并使用了专业化、参数包和排序,但在这种情况下,有些东西我没有看到。
我不明白为什么 when
模板的 true
或 false
值很重要,如果 false
没有默认实现的话]案例。
and I wonder why std::is_same<T, int>{}()
(or with ::value
which is the same), is a more specialized partial specialization than std::is_same<T, unsigned>{}()
, and why, if the condition is false for both case, when<condition>
is more specialized.
它没有更专业。他们根本就不是两个可行的专业。让我们来看看当我们尝试实例化 hana::tag_of<int>
.
时会发生什么
- 填写默认模板参数。在本例中,第二个模板参数默认为
void
,因此我们实际上有 hana::tag_of<int, void>
.
- 考虑哪些部分专业化是可行的。在这种情况下,none 是可行的——我们的类型 (
int
) 不是引用或 cv 限定的,也不是任何类型的when<condition>
。由于 none 的特化是可行的,我们实例化主模板。
- 主要
tag_of<T, void>
继承自 tag_of<T, when<true>>
。所以现在我们需要实例化第二种类型,这意味着我们重做步骤#2。
现在,可以选择两种不同的专业:
// from hana's core
template <typename T, bool condition>
struct tag_of<T, when<condition>>
// yours
template <typename T>
struct tag_of<T, when<std::is_same<T, int>{}()>>
请注意,您的其他专业 不可行 - 因为 std::is_same<T, unsigned>{}
是 false
而我们正在尝试匹配 when<true>
。
- 在这两个特化之间,如果我们通过部分排序规则,你的更特化 - 所以它被选中并实例化。
因此,hana::tag_of<int>::type
是hana::tag_of<int, void>::type
是hana::tag_of<int, when<true>>::type
是hana::tag_of<int, when<std::is_same<T, int>{}()>>::type
是my_tag
。
The thing is that I don't see why the true
or false
value of the when template can matter, if there's no default implementation for the false
case.
以上内容有望说明其重要性。我们没有直接实例化 when<false>
,但您可以编写一个专门化来替代 when<false>
(就像您的 when<std::is_same<T, unsigned>{}()>
专门化)。
and why, if the condition is false
for both cases, when<condition>
is more specialized.
由于我们正在实例化 when<true>
,那些条件为 false
的特化被简单地从候选集中排除。可行的专业列表只是减少到 hana 直接提供的列表。这不是 "more specialized" - 它是唯一可行的。
还值得注意的是 tag_of
为您提供了多种专业化方法。您可以提供一些布尔条件 或 使用 void_t
。或者,您可以专门研究顶级:
template <>
struct tag_of<int, void> {
using type = my_tag;
};
这将在上面的第 2 步短路,跳过所有其他实例化。
我想知道 when
专业化在 boost::hana::when<false>
案例没有案例库的情况下如何工作。
boost::hana::tag_of
实施:
template<bool condition>
struct when; // forward declaration only
template<typename T, typename = void>
struct tag_of;
template<typename T, typename>
struct tag_of : tag_of<T, when<true> >
{};
template<typename T, bool condition>
struct tag_of<T, when<condition> >
{
using type = T;
};
和一个测试例子:
struct my_tag {};
struct my_tag2 {};
namespace boost {
namespace hana {
template<class T>
struct tag_of<T, when<std::is_same<T, int>{}()> >
{
using type = my_tag;
};
template<class T>
struct tag_of<T, when<std::is_same<T, unsigned>{}()> >
{
using type = my_tag2;
};
}
}
int main()
{
using type = boost::hana::tag_of<int>::type;
std::cout << std::is_same<type, my_tag>{} << std::endl;
}
我想知道为什么 std::is_same<T, int>{}()
(或 ::value
是相同的)是比 std::is_same<T, unsigned>{}()
更专业的偏特化,以及为什么,如果条件为假在这两种情况下,when<condition>
更专业。
我已经完成了很多元函数并使用了专业化、参数包和排序,但在这种情况下,有些东西我没有看到。
我不明白为什么 when
模板的 true
或 false
值很重要,如果 false
没有默认实现的话]案例。
and I wonder why
std::is_same<T, int>{}()
(or with::value
which is the same), is a more specialized partial specialization thanstd::is_same<T, unsigned>{}()
, and why, if the condition is false for both case,when<condition>
is more specialized.
它没有更专业。他们根本就不是两个可行的专业。让我们来看看当我们尝试实例化 hana::tag_of<int>
.
- 填写默认模板参数。在本例中,第二个模板参数默认为
void
,因此我们实际上有hana::tag_of<int, void>
. - 考虑哪些部分专业化是可行的。在这种情况下,none 是可行的——我们的类型 (
int
) 不是引用或 cv 限定的,也不是任何类型的when<condition>
。由于 none 的特化是可行的,我们实例化主模板。 - 主要
tag_of<T, void>
继承自tag_of<T, when<true>>
。所以现在我们需要实例化第二种类型,这意味着我们重做步骤#2。 现在,可以选择两种不同的专业:
// from hana's core template <typename T, bool condition> struct tag_of<T, when<condition>> // yours template <typename T> struct tag_of<T, when<std::is_same<T, int>{}()>>
请注意,您的其他专业 不可行 - 因为
std::is_same<T, unsigned>{}
是false
而我们正在尝试匹配when<true>
。- 在这两个特化之间,如果我们通过部分排序规则,你的更特化 - 所以它被选中并实例化。
因此,hana::tag_of<int>::type
是hana::tag_of<int, void>::type
是hana::tag_of<int, when<true>>::type
是hana::tag_of<int, when<std::is_same<T, int>{}()>>::type
是my_tag
。
The thing is that I don't see why the
true
orfalse
value of the when template can matter, if there's no default implementation for thefalse
case.
以上内容有望说明其重要性。我们没有直接实例化 when<false>
,但您可以编写一个专门化来替代 when<false>
(就像您的 when<std::is_same<T, unsigned>{}()>
专门化)。
and why, if the condition is
false
for both cases,when<condition>
is more specialized.
由于我们正在实例化 when<true>
,那些条件为 false
的特化被简单地从候选集中排除。可行的专业列表只是减少到 hana 直接提供的列表。这不是 "more specialized" - 它是唯一可行的。
还值得注意的是 tag_of
为您提供了多种专业化方法。您可以提供一些布尔条件 或 使用 void_t
。或者,您可以专门研究顶级:
template <>
struct tag_of<int, void> {
using type = my_tag;
};
这将在上面的第 2 步短路,跳过所有其他实例化。