Re: Conversion Operator in Template Class
On Mar 18, 6:59 pm, Victor Bazarov <v.Abaza...@comAcast.net> wrote:
joec...@gmail.com wrote:
On Mar 18, 11:27 am, Victor Bazarov <v.Abaza...@comAcast.net> wrote:
joec...@gmail.com wrote:
Hmm... Why doesn't this work and use the conversion operator? (It
doesn't compile)
Victor said:
Because the Standard prohibits it. When deducing template
arguments from a function call, the conversions are not
applied to the function arguments.
Is there any way to get similar capability that you know of? What if
i wanted to have a class that behaved in everyway as say a
std::vector<T>, but I didn't want to inherit from std::vector<T> ? I
still want to pass this new class to functions that accept
std::vector<T>
Not in templates; you'd have to be explicit, and introduce a cast or a
function, like "as_vector":
template<class T> class Goo {
...
Foo<T>& as_Foo() { return m_foo; }
};
Goo<float> g;
bar(g.as_Foo());
. I am not sure why such requirements are imposed, probably
to allow compilers actually be reasonable with respect to time
they take to compile templates.
If by reasonable, you mean finite, yes. If you allowed all of
the conversions allowed for non template functions, in some
cases, you would end up with an infinite set of possibilities to
evaluate.
Imagine how many functions/class would have to be instantiated
if the compiler started applying all possible conversions,
especially in the cases with built-in types...
Type deduction always yields a single function (for a given
function template). What you would likely end up in such cases
is a large number of equally good choices, which no way to
choose (ambiguous), or in some extreme cases, the necessity to
check an infinite set of possibilities just in case one was
better.
--
James Kanze (GABI Software) email:james.kanze@gmail.com
Conseils en informatique orient=E9e objet/
Beratung in objektorientierter Datenverarbeitung
9 place S=E9mard, 78210 St.-Cyr-l'=C9cole, France, +33 (0)1 30 23 00 34