我可以检测编译时使用的标记调度重载吗?
Can I detect which tag dispatch overload is used at compile time?
>假设我有一个使用标签调度从函数的多个实现中进行选择的函子,如下所示:
// base class for all tags, indicating the "default" implementation
struct tag_base { };
// subclasses for tags that might select a different implementation
struct tag1 : tag_base { };
struct tag2 : tag1 { };
struct tag3 : tag2 { };
struct func
{
void operator()(tag_base) { }
void operator()(tag3) { }
};
因此,在这个简单的示例中,标签类型tag1
和tag2
将调度给调用运算符,以进行采用默认实现tag_base
func
。但是,tag3
会改为调度到不同的实现。我有兴趣在编译时检查,对于给定的函数类型func
和两个标签类型T
和U
,它们是否会调度到func
调用运算符的相同重载。
基本上,我想要这样的特征(只有伪代码,因为这种方法不编译):
template <typename Func, typename T, typename U>
struct has_same_tag_overload
{
enum { value = (void (Func::*)(T)) &func::operator() ==
(void (Func::*)(U)) &func::operator() };
}
因此,在上面的示例中,以下内容是正确的:
-
tag<func, tag_base, tag1>::value == 1
-
tag<func, tag_base, tag2>::value == 1
-
tag<func, tag1, tag2>::value == 1
-
tag<func, tag1, tag3>::value == 0
-
tag<func, tag2, tag3>::value == 0
这可能吗?为了增加难度,这在 C++03 中可能吗?
如果标签形成树状层次结构,因此可以写为
struct tag_base { using base = void; };
struct tag1 : tag_base { using base = tag_base; };
struct tag2 : tag1 { using base = tag1; };
struct tag3 : tag1 { using base = tag1; };
...
// or something like tag4: is_a<tag2> {}; if you don't like typing ...
然后我们可以写
template<class U>
struct tag_matcher
{
template<class V, class W = std::enable_if_t<std::is_same<U,V>::value> >
operator V();
};
template<typename F, typename T>
std::true_type match_tag_impl( decltype(F{}(tag_matcher<T>()))* );
template<typename F, typename T>
std::false_type match_tag_impl( ... );
template<typename F, typename T>
struct match_tag
{
using type = std::conditional_t< decltype(match_tag_impl<F,T>(0))::value,
T, typename match_tag<F, typename T::base>::type >;
};
template<typename F>
struct match_tag<F,void> { using type = void; };
template<typename F, typename T, typename U>
struct has_same_tag_overload:
std::is_same< typename match_tag<F,T>::type, typename match_tag<F,U>::type > {};
这个想法是检查所有祖先以找到最派生的匹配项,然后检查两者是否相同。这是 c++11,但据我所知,您也可以让它适用于 c++03。
更新 C++03:
如注释中所述,上面定义的tag_matcher不能在 C++03 中工作,因为我们那里没有默认的函数模板参数,因此无法使用启用 SFINAE 的转换运算符模板。也就是说,我们可以移动与标记转换构造函数相同的逻辑:
template<class U>
struct tag_matcher{};
// macro just for expository purposes
#define MATCHME(TAG) template<class T> TAG( tag_matcher<T>, std::enable_if_t<std::is_same<T,TAG>::value>* = 0 )
struct tag_base { using base = void; MATCHME(tag_base); };
struct tag1 : tag_base { using base = tag_base; MATCHME(tag1); };
// ...
我能想到的最简单的方法会使func
类型的定义严重复杂化。我将在这里使用 C++14 个功能:
#include <type_traits>
template <typename Func, typename Tag1, typename Tag2>
using has_same_tag_overload =
std::is_same<decltype(Func::fn(Tag1{})), decltype(Func::fn(Tag2{}))>;
struct func
{
static auto fn(tag_base) {
return [] { std::cout << "tag_basen"; };
}
static auto fn(tag3) {
return [] { std::cout << "tag3n"; };
}
template <typename Tag>
void operator()(Tag tag)
{
fn(tag)();
}
};
这个想法是,你让你的func
结构在调用它之前创建要调用的函数,让每个函数都是不同的类型。这意味着我们可以简单地比较函数类型 std::is_same
.
这在 C++03 中是可行的,但代码变得更加混乱。 func
必须返回不同的函数对象类型。而不是decltype
,您可以使用sizeof
技巧(让每个函数对象类型具有不同的大小func
以便您可以比较大小。
相关文章:
- 继承函数的重载解析
- 你能重载对象变量名本身返回的内容吗
- 从父命名空间重载类型
- 使用C++中的模板和运算符重载执行矩阵运算
- 为什么这个运算符<重载函数对 STL 算法不可见?
- 如何在c++中实现处理器调度模拟器
- 重载操作程序时出错>>用于类中的字符串 memebr
- 一个关于在C++中重载布尔运算符的问题
- 不同翻译单元中不可重载的非内联函数定义
- 为什么使用SFINAE而不是函数重载
- 为什么我不能在 C++ 中的特定函数重载中调用同一函数的任何其他重载?
- 将重载的成员函数传递给函数模板
- c++:可变模板和函数重载
- 重载元组索引运算符-C++
- 如何使用重载的相等(==)运算符向测试用例添加描述
- 重载==不适用于二进制树
- 为什么Mat类的两个对象可以在不重载运算符+的情况下添加
- 重载运算符new[]的行为取决于析构函数
- 正在尝试重载二进制搜索树分配运算符
- 我可以检测编译时使用的标记调度重载吗?