Re: std::auto_ptr deprecated?
On 18 Mai, 03:12, george.r...@gmail.com wrote:
On May 17, 12:37 pm, german diago <germandi...@gmail.com> wrote:
the replacement will be std::unique_ptr, which is basically the same,
unique_ptr differs from auto_ptr in that unique_ptr doesn't have a
"destructive copy constructor" and a "destructive assignment operator"
-- unlike auto_ptr.
auto_ptr<int> p (new int);
auto_ptr<int> q = p; // OK, but...
assert(p.get() == 0); // "copy" was destructive
unique_ptr<int> p (new int);
unique_ptr<int> q = p; // fails
unique_ptr has some other advantages as well (a smarter default
deleter that supports arrays and support for custom deleters).
but it works with stl containers.
Is this because the unique_ptr is MoveAssignable?
It's because of two things: 1. The new containers don't require types
to be "copyable" anymore. They require the types to be "movable" which
is less strict. 2. unique_ptr is movable.
copyable: can be copied from lvalue and rvalue sources. In case
the source was an lvalue it won't change the observable
state of the source object.
movable : can be moved from rvalues. This might involve an
observable alteration of the source object.
A copyable type would be "copy-constructible" as well as "copy-
assignable". A movable type would be "move-constructible" and "move-
assignable". Clearly, std::auto_ptr is not copyable by this definition
because its copy constructor and assignment operator involves an
observable modification of the source object. It even makes me want to
propose negative concept_maps for C++0x a la
template<typename T> concept_map !CopyConstructible<auto_ptr<T>>;
template<typename T> concept_map !CopyAssignable<auto_ptr<T>>;
so you can specifically override "auto concepts" just like you can
specialize some traits class to disable a type from being used in some
generic algorithm.
I'm still figuring out the new concepts stuff, but will this mean if
we define custom objects as move assignable that standard containers
will not make copies of them?
The purpose of concepts is constraining template parameters for better
type checking. You don't need concepts to benefit from movable types.
If you want to prevent unnecessary copying you just need to provide a
"move constructor" and use either the copy-and-swap idiom for
assignment or provide two assignment operators. (Btw: your type will
automatically satisfy the MoveConstructible and CopyConstructible
concepts.)
You should check out the rvalue reference papers to see how move
semantics works exactly. Start with document N2027 [1].
Cheers!
SG
[1] N2027: "A Brief Introduction to Rvalue References"
http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]