专门化模板成员功能

Question

I'm trying to specify a function of a template class, that should only work when an object of the class is created using specific types (KEY as std::string and VALUE as std::string ).

My template ( Dictionary.h ), simplified:

#ifndef QB_DICTIONARY_H
#define QB_DICTIONARY_H

#include <map>
#include <string>

namespace QB {
    template<typename KEY, typename VALUE, typename COMPARE = std::less<KEY>>
    class Dictionary {
    public:
        typedef typename std::map<KEY, VALUE, COMPARE>::iterator iterator;
        typedef typename std::map<KEY, VALUE, COMPARE>::const_iterator const_iterator;

        Dictionary() {
        }

        Dictionary(const std::map<KEY, VALUE, COMPARE> & value) {
            this->value = value;
        }

        typename iterator begin() {
            return value.begin();
        }

        typename const_iterator begin() const {
            return value.cbegin();
        }

        typename iterator end() {
            return value.end();
        }

        typename const_iterator end() const {
            return value.cend();
        }

        // Trying to have the function work only when the template KEY and VALUE are of type std::string
        const std::string implode<std::string, std::string>(const std::string & valueSeparator, const std::string & pairSeparator) const {
            std::string result;

            for (iterator i = begin(); i != end(); i++) {
                if (i != begin()) {
                    result += pairSeparator;
                }

                result += iterator->first;
                result += valueSeparator;
                result += iterator->second;
            }

            return result;
        }

    private:
        std::map<KEY, VALUE, COMPARE> value;
    };
}

#endif

The implode function is the one I'm trying to implement. Trying to compile the above results in this:

1>d:\cloud storage\onedrive\projects\qb\qb\dictionary.h(115): error C2143: syntax error: missing ';' before '<'
1>  d:\cloud storage\onedrive\projects\qb\qb\dictionary.h(133): note: see reference to class template instantiation 'QB::Dictionary<KEY,VALUE,COMPARE>' being compiled
1>d:\cloud storage\onedrive\projects\qb\qb\dictionary.h(115): error C2334: unexpected token(s) preceding '{'; skipping apparent function body

I'm not sure how I should implement this. Any hints?

---

EDIT:

I've encountered some new problems while trying out @TartanLlama's answer.

My current code is as follows (irrelevant parts left out): Dictionary.h :

#ifndef QB_DICTIONARY_H
#define QB_DICTIONARY_H

#include <map>
#include <string>
#include <type_traits>

namespace QB {
    template<typename KEY, typename VALUE, typename COMPARE = std::less<KEY>>
    class Dictionary {
    public:
        // ...

        const std::string implode(const std::string &, const std::string &) const;

        // ...
    };

    template<typename K=KEY, typename V=VALUE, typename COMPARE = std::less<KEY>>
    std::enable_if_t<std::is_same<std::string, K>{} && std::is_same<std::string, V>{}, const std::string> Dictionary<K, V, COMPARE>::implode(const std::string & valueSeparator, const std::string & pairSeparator) const {
        // ...
    }
}

#endif

Answer 1

You can specialize by explicitly instantiate your method member like this outside your class definition :

template<> std::string QB::Dictionary<std::string, std::string>::implode(const std::string & valueSeparator, const std::string & pairSeparator) const {
    std::string result;

    for (const_iterator i = begin(); i != end(); i++) {
        if (i != begin()) {
            result += pairSeparator;
        }

        result += i->first;
        result += valueSeparator;
        result += i->second;
    }

    return result;
}

Live Code

Note that I have fixed other errors (no need to add typename in return method type, use const_iterator...)

Answer 2

You are attempting to explicitly-specialize implode , but it's not a template.

You could use SFINAE to only enable the function if KEY and VALUE are std::string :

template <typename K=KEY, typename V=VALUE>
std::enable_if_t<std::is_same<std::string, K>{} &&
                 std::is_same<std::string, V>{}, 
                 const std::string>
implode(const std::string & valueSeparator, 
        const std::string & pairSeparator) const {
    //...
}

---

You could use static_assert to issue an error if the function is instantiated for the wrong Dictionary specialization:

implode(const std::string & valueSeparator, 
        const std::string & pairSeparator) const { 
    static_assert(std::is_same<std::string, K>{} &&
                  std::is_same<std::string, V>{},
                  "KEY and VALUE must be std::string");
    //...
}