3 ms·
> In C++ you'd have to go write a bunch of code to arrange that I don't think it's quite that bad. If you define a new struct or class that follows the "Rule o
by oconnor663 5y ago
> In C++ you'd have to go write a bunch of code to arrange that
I don't think it's quite that bad. If you define a new struct or class that follows the "Rule of Zero (or 3 or 5)", the copy-assignment and move-assignment operators will have reasonable defaults. For example, the following Rust and C++ programs make the same two allocations and two frees.
Rust:
struct Foo {
m: String,
}
fn main() {
let mut x = Foo {
m: "abcdefghijklmnopqrstuvwxyz".into(),
};
x = Foo {
m: "ABCDEFGHIJKLMNOPQRSTUVWXYZ".into(),
};
}
C++:
struct Foo {
string m;
};
int main() {
auto x = Foo{"abcdefghijklmnopqrstuvwxyz"};
// Foo's default move-assignment operator is invoked on the temporary.
x = Foo{"ABCDEFGHIJKLMNOPQRSTUVWXYZ"};
}
The high-level "you assigned a new value so the previous value gets dropped" behavior is indeed what's happening, and it's automatic in most cases. But when we do voilate the Rule of Zero and override the default constructors/operators, things get quite complicated, and it's easy to make mistakes. (Also in general we often get more copies than we intended, when we're not dealing with temporaries.)
The "moves are implcit and destructive, and everything is movable" behavior in Rust is substantially simpler and often more efficient, and personally I strongly prefer it. But I'll admit that trying to contend with destructive moves without the borrow checker would probably be painful.