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