Re: ambiguous
On Jun 15, 9:27 am, Alan Johnson <a...@yahoo.com> wrote:
Tim H wrote:
Why is this ambiguous:
------------------------------------------------
#include <boost/shared_ptr.hpp>
class base {};
class derived: public base {};
class other {};
void do_something(const boost::shared_ptr<other> dev) {}
void do_something(const boost::shared_ptr<base> scope) {}
int main()
{
boost::shared_ptr<base> b(new base());
boost::shared_ptr<derived> d(new derived());
do_something(b);
do_something(d);
return 0;
}
------------------------------------------------
[...]
shared_ptr does have a template constructor, though, that can accept
type shared_ptr<T>. The problem from the compiler's perspective is
whether it should instantiate that template with T = base or T = othe=
r,
thus, ambiguity.
Just a small addition to a very good explination: the important
point to keep in mind is that the compiler does overload
resolution before it instantiates the chosen template function.
So it cannot know that the conversion will cause an error if it
is instantiated with other.
There is a proposal (more than one, in fact) to add concepts to
the language. As I understand it, this will allow expression of
requirements like the fact that the template conversion
constructor requires the pointers to the underlying types to be
implicitly convertable. I'm not really sure of the details, but
presumably, such constraints will play a role in template type
deduction, ensuring that the conversion to other will not be
instantiated here, and thus that overload resolution will work.
So maybe sometime in the future...
--
James Kanze (GABI Software, from CAI) 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