Question

我试图编写一个模板函数来处理任何类型的参数，包括矢量，地图等，但我遇到了麻烦。

template<class C>
void foo(C c);

template<>
template<class V>
void foo<std::vector<V> >(std::vector<V> v);

编译器（g ++ 4.9.2-10）会抱怨这个：

test.cpp:13:43: error: too many template parameter lists in declaration of ‘void foo(std::vector<V>)’
 void foo<std::vector<V> >(std::vector<V> v) {
                                           ^
test.cpp:13:6: error: template-id ‘foo<std::vector<V> >’ for ‘void foo(std::vector<V>)’ does not match any template declaration
 void foo<std::vector<V> >(std::vector<V> v) {
      ^
test.cpp:13:43: note: saw 2 ‘template<>’, need 1 for specializing a member function template
 void foo<std::vector<V> >(std::vector<V> v) {
                                           ^

我怎样才能做到这一点？我还想专注于std :: map＆lt; std :: string，V＆gt;

删除第一个模板＆lt;＆gt;专业化的路线仍然不起作用（非法专业化）

Answer 1

你不能部分地专门化一个函数，你想创建一个新的重载：

template<class C>
void foo(C c);

template<class V>
void foo(std::vector<V> v); // This is an overload, not a specialization!

请注意foo

部分专业化的差异

template<class C>
void foo(C c); // 1

template<class V>
void foo<std::vector<V>>(std::vector<V> v); // 2

这里2是1的部分特化，在c ++中不允许使用函数。

Answer 2

根据容器的特性，您可能会发现过载很方便。

只需编写一次函数，就可以在接受引用，const引用和r值引用方面提供更多的灵活性。

这是一个小例子，它为具有foo和begin()方法的任何东西实现模板end()，除了std :: strings之外，它获得了自己的{ {1}}通过非模板重载：

foo

预期产出：

#include <vector>
#include <map>
#include <iostream>
#include <iomanip>

// trait type to determine whether something models a range.
template<class T>
struct is_range
{
    template <class Y> static auto has_begin(T*p) -> decltype(p->begin(), void(), std::true_type());
    template <class Y> static auto has_begin(...) -> decltype(std::false_type());

    template <class Y> static auto has_end(T*p) -> decltype(p->end(), void(), std::true_type());
    template <class Y> static auto has_end(...) -> decltype(std::false_type());

    static constexpr bool value = decltype(has_begin<T>(0))::value && decltype(has_end<T>(0))::value;
};


// specialised mini-functor for dealing with corner cases
template<class T>
struct emitter
{
    std::ostream& operator()(std::ostream& os, const T& t) const {
        return os << t;
    }
};

template<class T, class U>
struct emitter<std::pair<T, U>>
{
    std::ostream& operator()(std::ostream& os, const std::pair<T, U>& p) const
    {
        return os << "(" << p.first << ", " << p.second << ")";
    }
};

// a version of foo which works for all known containers, whether temporararies or references
template<class Container,
std::enable_if_t<is_range<std::decay_t<Container>>::value and not std::is_same<std::decay_t<Container>, std::string>::value>* = nullptr
>
void foo(Container&& c)
{
    // do things with c.begin(), c.end()
    bool first = true;
    for (auto& x : c) {
        using emitter_type = emitter<std::decay_t<decltype(x)>>;
        auto emit = emitter_type();
        if (first) {
            first = false;
        } else {
            std::cout << ", ";
        }
        emit(std::cout, x);
    }
    std::cout << std::endl;
}

// overload for std string

void foo(const std::string& s)
{
    std::cout << std::quoted(s) << std::endl;
}

int main()
{
    using namespace std::literals;

    foo(std::map<std::string, std::string> {
        {
            { { "foo" }, { "bar" } },
            { { "aaaa" }, { "bbbbb" } }
        }
    });
    foo(std::vector<std::string> {
        { "foo" },
        { "bar" },
        { "xxxx" },
        { "yyyy" } });

    foo("hello"s);

}

std :: vector <t>上的模板特化

2 个答案: