Question

我有一个模板功能，我想为其提供专业化，以便处理boost::optional<T>。但是，如果我想让我的专业化处理所有类型的boost::optional<T>而不是像boost::optional<int>这样的特定类型，我似乎无法找到适合这种情况的语法。< / p>

这是一个可编辑的例子：

#include <boost/optional.hpp>

template <typename T>
void foo(const T& t)
{}

// This works.
template<>
void foo<int>(const int& t)
{}

// This works.
template<>
void foo<boost::optional<int>>(const boost::optional<int>& t)
{}

// What to do in this case??
// template <typename U>
// void foo<boost::optional<U>>(const boost::optional<U>& t)
// {}

int main() {}

Answer 1

不专业。提供过载。

template <typename U>
void foo(const boost::optional<U>& t)
{
}

Answer 2

你不能局部专门化模板功能。但你可以为class

做到这一点

namespace detail
{
    template <typename T>
    struct foo_impl
    {
        void operator () (const T&) const {};
    }

    template <>
    struct foo_impl<int> // Full specialization for int
    {
        void operator () (int) const {};
    }

    template <>
    struct foo_impl<boost::optional<int>> // Full specialization for boost::optional<int>
    {
        void operator () (const boost::optional<int>&) const {};
    }

    template <typename T>
    struct foo_impl<boost::optional<T>> // Partial specialization for boost::optional<T>
    {
        void operator () (const boost::optional<T>&) const {};
    }

}

template <typename T>
void foo(const T& t)
{
    detail::foo_impl<T>{}(t); // Forward to correct struct
}

否则你可以提供过载（可能更简单）

template <typename T>
void foo(const T&) {}

void foo(int) {}

void foo(const boost::optional<int>&) {}

template <typename T>
void foo(const boost::optional<T>&) {}

关于重载方法的注意事项：

- `foo(42)` and `foo<int>(42)` won't call the same function
- and similarly, with `boost::optional<int> opt_i;`,  
    `foo(opt_i)`, `foo<int>(opt_i)` and `foo<boost::optional<int>>(opt_i)`
     will call 3 different functions.

如何为模板化类型提供模板功能的专业化？

2 个答案: