Question

I have this template function:

template <class P>
double Determinant(const P & a, const P & b, const P & c) {
    return  (b.x-a.x)*(c.y-a.y) - (c.x-a.x)*(b.y-a.y);
}

but I want to avoid forcing the return type to double all the time — P::x and P::y could be ints too, and I need this function in both situations. Is there a way to specify the type of x and y, something like this?

//doesn't compile; can't deduce template argument for T
template <typename T, class P>
T Determinant(const P & a, const P & b, const P & c) {
    return  (b.x-a.x)*(c.y-a.y) - (c.x-a.x)*(b.y-a.y);
}

edit: My compiler is VC2005

edit2: sorry to forget to mention: Unfortunately I can’t modify the implementation of the structs for P; one of the point types I deal with is MFC/ATL’s CPoint, which are hard-coded as { long x; long y; }.

Answer 1

Compiler cannot deduce return-type of function template, from function argument. Type deduction is done with function arguments only.

In C++03, you can define typedef in your class as:

struct A //suppose A is going to be type argument to your function template
{
   int x, y;     //I'm assuming type of x and y is same!
   typedef int value_type; //type of x and y!
};

And then you’ve to re-write your function as:

template <class P>
typename P::value_type Determinant(const P & a, const P & b, const P & c) {
    return  (b.x-a.x)*(c.y-a.y) - (c.x-a.x)*(b.y-a.y);
}

Notice the return-type now, its a dependent type. Its :

typename P::value_type

The keyword typename is required here.

---

Alright, as you said you can’t modify your structs, then you can use traits instead. Here is how this can be done:

template<typename T> struct PTraits;

//Suppose this is your type which you can't modify
struct A //A is going to be type argument to your function template
{
   long x, y; 
};

//specialization: defining traits for struct A
template<>
struct PTraits<A>
{
    typedef long value_type; //since type of A::x and A::y is long!
};

And your function template would look like this:

template <class P>
typename PTraits<P>::value_type Determinant(const P & a, const P & b, const P & c) {
    return  (b.x-a.x)*(c.y-a.y) - (c.x-a.x)*(b.y-a.y);
}

Notice the return-type; its slightly different now:

typename PTraits<P>::value_type

Again, value_type is a dependent name, so the keyword typename is required.

Note that you’ve to specialize PTraits<> for each type which you pass to the function template, as I did.