Question

Please consider the following example:

#include <string>
#include <vector>

using std::string;
using std::vector;

template <typename T>
const T GetValue()
{
    return T(); // some value
}

template <typename T>
const vector<T> GetValue()
{
    return vector<T>(); // some vector of values
}

int main(int argc, char* argv[])
{
    int i = GetValue<int>();
    vector<int> = GetValue<vector<int>>();
    return 0;
}

I have two template functions which are supposed to parse values from some storage depending on an given type. The first should do the job for simple data types, the second for vectors of simple data types only.
My problem is that the template matching is ambiguous since T may be vector<T>.
I wonder how to implement the overload/specialization for the vector types properly.

Any help would be greatly appreciated!

Answer 1

One simple way is to use an out-param, so that the template parameter can be deduced from the argument:

#include <vector>
using std::vector;

template <typename T>
void GetValue(T &t)
{
    t = T(); // some value
}

template <typename T>
void GetValue(vector<T> &v)
{
    v = vector<T>(); // some vector of values
}

int main(int argc, char* argv[])
{
    int i;
    GetValue(i);
    vector<int> v;
    GetValue(v);
    return 0;
}

GetValue(v) isn’t ambiguous, since the template argument deduction rules say that the second overload is the better match.

This isn’t necessarily the interface/style you want, though, in which case you could use partial specialization instead of overloading. But that requires a class, since function templates cannot be partially specialized:

#include <vector>
using std::vector;

template <typename T>
struct Getter {
    T get(void) {
        return T(); // some value
    }
};

template <typename T>
struct Getter<vector<T> > {
    vector<T> get(void) {
        return vector<T>(); // some vector of values
    }
};

template <typename T>
T GetValue(void)
{
    return Getter<T>().get();
}

int main(int argc, char* argv[])
{
    int i = GetValue<int>();
    vector<int> v = GetValue<vector<int> >();
    return 0;
}