Differences

This shows you the differences between two versions of the page.

--- devlogs:7_5_2022 [2022/05/07 22:06]
root
+++ devlogs:7_5_2022 [2023/10/19 15:25] (current)
@@ Line 127: / Line 127: @@
 == Move ==
-With simple types that are stored on the stack. A copy of the data is made when we try to bind it to another variable. **This is a hard copy**
+With simple types that are stored on the stack. A copy of the data is made when we try to bind it to another variable. **This is a deep copy**
 <code rust>
 let x =2;
@@ Line 137: / Line 137: @@
 However with data stored on the Heap such as a string it would be to time consuming and expensive to run. So rust would just store the pointer to the data in the new variable.
+\\
 [[https://doc.rust-lang.org/book/ch04-01-what-is-ownership.html|{{:devlogs:string_copy.png?200}}]]
@@ Line 149: / Line 150: @@
 That will not compile.
+[[https://doc.rust-lang.org/book/ch04-01-what-is-ownership.html|{{:devlogs:string_move.png?200}}]]
+by default none of rust's functions will **deep copy** any heap data so you can just assume that it **moves** it.
+== Clone ==
+If you did wanna **deep copy** heap data. You can clone it. Strings derive clone.
+<code rust>
+    let s1 = String::from("hello");
+    let s2 = s1.clone();
+    println!("s1 = {}, s2 = {}", s1, s2); //Good job it compiles and you wasted memory!
+    //Copied from the rust book
+</code>
+== Copy ==
+As with the simple int example above. Simple stack stored traits can be copied and used over again. Even structs that contain these copyable types can be copied. If a type inherits the **drop** trait it cannot be copied.
+<wrap lo> things that can be copied : u32,bool,f64,char, moreplscheckthedocs. </wrap>
+an (i32,i32) can be copied but a (i32,string) cannot.
+== Ownership and Functions ==
+its simple
+<code rust>
+fn main() {
+    let s = String::from("hello");  // s comes into scope
+    takes_ownership(s);             // s's value moves into the function...
+                                    // ... and so is no longer valid here
+    let x = 5;                      // x comes into scope
+    makes_copy(x);                  // x would move into the function,
+                                    // but i32 is Copy, so it's okay to still
+                                    // use x afterward
+} // Here, x goes out of scope, then s. But because s's value was moved, nothing
+  // special happens.
+fn takes_ownership(some_string: String) { // some_string comes into scope
+    println!("{}", some_string);
+} // Here, some_string goes out of scope and `drop` is called. The backing
+  // memory is freed.
+fn makes_copy(some_integer: i32) { // some_integer comes into scope
+    println!("{}", some_integer);
+} // Here, some_integer goes out of scope. Nothing special happens.
+//Copied from the rust book
+</code>
+Things that derive copy, get copied into a function. and droppable types get moved.
+Returning stuff follows a similar rule.
+<code rust>
+fn main() {
+    let s1 = gives_ownership();         // gives_ownership moves its return
+                                        // value into s1
+    let s2 = String::from("hello");     // s2 comes into scope
+    let s3 = takes_and_gives_back(s2);  // s2 is moved into
+                                        // takes_and_gives_back, which also
+                                        // moves its return value into s3
+} // Here, s3 goes out of scope and is dropped. s2 was moved, so nothing
+  // happens. s1 goes out of scope and is dropped.
+fn gives_ownership() -> String {             // gives_ownership will move its
+                                             // return value into the function
+                                             // that calls it
+    let some_string = String::from("yours"); // some_string comes into scope
+    some_string                              // some_string is returned and
+                                             // moves out to the calling
+                                             // function
+}
+// This function takes a String and returns one
+fn takes_and_gives_back(a_string: String) -> String { // a_string comes into
+                                                      // scope
+    a_string  // a_string is returned and moves out to the calling function
+}
+//Taken from the rust docs.. Again please read that. and not this...
+</code>
+S1 gets ownership from the functions return.
+S2 is moved into the function and then is returend back to s3

Ultra Letter Linker

User Tools

Site Tools

Differences

Page Tools