A function templatized for int, bool, string, vector is giving link errors

Question

The following template seems to be giving link errors.

Is there a reason and a workaround for this code?
I initially started using templates because the overload for bool was getting auto-promoted and conflicting with overload for bool. Is there any way to work around that
In the readMember function call code, it seems I have to specify the template type, even though system has enough knowledge to infer the type. Am I doing something wrong?

Background - I am trying to auto-generate code based on an internal version of class schemas

#include <string>
#include <vector>
#include <json/json.h> // uses jsoncpp

template <typename T>
  bool readMember(const Json::Value& details, const std::string& member, T& value);

template<> bool readMember<std::string>(const Json::Value& details, const std::string& member, std::string& value) {
  return true;
}

template<> bool readMember<int>(const Json::Value& details, const std::string& member, int& value) {
  return true;
}

template<> bool readMember<bool>(const Json::Value& details, const std::string& member, bool& value) {
  return true;
}

template<typename T> bool readMember(const Json::Value& details, const std::string& member,
                           std::vector<T>& value) {

     Json::Value root = details[member];
     for (Json::Value::iterator it=root.begin(); it!=root.end(); ++it) {
         T item_value;
         bool status = readMember<T>(*it, member, item_value);
         value.push_back(item_value);
    }
    return false;
}

class _Settings {
public:
  std::string BE_SERVER;
  std::vector<std::string> backendEnvs;
};

template<> bool readMember<_Settings>(const Json::Value& details, const std::string& member, _Settings& value) {

    readMember<std::vector<std::string>>( details[member], "BE_SERVER", value.BE_SERVER);
    readMember<std::vector<std::string>>( details[member], "backendEnvs", value.backendEnvs);
};

The error is

Undefined symbols for architecture x86_64:
  "bool readMember<std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > > >(Json::Value const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >&)", referenced from:
      bool readMember<_Settings>(Json::Value const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, _Settings&) in settings.o

Notes :- Template line std::string compiles, while the vector line fails.

Does this answer your question? [Partial template specialization of free functions - best practices](https://stackoverflow.com/questions/2403928/partial-template-specialization-of-free-functions-best-practices) — Stephen Newell, Feb 15 '21 at 04:04
Template functions need to be fully defined in a header file, you can't split them into header and implementation files. — Mark Ransom, Feb 15 '21 at 04:06
You seem to believe that `template bool readMember(std::vector&)` is a partial specialization of the primary template `template bool readMember(T&)` (I'm omitting the first two parameters for brevity). There ain't no such thing as a partial specialization of a function template; instead, these are two independent overloads. The way you call the function, as `readMember>(...)`, makes the second overload non-viable, so the first is chosen, but there's no suitable specialization, and the linker complains. — Igor Tandetnik, Feb 15 '21 at 04:24
You could call the second overload explicitly as `readMember(...)` (note that `T` there is the type of the element of the vector, not the vector itself). Or you could drop the explicit template argument altogether, and allow the overload resolution to do its job. Or, you could avoid creating an overload, and use one of a few techniques that simulate partial specialization (e.g. have the function template delegate to a helper class template, then partially specialize that helper template). — Igor Tandetnik, Feb 15 '21 at 04:27
If you do come up with a final solution, post it as an answer rather than an update to the question. — Mark Ransom, Feb 16 '21 at 04:00

score 0 · Answer 1 · answered Mar 11 '21 at 07:01

The reason your code isn't compiling is that you are passing the wrong template parameter to the functions.

To understand why, first, we have to look at the function definitions. Let's start with the most generic case:

// Let's call this f1
// The most generic case is declared but not defined, so any function with
// types matching it but not matching one of its specializations, will fail
// to compile
template <typename T>
bool readMember(const Json::Value& details, const std::string& member, T& value);

The specializations are self-explanatory. Any call with a type matching the type T will compile since it will use the matching function:

// Let's call this f2
// T equals string, last parameter's type is string& (i.e. T&)
template<> bool readMember<std::string>(const Json::Value& details, const std::string& member, std::string& value) {
    return true;
}

// Let's call this f3
// T equals int; last parameter's type is int& (i.e. T&)
template<> bool readMember<int>(const Json::Value& details, const std::string& member, int& value) {
    return true;
}

// Let's call this f4
// T equals bool; last parameter's type is bool& (i.e. T&)
template<> bool readMember<bool>(const Json::Value& details, const std::string& member, bool& value) {
    return true;
}

// Let's call this f5
// This one is also a specialization of the same template function above
// even though it appears later in your code.
// T equals _Settings; last parameter's type is _Settings& (i.e. T&)
template<> bool readMember<_Settings>(const Json::Value& details,
    const std::string& member, _Settings& value) {

    // these two calls are the ones that fail to compile even though the
    // compiler is probably stopping on the first failure
    readMember<std::vector<std::string>>( details[member], "BE_SERVER", value.BE_SERVER);
    readMember<std::vector<std::string>>( details[member], "backendEnvs", value.backendEnvs);
};

Now the overload:

// Let's call this f6
// This is a non-specialized template; the only function that has vector in
// its signature, but note that T is the value_type of the vector. T could be
// a vector, but that would mean you'd have a vector of vectors as the type
// of the last parameter (i.e vector<T>&), which is probably not what you mean
// later on your code
template<typename T> bool readMember(const Json::Value& details,
    const std::string& member, std::vector<T>& value) {
    ...
    return false;
}

Now that we've seen the function signatures, the question is which one of them fits the calls that are failing to compile? The answer is none, but let's take a closer look. First,

readMember<std::vector<std::string>>( details[member], "BE_SERVER", value.BE_SERVER);

The first question is what is T? Let's ignore the type you're giving the compiler:

// this compiles in my compiler BTW; it compiles because the compiler
// determines T as std::string, which is the type of value.BE_SERVER;
// it also determines the type of the last parameter as string& (T&)
// Therefore, this would match f2
readMember( details[member], "BE_SERVER", value.BE_SERVER);

It is equivalent to:

// this compiles in my compiler too
readMember<std::string>( details[member], "BE_SERVER", value.BE_SERVER);

When you explicitly specify T as std::vector<std::string>, it doesn't match any of your defined functions because the type of the last parameter, which is supposed to be T& if it were to match f1, would have to be std::vector<std::strig>&, but it isn't; that's simply not the type of value.BE_SERVER.

If it were to match f6, then the value of the last parameter would have to be std::vector<T>&, so replace the T that you're specifying, and you get std::vector<std::vector<std::string>>& which is not the case. Therefore, it doesn't match f6 either.

Almost there, let's look at the last call:

readMember<std::vector<std::string>>( details[member], "backendEnvs", value.backendEnvs);

Again, this doesn't match any of your defined functions. It doesn't match any of the specializations because none of them have T as a vector, which is what you are explicitly saying that T is (std::vector<std::string>>). Also, it can't match f1 because there is no code for it, so nothing can match that one. If you had provided a definition, code for it, it would compile, but you didn't.

You're only left with f6. Looking at its prototype, the value of the last parameter is std::vector<T>&, but if you plug in the value of T that you're passing, you get std::vector<std::vector<std::string>> which doesn't match the type of value.backendEnvs.

In order for it to match f6, the only one it can possibly match, the value of T has to be std::string. Then, the value of the last parameter would be std::vector<std::string>&, which matches the prototype, std::vector<T>&.

The following two calls compile:

// this compiles
readMember<std::string>( details[member], "backendEnvs", value.backendEnvs);

// or let the compiler figure it out
readMember( details[member], "backendEnvs", value.backendEnvs);

Note: I removed all of the Json related code in order to compile it.

A function templatized for int, bool, string, vector is giving link errors

1 Answers1