C++ failed template argument deduction. why?

Question

template<typename T>
Ref<Iterator<T> > GetFilterIterator(Ref<Iterator<T> > i, boost::function<bool(T)> pred) {
    return new FilterIterator<T>(i, pred);
}


Ref<Iterator<CWorm*> > x = GetFilterIterator(worms(), &CWorm::getLocal);

And worms() returns a Ref<Iterator<CWorm*> Ref> and there is bool CWorm::getLocal(); (which is a member function). And:

template<typename T> struct Ref {
     // ...
};

template<typename T> struct Iterator {
     // ...
};

This will fail to deduce the template argument:

Iter.h:272:27: note: candidate template ignored: failed template argument deduction [3]

Why?

If I call it with the specified template argument, i.e. GetFilterIterator<CWorm*>(worms(), &CWorm::getLocal), it doesn't complain. I wonder why it cannot deduce the template argument like this. And can I make it different somehow so that it would be able to automatically deduce the type?

[Related?](http://stackoverflow.com/questions/6677072/overload-resolution-failure-when-streaming-object-via-implicit-conversion-to-str) — Lightness Races in Orbit, Jan 10 '12 at 19:54
`bool CWorm::getLocal();` cannot match `boost::function`, because it does not take an argument. — Björn Pollex, Jan 10 '12 at 19:58
@BjörnPollex Is that specific to boost::function? Because it's not required with std::function. — bames53, Jan 10 '12 at 20:23
@bames53: You're right, now that you mention it, i remember reading it somewhere - guess I am wrong then. — Björn Pollex, Jan 10 '12 at 20:30
[This](http://stackoverflow.com/questions/8513050/why-can-template-instances-not-be-deduced-in-stdreference-wrappers/8513174#8513174) should answer your question too. — Xeo, Jan 11 '12 at 19:31
@Xeo: How? It speaks about implicit type conversion, but `Ref Ref>` doesn't need a type conversion to be matched against `Ref >`. — Albert, Jan 13 '12 at 05:56

bames53 · Answer 1 · 2012-01-10T20:38:18.303

Do you mean typname Iterator<T>::Ref for the type of the first parameter in the GetFilterIterator template declaration? If so, that is not a deducible context for template type parameters.

Consider:

template<>
struct Iterator<Foo> {
    typedef int Ref;
};
template<>
struct Iterator<Bar> {
    typedef int Ref;
};

GetFilterIterator(int(0),f);

Both Iterator<Foo>::Ref and Iterator<Bar>::Ref match the parameter passed to GetFilterIterator, an int. Which one should it pick? C++ disallows deducing template types from parameters like the one you've declared.

With the update to your question it looks like you do mean ::Ref<Iterator<T> >. I think that should be deducible then, and since the typedef Iterator<CWorm*>::Ref is ::Ref<Iterator<CWorm*> > it seems like it should be able to deduce T. I'm not sure why it's not working.

score 1 · Answer 2 · answered Jan 11 '12 at 19:25

The compiler cannot deduce the template arguments because fitting to the parameters would mean a non-trivial conversion - first to Iterator<T> and then to Ref<Iterator<T> > which both require user-defined conversions. Also, directly converting the member function pointer to boost::function is similarly non-trivial for the compiler.

IBM has a list of supported template parameter deductions.

If you want your template arguments to be deduced automatically, you have to provide wrapper methods:

template <typename T>
Ref<Iterator<T> > makeIteratorRef(T val)  {
    return Ref<Iterator<T> >(Iterator<T>(val));
}

template <typename T>
boost::function<bool (T)> makeFn(bool (T::*fn) () const)  {
    boost::function<bool (T)> res = boost::bind(fn, _1);    
    return res;
}

...

Ref<Iterator<CWorm*> > x = GetFilterIterator(makeIteratorRef(worms()), makeFn(&CWorm::getLocal));

This way the compiler is capable of deducing the template parameters because no conversions are necessary.

By the way, I think you are overcomplicating simple things:

for (auto it = worms().begin(); it != worms().end(); ++it)
  if (it->isLocal()) { 
    // Do something
  }

This code is way more readable in C++ and even though it might not be as general it hardly makes the code worse.

There is no conversion involved. It just needs to match `Ref >` with `Ref >`. I always thought that wouldn't be a problem (and I also don't see why it is; I'm quite sure I have seen similar stuff elsewhere). Also, this already determines `T`, so the `boost::function` stuff doesn't matter anymore then. — Albert, Jan 13 '12 at 01:22
Ah, did you overread this? "`worms()` returns a `Ref Ref>`". — Albert, Jan 13 '12 at 01:36
Ah, sorry, missed that point. Then the problem lies in conversion to boost::function - you will need the makeFn wrapper or some alternative to it. — Karel Petranek, Jan 13 '12 at 07:51

score 0 · Accepted Answer · edited May 23 '17 at 10:24

Thanks to the hint from Xeo to here about that implicit type conversions are not allowed when deducing template arguments, I wondered wether the second parameter might cause problems here. I thought that it would do the type deduction from left to right and once the type is deducted, it is not a problem anymore (for the function pointer to boost::function cast).

It seems I was wrong and this was exactly the problem.

Another version of the same thing avoids the problem:

template<typename T>
struct PartialFuncWrapper {
    ::Ref<Iterator<T> > i;
    PartialFuncWrapper(::Ref<Iterator<T> > _i) : i(_i) {}
    typename Iterator<T>::Ref operator()(boost::function<bool(T)> pred) {
        return new FilterIterator<T>(i, pred);      
    }
};

template<typename T>
PartialFuncWrapper<T> GetFilterIterator(::Ref<Iterator<T> > i) {
    return PartialFuncWrapper<T>(i);
}

Then I can write:

Ref<Iterator<CWorm*> > x = GetFilterIterator(worms())(&CWorm::getLocal);

C++ failed template argument deduction. why?

3 Answers3