auto_ptr...

Greetings!

  Please, forgive the long post..

  My concerns are of the auto_ptr implementation found in VS 8.0
standart library.

  I accidently successfully compiled something like

//-----------------------
  auto_ptr<T> p = new T;
//-----------------------

  and got a runtime error. Looking through the code of the library I
find a proxy class:
<memory>
//----------------
template<class _Ty>
struct auto_ptr_ref
    { // proxy reference for auto_ptr copying

[please, note the void ptr]
        auto_ptr_ref(void *_Right)
        : _Ref(_Right)
        { // construct from generic pointer to auto_ptr ptr
        }

        void *_Ref; // generic pointer to auto_ptr ptr
    };

//----------------

!...proxy class to auto_ptr implicit conversion:
//----------------
auto_ptr(auto_ptr_ref<_Ty> _Right) _THROW0()
    { // construct by assuming pointer from _Right auto_ptr_ref
    _Ty **_Pptr = (_Ty **)_Right._Ref;
    _Ty *_Ptr = *_Pptr;
    *_Pptr = 0; // release old
    _Myptr = _Ptr; // reset this
    }

//----------------

!...and a proxy conversion operator:
//----------------
template<class _Other>
    operator auto_ptr_ref<_Other>() _THROW0()
    { // convert to compatible auto_ptr_ref
    _Other *_Testptr = (_Ty *)_Myptr; // test implicit conversion
    auto_ptr_ref<_Other> _Ans(&_Myptr);
    return (_Testptr != 0 ? _Ans : _Ans);
    }

//----------------

All right, I've read the story on the proxies, they're supposed to
allow this:

auto_ptr<A> f();
auto_ptr<A> ptr(f());

and this:

void g(auto_ptr<A>);
g(f());

But dear Sirs, the way it is done in VS 8.0 seems to be complete
b******t!
Pay attention please, in order to strip ownership of the source
auto_ptr, the source
_Myptr's address is cast to void* and then 'released' in
'auto_ptr(auto_ptr_ref<_Ty> _Right)'
like this:

        _Ty **_Pptr = (_Ty **)_Right._Ref;
        _Ty *_Ptr = *_Pptr;
        *_Pptr = 0; // release old
        _Myptr = _Ptr; // reset this

Well, NULLing is fine I guess, but look at the _Myptr retrieving: it's
a back cast from
void ptr as if it is a pointer to the 'target type' ptr! A simple
multiple inheritance
test ruins the concept in one single blow:

//------------------------------------
#include <iostream>
#include <memory>

using namespace std;

struct A
{
    virtual ~A() {}
    char a;
};

struct B
{
    virtual ~B() {}
    char b;
};

struct C : A, B
{

};

auto_ptr <C> f ()
{
    auto_ptr<C> p (new C);
    p->a = 'a';
    p->b = 'b';
    return p;
}

int main()
{

    auto_ptr<A> pa = f();
    cout << "A: " << pa->a << endl;

    auto_ptr<B> pb = f();
    cout << "B: " << pb->b << endl;

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

This would either print:

A: a
B: a

Or:

A: b
B: b

Instead of:
A: a
B: b

depending on which class you inherit first in 'C' def.

Well, I did some research and found out that it had been even worse
in VS 7.1, as the proxies held a reference to target auto_ptr type.
(the words of standart were followed very strict I must confess ;])
And converting to them looked like this:

    template<class _Other>
        operator auto_ptr_ref<_Other>() _THROW0()
        { // convert to compatible auto_ptr_ref
        return (auto_ptr_ref<_Other>(*this));
        }

This caused recursive calls in the operator if you had tried to
compile
the test above. Some warnings on this were issued however.

This is all a bit confusing, as the copyright in the library code
dates
to 2002, but you might want to check this link:

http://www.josuttis.com/libbook/util/autoptr.hpp.html

which seems to hold an appropriate solution and is dated 1999. In
order
to avoid the recursive call they hold the target auto_ptr wrapped
pointer
in the proxy, not the auto_ptr reference, and not the address of the
source wrapped pointer in form of void* (thus no retrieving via void
and
it is correct up from the point where the source ptr is cast to
target type ptr). As the proxy holds the pointer alone, they strip
the
ownership of the source in the 'to-proxy' conversion operator, not in
the target auto_ptr constructor.

Is this approach fine or it contains some side effects?

When I use the code from the link, the test above is a success
and prits 'a' 'b'.

Please, point me if I'm wrong somewhere.

P.S. I would also appreciate any comments on this line in

    template<class _Other>
        operator auto_ptr_ref<_Other>() _THROW0()
        { // convert to compatible auto_ptr_ref
        _Other *_Testptr = (_Ty *)_Myptr; // test implicit conversion
        auto_ptr_ref<_Other> _Ans(&_Myptr);
        return (_Testptr != 0 ? _Ans : _Ans);
        }

[the line]
        return (_Testptr != 0 ? _Ans : _Ans);

Is this some bizarre way to avoid unused _Testptr warning, or does it
have a deeper, guru-only-perceivable meaning?

--
      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]