How does Rust provide move semantics?

by

I think it’s a very common issue when coming from C++. In C++ you are doing everything explicitly when it comes to copying and moving. The language was designed around copying and references. With C++11 the ability to “move” stuff was glued onto that system. Rust on the other hand took a fresh start.

Rust doesn’t have constructors at all, let alone move constructors.

You do not need move constructors. Rust moves everything that “does not have a copy constructor”, a.k.a. “does not implement the Copy trait”.

struct A;

fn test() {
    let a = A;
    let b = a;
    let c = a; // error, a is moved
}

Rust’s default constructor is (by convention) simply an associated function called new:

struct A(i32);
impl A {
    fn new() -> A {
        A(5)
    }
}

More complex constructors should have more expressive names. This is the named constructor idiom in C++

No support for rvalue references.

It has always been a requested feature, see RFC issue 998, but most likely you are asking for a different feature: moving stuff to functions:

struct A;

fn move_to(a: A) {
    // a is moved into here, you own it now.
}

fn test() {
    let a = A;
    move_to(a);
    let c = a; // error, a is moved
}

No way to create functions overloads with rvalue parameters.

You can do that with traits.

trait Ref {
    fn test(&self);
}

trait Move {
    fn test(self);
}

struct A;
impl Ref for A {
    fn test(&self) {
        println!("by ref");
    }
}
impl Move for A {
    fn test(self) {
        println!("by value");
    }
}
fn main() {
    let a = A;
    (&a).test(); // prints "by ref"
    a.test(); // prints "by value"
}

More Related Contents:

  1. What are move semantics in Rust?
  2. Why is the mutable reference not moved here?
  3. Why does the compiler not complain that an iterator moved to a for loop is immutable?
  4. Can Rust optimise away the bit-wise copy during move of an object someday?
  5. Return local String as a slice (&str)
  6. What is the difference between iter and into_iter?
  7. How can I swap in a new value for a field in a mutable reference to a structure?
  8. How do I return a reference to something inside a RefCell without breaking encapsulation?
  9. How to convert a String into a &’static str
  10. Proper way to return a new string in Rust
  11. Double mutable borrow error in a loop happens even with NLL on
  12. println! error: expected a literal / format argument must be a string literal
  13. How to return a reference to a sub-value of a value that is under a mutex?
  14. How do I convert a Rust closure to a C-style callback?
  15. How to transform fields during serialization using Serde?
  16. “borrowed value does not live long enough” when using the builder pattern
  17. Is it possible to conditionally enable an attribute like `derive`?
  18. cannot borrow `self.x` as immutable because `*self` is also borrowed as mutable
  19. Using the same iterator multiple times in Rust
  20. How do I fix “cannot find derive macro in this scope”?
  21. Thread ” has overflowed its stack when allocating a large array using Box
  22. How do you enable a Rust “crate feature”?
  23. How to implement Iterator yielding mutable references [duplicate]
  24. How can a Rust program access metadata from its Cargo package?
  25. How can the ref keyword be avoided when pattern matching in a function taking &self or &mut self?
  26. How to swap two variables?
  27. Expected bound lifetime parameter, found concrete lifetime [E0271]
  28. Rust equivalent to Swift’s extension methods to a protocol?
  29. How can I solve “use of moved value” and “which does not implement the `Copy` trait”?
  30. Why does using Option::map to Box::new a trait object not work?

Leave a Comment