Re: Object that transfers ownership on assignment/copy
On Sep 5, 10:49 pm, Scott Gifford <sgiff...@suspectclass.com> wrote:
As a possible solution to a problem I'm trying to solve with an
iterator (see an earlier post by me with subject "Iterator
implementation questions: copy constructor and postfix increment"),
I'm trying to implement an object that transfers ownership on
assignment or copy, just like auto_ptr does.
With an auto_ptr, I can do this:
#include <string>
#include <memory>
#include <iostream>
using namespace std;
auto_ptr<string> ap_factory() {
return auto_ptr<string>(new string("foo"));
}
int main() {
auto_ptr<string> s = ap_factory();
auto_ptr<string> s2 = s;
cout << "s1=" << s.get() << ", s2=" << *s2 << endl;
}
and when "s2 = s" executes, the pointer that was held by "s" is
trasferred to "s2", and then the pointer in "s" is set to NULL. So, I
see this output:
s1=0, s2=foo
When I try to implement the same behavior in my own class, I have
compilation problems.
std::auto_ptr is very, very tricky. In addition, it has
undergone several revisions, and different implementations (e.g.
g++, VC++, etc.) may reflect different versions of the standard.
The main reason for this is that one National Body threatened a
no vote on the standard if you tried to instantiate a standard
container with an auto_ptr and didn't get an error. (A copy
constructor or assignment operator which transfers ownership
does not meet the requirements of Copiable or Assignable.) The
classical solution is just to cast away const (or use mutable)
in the object; the auto_ptr solution has a number of side
effects. (For example, copy initialization isn't legal. And a
pointer won't implicitly convert to an auto_pointer, which may
or may not be good.)
Here's my small test case:
#include <string>
#include <iostream>
using namespace std;
class C {
public:
C(string *_s) : s(_s) { }
C(C &that) : s(that.s) { }
C& operator=(C &that) {
if (&that != this) {
Just a nit, but note that the test for self assignment should
not be necessary, and is probably a pessimization.
(std::auto_ptr should handle self assignment correctly.)
s = that.s;
}
return *this;
}
const string *get() {
return s.get();
}
private:
auto_ptr<string> s;
};
C c_factory() {
return C(new string("foo"));
}
int main() {
C myC = c_factory();
C myC2 = myC;
cout << "myC=" << myC.get() << ", myC2 = " << *(myC2.get()) << =
endl;
return 0;
}
When I try to compile this, I get:
test8.C: In function C c_factory():
test8.C:28: error: no matching function for call to C::C(C)
test8.C:10: note: candidates are: C::C(C&)
test8.C:8: note: C::C(std::string*)
test8.C: In function int main():
test8.C:32: error: no matching function for call to C::C(C)
test8.C:10: note: candidates are: C::C(C&)
test8.C:8: note: C::C(std::string*)
The problem seems to be that class C doesn't have a copy constructor
for "const C&" but only "C&", which is appropriate since the copied
object will be destroyed.
Exactly.
I can verify this is the problem by
creating a constructor for "const C&", and making s mutable so I can
change it without the compiler complaining:
#include <string>
#include <iostream>
using namespace std;
class C {
public:
C(string *_s) : s(_s) { }
C(C const &that) : s(that.s) { }
C& operator=(C &that) {
if (&that != this) {
s = that.s;
}
return *this;
}
const string *get() {
return s.get();
}
private:
mutable auto_ptr<string> s;
};
C c_factory() {
return C(new string("foo"));
}
int main() {
C myC = c_factory();
C myC2 = myC;
cout << "myC=" << myC.get() << ", myC2 = " << *(myC2.get()) << =
endl;
return 0;
}
compiles and gives the expected output:
myC=0, myC2 = foo
Clearly, though, using "mutable" in this way is a hack.
True, but it's doubtlessly the simplest way.
Is there a better solution to this problem? auto_ptr seems
not to have a copy constructor that requires a const object,
so there must be a way, but I've looked at the source code for
g++'s auto_ptr and can't figure out what magic is making this
work.
auto_ptr uses an intermediate object (auto_ptr_ref, or something
like that), with conversions to and from auto_ptr. This allows
things like:
std::auto_ptr<T> f() ;
std::auto_ptr<T> a( f() ) ;
since there is a constructor for auto_ptr which takes an
auto_ptr_ref, and the auto_ptr returned by f() will convert
implicitly to an auto_ptr_ref. Note, however, that:
std::auto_ptr<T> a = f() ;
won't compile, because the semantics here are basically the same
as if you'd written:
std::auto_ptr<T> a = std::auto_ptr<T>( f() ) ;
except that an explicit constructor won't be considered in the
right hand side. Similarly, you can't copy the auto_ptr from a
const reference (e.g. like the parameter of push_back).
The need for "move" semantics (a copy where the source will
never be used again) are more general, and the language is being
modified to support them. Once that happens, things like this
should become much simpler (I think---I'm not really up to date
in this). Until then, I'd just go with the abuse of mutable,
and carefully document that the copy semantics are NOT true
copy, and that the type doesn't meet the Copiable constraints of
the standard containers.
--
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