Re: nevermind
On May 1, 11:23 am, "Bo Persson" <b...@gmb.dk> wrote:
James Kanze wrote:
On Apr 28, 9:10 pm, Noah Roberts <n...@nowhere.com> wrote:
Noah Roberts wrote:
#include <iostream>
#include <memory>
struct T {};
std::auto_ptr<T> f() { return new T; }
That doesn't compile in g++. So I changed the source
according to what g++ expects and it works without
craishing in both compilers. Dunno why MSVC lets me return
new T, but it does and then can't handle it.
Looking at the expanded code (your program compiled using
-E), it looks like the VC++ library is missing an explicit
on the constructor of auto_ptr_ref, compared at least to
g++. It's actually hard to say; the standard doesn't say
much of anything about what auto_ptr_ref should look like.
The class definition show it as empty, which IIUC means that
it cannot contain any public members (and the g++
implementation is non-conforming as well). But without the
explicit, you code compiles, since the pointer returned by
new converts implicitly to an auto_ptr_ref, and auto_ptr has
a constructor which takes an auto_ptr_ref. At any rate, the
VC++ auto_ptr_ref is designed to contain a pointer to the
pointer in the auto_ptr which creates it, so it's not
surprising that funny things happen when it is initialized
with something else. (The g++ implementation works
differently... and will leak memory if the auto_ptr_ref
isn't used to initialize an auto_ptr. I don't know what the
correct solution is.)
One option is for the auto_ptr_ref to hold a reference to the
auto_ptr that created it.
But that's probably too obvious. :-)
That's basically what VC++ does (IIRC---I don't have access to
VC++ where I am at the moment). Except that in fact, it holds a
pointer to the internals of the auto_ptr, rather than to the
auto_ptr itself. And of course, that gets you into no end of
problems if the auto_ptr_ref has a lifetime beyond that of the
auto_ptr, and is used. I can't see that being a problem in
real code, but I think that the standard does allow something
like:
std::auto_ptr_ref< T > r( functionReturningAutoPtr() ) ;
std::auot_ptr< t > p( r ) ;
In which case, I don't think the VC++ implemenation would
work. IMHO, this particular error is along the same lines as
the fact that std::basic_string<double> core dumps in g++. If
you actually encounter it, you deserve it. (VC++ should either
make the constructor of auto_ptr_ref private, with auto_ptr a
friend, or make it typesafe, rather than just taking a void*,
however.)
--
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