Differences

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

--- devlogs:7_5_2022 [2022/05/08 00:08]
root
+++ devlogs:7_5_2022 [2023/10/19 15:25] (current)
@@ Line 164: / Line 164: @@
     println!("s1 = {}, s2 = {}", s1, s2); //Good job it compiles and you wasted memory!
+    //Copied from the rust book
 </code>
@@ Line 171: / Line 172: @@
 <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