hello, run into something i feel is a little weird, heres the situation;

I have a few template vector classes for obvious reasons and these vector classes have global operator overloads. I noticed that when i try to do the following;

math::vector2f u(...);
u *= 2;

or something along those lines i get the error in the title.
i also have a bunch of other functions that have similar behaviours eg. math::clamp(x, min, max) where if all parameters are not exactly the same it spits out the above error.
so i cant for example;

type::real_t x = 0.0f; //real_t == float in this case
//...
type::real_t a = math::clamp(x, 0.0, 1.0);

the above sample is particularly irritating because type::real_t can be either float or double and changed with a single define so if i got to some point and decided to change from one type to another it could break existing code without an explicit cast!

I know why the compiler is doing this (it cant decide which parameter it should take the type of hence the ambiguity) its just annoying.

this may be a long shot, but is there no way to tell the compiler to default to the first parameters (or even any single parameters) type in these kinds of situations? then the other parameters will be implicitly cast to that type.... hmm on second thought it might be a good thing that it requires each parameter to be exactly the same type (these functions have one template parameter 'T' by the way.. would be a whole other rant if each were different template parameters haha)

thoughts?
perhaps i should just prefer function overloads in this case :/ ...

EDIT: Actually no that would still produce the same problem... perhaps i should just make a single function and have it take parameters of type::real_t.. yeah that should do it..

My thoughts:

Typing in your exact heading "template parameter 'T' is ambiguous" into Google gives you many examples of what causes the behavior and ways to correct it.

I understand why the compiler is generating these errors.

You can parameterize your function templates using multiple types, e.g. (untested):

template < typename T1, typename T2, typename T3 >
T1 clamp(T1 value, T2 min, T3 max) { ... }
But then you get into issues of type promotion and so forth.

In any case, I think it's reasonable for such functions to have only a single type parameter. (Standard library functions such as min() and max() are implemented this way, for example.)

It looks like the main issue you're dealing with is literals. One solution is to cast at the call site, e.g.:

value = clamp(value, real_t(0.0), real_t(1.0));
There are other solutions as well (and perhaps better solutions than the above), but again, I'd be inclined to stick with a single type parameter unless you really need the flexibility of supporting multiple types.

Hmm yeah, other std functions such as min and max also suffer from this problem (it has just never occured to me before odd really).. I could get around it by not having real_t atall (therefore eliminating the need for guess work when it comes to entering literals, if they are needed) or by just making sure that type::real_t is decided upon and never changed at the very beginning of application development, which kind of defeats 1/2 the purpose of it..

In "library" code having to cast to real_t for literals doesnt seem like such a bad idea but for client programmer I would imagine this could become quite cumbersom..
Perhaps I will just keep it how it is, because it still gives the option of using 32 or 64 bit floating point precision across an entire library.

Bleh.. who knows..

How badly do you need templates for this? It seems like you are kind of throwing in templates because templates seem cool rather than because they are what is actually needed.

Its being used instead of a macro, which is exactly what templates were originally meant for


For templates taking a single type manually specifying the type to the function call is usually the cleanest way

clamp<float>(a, 0.0f, 1.2);

or a bit more typesafe:

lhs = clamp<typeof<a>>(a, 0.0f, 1.2f);

or

lhs = clamp<typeof<lhs>>(a, 0.0f, 1.2f);


Though a good typeof template is a bit of a nuisance to get (i.e. from the boost library etc)