Compiler mistakes template argument list for < comparison

Question

I have a template function in the style:

template <int Exponent> DERIVED_TYPE pow(TYPE const x);

This function is defined inline in a template struct as a friend function:

template <ARGUMENTS>
struct unit {
    typedef unit<ARGUMENTS> type;

    ....
    template <int Exponent>
    friend constexpr unit_pow_t<type, Exponent> pow(type const x) { ... }
};

This is because taking a value with a unit to a power has to change the unit along with the value.

When I try to use it omitting the Exponent, I can see the candidates the compiler considers for matching:

src/model/Tool.cpp:113:3: error: no matching function for call to 'pow'
                pow(1._m);
                ^~~
src/model/../units/Units.hpp:2266:46: note: candidate template ignored: couldn't infer template argument 'Exponent'
        friend constexpr unit_pow_t<type, Exponent> pow(type const x) {
                                                    ^
/usr/include/math.h:255:8: note: candidate function not viable: requires 2 arguments, but 1 was provided
double  pow(double, double);
        ^

So far things are as expected, the template is seen, but of course the Exponent needs to be specified. When I do however something unexpected happens:

src/model/Tool.cpp:113:6: error: comparison between pointer and integer ('double (*)(double, double)' and 'int')
                pow<3>(1._m);
                ~~~^~

The compiler sees pow as the address of "double pow(double, double)" and interprets <3 as the intent to compare the function pointer with the integer. The problem occurs with clang 3.4, 3.6 and GCC 5.2.

My question is, how do I convince the compiler that <3> is a template argument list?

UPDATE

I finally managed to create a minimal example, sorry for the incomplete question:

template <int Exp>
struct metre {
    double value;
    template <int Exponent>
    friend constexpr metre<Exp * Exponent> pow(metre<Exp> const x) {
        return {0};
    }
};

int main() {
    pow<2>(metre<1>{1});
    return 0;
};

It seems it is not seeing pow:

targs.cpp:11:2: error: use of undeclared identifier 'pow'
        pow<2>(metre<1>{1});
        ^

If I include cmath I have the same diagnostics as before:

targs.cpp:13:5: error: comparison between pointer and integer ('double (*)(double, double)' and 'int')
        pow<2>(metre<1>{1});
        ~~~^~
1 error generated.

So the presence of "double pow(double, double)" just masks the issue that the template is not seen. The question then is, why is pow<>() not seen by the compiler?

Answer 1

There is no need (and no logic) for the friend template. Use a free function:

template <int Exp>
struct metre {
    double value;
};

template<int B, int A>
constexpr auto pow(metre<A> const x) -> metre<A*B>
{
        return metre<A*B>{x.value};
}

int main() {
    metre<2> result = pow<2>(metre<1>{1});
    return 0;
};

Live demo on coliru.

Answer 2

This is the template friends problem, with two quirks: the name of the function being pow; and the template friend has its own template parameter!

As a rule of thumb, be on guard whenever you use friend inside a class template.

To get the easier problem out of the way first: as posted, in the MCVE, the class definition of metre doesn't cause a name pow to be declared (this will be explained later). Your error message is coming because there is in fact a visible declaration of a name pow: it's in the C standard library header math.h. The "pointer" in the error message is a function pointer to this function.

It's a good idea to not name your function the same as a function in the C standard library. Those may be defined as preprocessor macros anyway, causing further trouble.

For the rest of this post I will assume the MCVE has pow swapped out for pok , to avoid this wrinkle. Then a sane error message is generated:

po.cc:13:5: error: 'pok' was not declared in this scope
    pok<2>(metre<1>{1});
    ^

---

Moving onto the main issue now.

The basic version of the problem is discussed here. The issue is that declaring a friend function inside a class template does NOT make the friend function also be a template function with the same parameter as the class template.

In fact, what happens is that for each instantiation of the class template, the friend declaration declares a non-template friend for that instantiation.

To see this in action, in your MCVE, add the line metre<1> m; as the first line of main. This instantiates metre<1>, which causes template<int Exponent> pok(metre<1>) to exist, and so the compiler recognizes pok on the next line!

In fact, any particular instantiation works, not just metre<1>, because this at least allows name lookup of pok to succeed, and then by the time overload resolution occurs (two-phase lookup!) , the argument metre<1> has caused metre<1> to be instantiated.

---

Closing note: I'm not entirely sure the above explanation is correct - template friends are pretty complicated. Maybe it'll turn out that actually pok is supposed to be declared and the compiler is bugged. But I concur with rubenvb's suggestion that it is best to avoid this situation entirely by not using a friend.

Answer 3

With the help of the previous answers I figured out a workaround.

The problem is that the friends are defined (more or less as expected) but not known outside of class/struct scope. So the compiler does not find them.

The solution is to put a declaration outside of the struct:

template <int Exp>
struct metre {
    double value;

    template <int Exponent>
    friend constexpr metre<Exp * Exponent> pow(metre<Exp> const x) {
        return {23};
    }
};

template <class> void pow(); // <== HERE BE DRAGONS

int main() {
    static_assert(pow<2>(metre<1>{1}).value == 23, "foobar");
    return 0;
};

Note that it is not necessary to provide a matching declaration. Any template declaration for a function with the right name seems to allow the compiler to discover the friend template function.