Why Concurrency Is Hard

Re:Why Concurrency Is Hard by dragontamer on Tuesday November 10, 2020 @02:32AM (#25043580)

    unique_ptr<Blah> foo = make_unique(...);
    unique_ptr<Blah> bar = std::move(foo); 
    // foo is now effectively destroyed as part of the move;

    foo->something(); // Will error, probably seg-fault. Foo is now "empty"

The value foo used to point at is preserved. But foo itself was destroyed from the std::move(foo); The foo->something() is almost certainly a null-pointer exception or seg-fault in any sane implementation of C++11.

---------

Example 2:

    int main(){
      vector<int> foo = {1, 2, 3, 4, 5};
      vector<int> bar = std::move(foo);

      cout << foo.size() << endl;
      cout << bar.size() << endl;

      return 0;
    }

Notice: foo.size() is 0. The foo-vector was DESTROYED by the std::move(foo);.

[ Parent | on HN ]

Re:Why Concurrency Is Hard by mehrdadn on Tuesday November 10, 2020 @02:39AM (#25043620)

unique_ptr's destructor happens to do nothing in a moved-from state. The fact that some types behave this way does not mean moves are destructive. They're still non-destructive. Indeed you're still supposed to call the destructor after a move, and the destructor very well _could_ do something in general. It's just that it doesn't happen to make any difference for typical implementations of some types like unique_ptr.

In fact there are people who have wanted destructive moves in C++, because they found the current non-destructive moves inadequate, but I don't believe the feature has ever been added. Look up destructive moves to find discussions on the issue.

[ Parent | on HN ]

Re:Why Concurrency Is Hard by dragontamer on Tuesday November 10, 2020 @02:44AM (#25043641)

I guess I'm being imprecise with terminology then. It seems like Rust has a concept called destructive move, which is not what I'm talking about.

In any case, the "foo" vector, and "foo" unique_ptr are _mutilated_ as part of the std::move operation. (Since the word "destroyed" seems to have been taken by the Rust community, I can't use that word anymore... hopefully no other community has taken the word "mutilated")

[ Parent | on HN ]

Re:Why Concurrency Is Hard by gpderetta on Tuesday November 10, 2020 @08:52AM (#25045877)

I think "moved-from" already captures what you are trying to say.

The theoretical destructive move is understood not leave an object behind at all, i.e. nothing to call a destructor on.

[ Parent | on HN ]