C++ const&；的相同模板专门化；非常量类型

我有以下代码：

#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;
}

我应该如何重写代码以共享const和non-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);
}

模板
无效Do（常数A*数据）
{
std:：cout如果您愿意编写一个小存根，您可以使用此模式：

template<>
void Do(const A* data)
{
    std::cout << "Do(A*)\n";
}

template<>
void Do(A* data)
{
    Do((const A*)data);
}

模板
无效Do（常数A*数据）
{
std:：cout您可以重载，而不是专门化

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";
}

模板
无效Do（T*数据）
{
std:：cout您可以重载，而不是专门化

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";
}

模板
无效Do（T*数据）
{
std:：coutc++14
我投票决定了这是一个很好的SFINAE展示。为了扩展它，可以使用
std:：is_convertible
简化SFINAE表达式。这与重载解析的工作方式更相似（添加常量限定符）

模板
无效Do（T*数据）
{
std:：coutc++14
我投票决定了这是一个很好的SFINAE展示。为了扩展它，可以使用
std:：is_convertible
简化SFINAE表达式。这与重载解析的工作方式更相似（添加常量限定符）

模板
无效Do（T*数据）
{
std:：cout
templatevoiddo（A*data）
调用
templatevoiddo（const A*data）
？或者你想避免中间调用吗？如果你使用重载而不是专门化，一个相关且非常常见的问题是常量/非常量成员函数的代码重用。有不同的解决方案，通常也可以应用于常量限定参数。我提出了我的。
templatevoid Do（A*数据）
调用
模板无效Do（常数A*数据）
？或者您想避免中间调用吗？如果您使用重载而不是专门化，一个相关且非常常见的问题是常量/非常量成员函数的代码重用。有不同的解决方案，通常也可以应用于常量限定参数。我提出了我的方案。我喜欢新的name.这基本上就是我要找的，谢谢。你错过了几个typename的tho。@mezo使用
enable\u if\u t
时不需要这些typename。如果我使用的是
std:：enable\u if:：type
，我会的，因为
：：type
是一个依赖类型。请看这里没有它们的代码：我喜欢新名称。这基本上是我在找什么，谢谢。你错过了几个typename的tho。@mezo使用
enable\u if\u t
时不需要这些typename。如果我使用的是
std:：enable\u if:：type
，那么我会的，因为
：：type
是一个依赖类型。请参阅没有它们的代码：