const 和非 const 类型的相同模板特化
Same template specialization for const & non const type
我有以下代码:
#include <iostream>
class A
{};
class B
{};
template<typename T>
void Do(T data)
{
std::cout << "Do() default\n";
}
template<>
void Do(A* data)
{
std::cout << "Do(A*)\n";
}
template<>
void Do(B* data)
{
std::cout << "Do(B*)\n";
}
int main(int argc, char* argv[])
{
A* a = nullptr;
B* b = nullptr;
const A* aConst = nullptr;
const B* bConst = nullptr;
Do(a);
Do(aConst);
Do(b);
Do(bConst);
return 0;
}
输出:
Do(A*)
Do() default
Do(B*)
Do() default
我应该如何重写代码以共享 const 和非 const 类型的模板专业化而不用复制粘贴带有 const 关键字说明符的专业化以便它产生输出:
Do(A*)
Do(A*)
Do(B*)
Do(B*)
如果你愿意写一个小存根,你可以使用这个模式:
template<>
void Do(const A* data)
{
std::cout << "Do(A*)\n";
}
template<>
void Do(A* data)
{
Do((const A*)data);
}
您不想复制的主要代码使用 const A*
,因为,好吧,您希望它也适用于 const 数据。非常量的只是转发给它。
您可以超载而不是专门化。使用
template<typename T, std::enable_if_t<std::is_same_v<std::decay_t<T>, A>, bool> = true>
void Do(T* data)
{
std::cout << "Do(A*)\n";
}
template<typename T, std::enable_if_t<std::is_same_v<std::decay_t<T>, B>, bool> = true>
void Do(T* data)
{
std::cout << "Do(B*)\n";
}
当您传递 const A*
/A*
/const B*
/B*
时将调用这些函数,因为它们比通用模板更匹配。它们更匹配的原因是 T
受到更多限制。它被认为更专业,因此它将在重载决议中使用通用模板的决胜局中获胜。
C++14
我投票 这是 SFINAE 的一个很好的展示。要对其进行扩展,您可以使用 std::is_convertible
简化 SFINAE 表达式。这更类似于重载解析的工作方式(添加 const 限定符)。
template<typename T, std::enable_if_t<std::is_convertible_v<T*, const A*>, int> = 0>
void Do(T* data)
{
std::cout << "Do(A*)\n";
}
template<typename T, std::enable_if_t<std::is_convertible_v<T*, const B*>, int> = 0>
void Do(T* data)
{
std::cout << "Do(B*)\n";
}
C++17
作为奖励,在带有 constexpr if
的 C++17 中,您可以对所有情况使用单个函数:
template<typename T>
void Do(T data)
{
if constexpr (std::is_convertible_v<T, const A*>)
std::cout << "Do(A*)\n";
else if constexpr (std::is_convertible_v<T, const B*>)
std::cout << "Do(B*)\n";
else
std::cout << "Do() default\n";
}
我有以下代码:
#include <iostream>
class A
{};
class B
{};
template<typename T>
void Do(T data)
{
std::cout << "Do() default\n";
}
template<>
void Do(A* data)
{
std::cout << "Do(A*)\n";
}
template<>
void Do(B* data)
{
std::cout << "Do(B*)\n";
}
int main(int argc, char* argv[])
{
A* a = nullptr;
B* b = nullptr;
const A* aConst = nullptr;
const B* bConst = nullptr;
Do(a);
Do(aConst);
Do(b);
Do(bConst);
return 0;
}
输出:
Do(A*)
Do() default
Do(B*)
Do() default
我应该如何重写代码以共享 const 和非 const 类型的模板专业化而不用复制粘贴带有 const 关键字说明符的专业化以便它产生输出:
Do(A*)
Do(A*)
Do(B*)
Do(B*)
如果你愿意写一个小存根,你可以使用这个模式:
template<>
void Do(const A* data)
{
std::cout << "Do(A*)\n";
}
template<>
void Do(A* data)
{
Do((const A*)data);
}
您不想复制的主要代码使用 const A*
,因为,好吧,您希望它也适用于 const 数据。非常量的只是转发给它。
您可以超载而不是专门化。使用
template<typename T, std::enable_if_t<std::is_same_v<std::decay_t<T>, A>, bool> = true>
void Do(T* data)
{
std::cout << "Do(A*)\n";
}
template<typename T, std::enable_if_t<std::is_same_v<std::decay_t<T>, B>, bool> = true>
void Do(T* data)
{
std::cout << "Do(B*)\n";
}
当您传递 const A*
/A*
/const B*
/B*
时将调用这些函数,因为它们比通用模板更匹配。它们更匹配的原因是 T
受到更多限制。它被认为更专业,因此它将在重载决议中使用通用模板的决胜局中获胜。
C++14
我投票 std::is_convertible
简化 SFINAE 表达式。这更类似于重载解析的工作方式(添加 const 限定符)。
template<typename T, std::enable_if_t<std::is_convertible_v<T*, const A*>, int> = 0>
void Do(T* data)
{
std::cout << "Do(A*)\n";
}
template<typename T, std::enable_if_t<std::is_convertible_v<T*, const B*>, int> = 0>
void Do(T* data)
{
std::cout << "Do(B*)\n";
}
C++17
作为奖励,在带有 constexpr if
的 C++17 中,您可以对所有情况使用单个函数:
template<typename T>
void Do(T data)
{
if constexpr (std::is_convertible_v<T, const A*>)
std::cout << "Do(A*)\n";
else if constexpr (std::is_convertible_v<T, const B*>)
std::cout << "Do(B*)\n";
else
std::cout << "Do() default\n";
}