Re: ambiguous

From:

Alan Johnson <awjcs@yahoo.com>

Newsgroups:

comp.lang.c++

Date:

Fri, 15 Jun 2007 00:27:59 -0700

Message-ID:

<RNudnT2fCdsdou_bnZ2dnUVZ_q-vnZ2d@comcast.com>

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;
}
------------------------------------------------

but this is not

------------------------------------------------
class base {};
class derived: public base {};
class other {};

void do_something(const other *dev) {}
void do_something(const base *scope) {}

int main()
{
        base *b = new base();
        derived *d = new derived();

        do_something(b);
        do_something(d);

        return 0;
}
-------------------------------------------------------

In your second example, the type 'derived *' has relationship to the
type 'base *' that is well defined by the standard. Specifically,
pointers to derived are convertible to pointers to base.

In your first example, the type 'shared_ptr<derived>' has no particular
relation to the type 'shared_ptr<base>'. That is, shared_ptr<derived>
is not convertible to shared_ptr<base> any more than
std::vector<derived> would be convertible to std::vector<base>.

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 = other,
thus, ambiguity.

--
Alan Johnson