wrong-looking compile error invoking template member function of template class - c++

Question

I have a templated C++ class with a further template on one of its member functions.
I am calling it in two places in my code, one of them works, the other generates a very confusing error which boils down to the sample code below:
#include <memory>
template <unsigned char N>
struct Foo
{
template <typename OtherFoo, unsigned X>
void do_work (
const OtherFoo * __restrict,
float,
Foo * __restrict
)
const
{
}
};
struct Bar
{
std :: unique_ptr <Foo<0>> foo_0;
std :: unique_ptr <Foo<1>> foo_1;
std :: unique_ptr <Foo<2>> foo_2;
void run (float);
template <typename FOO>
void run (std :: unique_ptr <FOO> & foo, float x)
{
FOO out;
foo -> template do_work <123> (foo_2.get(), x, &out);
}
};
void Bar :: run (float x)
{
if (foo_0)
run (foo_0, x);
else
run (foo_1, x);
}
int main ()
{
Bar bar;
bar .run (1.23);
}
The error message is quite straightforward, but apparently wrong.
temp.cpp: In member function ‘void Bar::run(std::unique_ptr<FOO>&, float) [with FOO = Foo<0u>]’:
temp.cpp:61:16: instantiated from here
temp.cpp:54:3: error: no matching function for call to ‘Foo<0u>::do_work(Foo<2u>*, float&, Foo<0u>*)’
temp.cpp: In member function ‘void Bar::run(std::unique_ptr<FOO>&, float) [with FOO = Foo<1u>]’:
temp.cpp:63:16: instantiated from here
temp.cpp:54:3: error: no matching function for call to ‘Foo<1u>::do_work(Foo<2u>*, float&, Foo<1u>*)’
Let's see, no matching function for call to Foo<1u>::do_work(Foo<2u>*, float&, Foo<1u>*) ...? No, that to me looks EXACTLY like a valid instantiation of Foo::do_work.
Is the compiler wrong? (gcc 4.5.1 on ubuntu 12.04) What's especially weird is that this code does compile in what appears to be an equivalent invocation elsewhere in the code (the full thing has rather too many dependencies to be meaningfully reproduced here).

Answer 1

You should change the order of your template parameters for the do_work<>() function template, or your instantiation will indeed be incorrect:
// template<typename OtherFoo, unsigned X> // This order is not appropriate.
// Let template parameters that
// cannot be deduced come first...
template<unsigned X, typename OtherFoo>
// ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^
// THIS FIRST THEN THIS
void do_work(const OtherFoo* __restrict, float, Foo* __restrict) const
{
}
That is because in the following function call you are providing an explicit argument for the first template parameter:
foo->template do_work<123>(foo_2.get(), x, &out);