4 ms·

C++11 introduces unique_ptr, which has a lot of the same safety characteristics. Rust's syntax does seem much nicer, though.

pcwalton 12y ago
> C++11 introduces unique_ptr, which has a lot of the same safety characteristics. Sure, other than not actually being safe (UB resulting from use after move of unique_ptr being an obvious one; there are many others).
- justinsb 12y ago
  Good point! Safe if used very carefully, perhaps - like most of C++.
  - Dewie 12y ago
    Raw pointers are safe if used very carefully... :)
- wycats 12y ago
  For those who might have been wondering, "UB" means "undefined behavior".
- Animats 12y ago
  Right. C++ used to have auto_ptr, which did roughly the same thing, but didn't quite get it right. Transferring ownership was always iffy. There were, I think, three standardized versions of auto_ptr, all bad. Now there's unique_ptr, which is supposed to be better. The lesson of C++ is that you can't bolt on safety by using templates to paper over the underlying mess. The mold always seeps through the wallpaper. The usual problem is that at some point you need raw pointers to call some API. If you can get raw pointers, the abstraction has to have a leak.
- crantanplum 12y ago
  What part of that is undefined? When you move the pointer, the original becomes null..
  - masklinn 12y ago
    > What part of that is undefined? When you move the pointer, the original becomes null.. Nope, the argument is "valid but unspecified" not necessarily null. And http://en.cppreference.com/w/cpp/utility/move http://en.cppreference.com/w/cpp/utility/move specifically has this as an example of UB: std::vector<std::string> v; std::string str = "example"; v.push_back(std::move(str)); // str is now valid but unspecified str[0]; // undefined behavior: operator[](size_t n) has a precondition size() > n There's an other fun UB because std::move doesn't check for aliasing, so self-assignment: v = std::move(v); is also an UB. And of course even if it were null., pcwalton talks about use after null. Deref'ing a null pointer (to use it) is still an UB.
    - lbrandy 12y ago
      OP is correct. You've quoted the general language around move semantics but unique_ptr itself has a stronger gaurantee. From 20.7.1 Additionally, u can, upon request, transfer ownership to another unique pointer u2. Upon completion of such a transfer, the following postconditions hold: — u.p is equal to nullptr, unique_ptr isn't what's unsafe here. Null pointers are. The difference, admittedly, is mostly semantic. There is nothing undefined about using a unique_ptr after moving unless you use the internal pointer in undefined ways.
      - pcwalton 12y ago
        > There is nothing undefined about using a unique_ptr after moving unless you use the internal pointer in undefined ways. If you dereference (i.e. use) a moved unique pointer you get undefined behavior. When talking about "using a pointer" most people mean dereferencing it, not for example comparing against null. It may be somewhat imprecise language, but it's what security people mean when they talk about "use after free", for example.

pcwalton 12y ago

> C++11 introduces unique_ptr, which has a lot of the same safety characteristics. Sure, other than not actually being safe (UB resulting from use after move of unique_ptr being an obvious one; there are many others).

justinsb 12y ago
Good point! Safe if used very carefully, perhaps - like most of C++.
- Dewie 12y ago
  Raw pointers are safe if used very carefully... :)
wycats 12y ago
For those who might have been wondering, "UB" means "undefined behavior".
Animats 12y ago
Right. C++ used to have auto_ptr, which did roughly the same thing, but didn't quite get it right. Transferring ownership was always iffy. There were, I think, three standardized versions of auto_ptr, all bad. Now there's unique_ptr, which is supposed to be better. The lesson of C++ is that you can't bolt on safety by using templates to paper over the underlying mess. The mold always seeps through the wallpaper. The usual problem is that at some point you need raw pointers to call some API. If you can get raw pointers, the abstraction has to have a leak.
crantanplum 12y ago
What part of that is undefined? When you move the pointer, the original becomes null..
- masklinn 12y ago
  > What part of that is undefined? When you move the pointer, the original becomes null.. Nope, the argument is "valid but unspecified" not necessarily null. And http://en.cppreference.com/w/cpp/utility/move http://en.cppreference.com/w/cpp/utility/move specifically has this as an example of UB: std::vector<std::string> v; std::string str = "example"; v.push_back(std::move(str)); // str is now valid but unspecified str[0]; // undefined behavior: operator[](size_t n) has a precondition size() > n There's an other fun UB because std::move doesn't check for aliasing, so self-assignment: v = std::move(v); is also an UB. And of course even if it were null., pcwalton talks about use after null. Deref'ing a null pointer (to use it) is still an UB.
  - lbrandy 12y ago
    OP is correct. You've quoted the general language around move semantics but unique_ptr itself has a stronger gaurantee. From 20.7.1 Additionally, u can, upon request, transfer ownership to another unique pointer u2. Upon completion of such a transfer, the following postconditions hold: — u.p is equal to nullptr, unique_ptr isn't what's unsafe here. Null pointers are. The difference, admittedly, is mostly semantic. There is nothing undefined about using a unique_ptr after moving unless you use the internal pointer in undefined ways.
    - pcwalton 12y ago
      > There is nothing undefined about using a unique_ptr after moving unless you use the internal pointer in undefined ways. If you dereference (i.e. use) a moved unique pointer you get undefined behavior. When talking about "using a pointer" most people mean dereferencing it, not for example comparing against null. It may be somewhat imprecise language, but it's what security people mean when they talk about "use after free", for example.