temporary auto_ptr

temporary auto_ptr

[Dima Sorkin]

Hi.
Some tricky question, just to understand how compiler thinks:
See the example:

//a.cpp -*-c++-*-     -------------------------------------------------
#include<memory>
using namespace std;

class A{};
class B : public A {};

// This function does pass comilation
auto_ptr<const A> f1(){
	auto_ptr<const B> pB(new B);
	return auto_ptr<const A>(pB);
}

// This function doesn't pass compilation : why ?
auto_ptr<const A> f2(){
	auto_ptr<const B> pB(new B);
	return pB;
}  //---------------------------------------------------------------------------

Note: there exists
template<class X> template<class Y>
auto_ptr<X>::auto_ptr(auto_ptr<Y> &);     non-explicit constructor

Thank you.
 Dima.

P.S.
I tried to parse compiler's warnings and to understand what it does.

gcc 4.0.1 just writes that conversion is ambiguous.

gcc 3.3.4 : (as I understood)
I don't undersand why in case of "f2" compiler tries to create a const
temporary of auto_ptr<const A> as a part of cast process,
for building a non-const temporary that "f2" returns
(assuming there is no return-value optimizations in this stage).

It can construct a non-const auto_ptr<const A> temporary that "f2"
returns directly from auto_ptr<const B> instead.

Re: temporary auto_ptr

[John Love-Jensen]

Hi Dima,

>This function doesn't pass compilation : why ?

The f2 function returns an auto_ptr<const A>.

You are trying to return an auto_ptr<const B>.

An auto_ptr<const B> is not an auto_ptr<const A>, regardless if a "B is an
A".

HTH,
--Eljay

Re: temporary auto_ptr

[Dima Sorkin]

On 9/29/05, John Love-Jensen  wrote:
> The f2 function returns an auto_ptr<const A>.
> You are trying to return an auto_ptr<const B>.
> An auto_ptr<const B> is not an auto_ptr<const A>, regardless if a "B is an
> A".
  And it does not matter that there is an implicit conversion possible
between auto_ptr<const B>& and auto_ptr<const A> ?
(unless I explicitly state I want to do it, as in "f1" )

Regards,
 Dima.

Re: temporary auto_ptr

[John Love-Jensen]

Hi Dima,

>   And it does not matter that there is an implicit conversion possible
> between auto_ptr<const B>& and auto_ptr<const A> ?
> (unless I explicitly state I want to do it, as in "f1" )

If there is a *single* implicit conversion possible, then I think you'll get
that implicit conversion.

If there are *multiple* implicit conversions possible, then the compiler
will indicate an ambiguous implicit conversion situation.

HTH,
--Eljay

Re: temporary auto_ptr

[Dima Sorkin]

> If there is a *single* implicit conversion possible, then I think you'll get
> that implicit conversion.
>
> If there are *multiple* implicit conversions possible, then the compiler
> will indicate an ambiguous implicit conversion situation.

 At least I don't see any options for multiple implicit conversion here.
It seems to be one and single .
  I don't see neither multiple paths to do the conversion,nor sequence of
conversions that require more than one cast.
(maybe there are some hidden things in actual implementation of auto_ptr,
 however)


Regards,
 Dima.

Re: temporary auto_ptr

[John Love-Jensen]

Hi Dima,

> At least I don't see any options for multiple implicit conversion here. It
seems to be one and single.

I see three implicit conversions.

std::auto_ptr<const A>::auto_ptr(std::auto_ptr_ref<const A>)
 ... via the operator cast
std::auto_ptr<const A>::auto_ptr(std::auto_ptr<const A>&)
 ... by template constructor
std::auto_ptr<const A>::auto_ptr(std::auto_ptr<const A>&)
 ... by copy constructor

The "perfect match" would be...
std::auto_ptr<const A>::auto_ptr(std::auto_ptr<const A>)
 ... but that does not exist.

> I don't see neither multiple paths to do the conversion,nor sequence of
conversions that require more than one cast.

See above.

The real issue is that a std::auto_ptr<const B> is *NOT* a
std::auto_ptr<const A>, since std::auto_ptr<const B> is *NOT* derived from
std::auto_ptr<const A>.  The former is not interchangeable with the latter.

HTH,
--Eljay