unable to determine the template type even it is passed in

Question

I have the following code:

template <typename T>
struct Data {
   struct Embed
   { 
      T t;
   };
};

struct Functor {
  template <typename T>
  void foo( typename Data<T>::Embed & e) {}
};
template <typename T, typename F>
struct Caller
{
  F f;
  template <typename T>
  void invoke() {
    typename Data<T>::Embed e;
    f.foo<T>(e); //compiler error pointed this line
   }
 };

Then I specialized the template as:

 Caller<int, Functor> c;
 c.invoke();

compiler error is : error: expected primary-expression before '>' in f.foo<T>(e); line. It seems compiler suddenly doesn't know what T is even it is specified in the template declaration on the function.

Take out the explicit specified T in foo.invoke(e) line will result could not deduce template parameter 'T'

How do I fix this? (I still want to keep the functionality that Caller can have generic functor and functor's function can be templated).

It could be that you are reusing the same template name for `invoke()` as you have for `Caller`. I don't think that is allowed. — NathanOliver, May 29 '15 at 17:41

R Sahu · Answer 1 · 2015-05-29T18:06:22.120

2

You are using:

template <typename T>
void invoke() {
   typename Data<T>::Embed e;
   f.foo<T>(e); //compiler error pointed this line
}

inside Caller even though T is one of the parameters of Caller. Remove the line

template <typename T>

and use just:

void invoke() {
   typename Data<T>::Embed e;
   // f.foo<T>(e);   //compiler error pointed this line
   f.template foo<T>(e); // Need the template keyword here.
}

However, as @Nawaz pointed out in a comment, that changes the semantics of invoke. If T in invoke was meant to be different than the T used to instantiate Caller, then it will be better to use a different name, say U.

edited May 29 '15 at 18:06

answered May 29 '15 at 17:42

R Sahu

204,454
14
159
270

2

I think it changes the semantic. `T` in `invoke` might be different from `T` of the class template. `f.foo(e)` needs to be written as `f.template foo()`. – Nawaz May 29 '15 at 17:55
@Nawaz, true. Updated the answer to reflect that. – R Sahu May 29 '15 at 18:01
@Nawaz I don't think OP wants `invoke` to be a template - the semantics desired were `c.invoke();` – Barry May 29 '15 at 18:02
1

@Barry: Maybe, either way, the `template` keyword is **required**. – Nawaz May 29 '15 at 18:02
@Nawaz, I agree that the `template` keyword is required. Fixed the answer. – R Sahu May 29 '15 at 18:07
@Barry is correct that the calling semantics should be no template. @R Sahu answer is not completely right since foo's parameter is templated so you can not remove the template function declaration. – user2426361 May 29 '15 at 18:30
@user2426361, yes, you can. See http://ideone.com/xtlXAV. – R Sahu May 29 '15 at 18:35
@RSahu Thanks, that is what I want and more elegant. – user2426361 Jun 01 '15 at 21:41

score 2 · Answer 2 · edited May 23 '17 at 12:30

The problem is that f is of type F which is template parameter, f.foo is a dependent name and which happens to be a function template. So you've to use template in a very weird way:

f.template foo<T>(e);

For further explantion, see these:

Also, I'd advise you to use U as template parameter for the function template invoke if at all it needs to be a template, else you can make it a normal function (i.e if the T of invoke is ought to be same as T of the enclosing class template).

Hope that helps.

unable to determine the template type even it is passed in

2 Answers2