Rewrite Memory Layout

Author: dumindu

content/en/docs/c2.borrowing.md

@@ -80,49 +80,58 @@ References are pointers that are either a thin pointer that points to a Sized ty
 use std::mem::size_of_val;
 
 fn main() {
-    let a = 3; // 💡 3 store on the stack
-    let b: [i32; 3] = [1, 2, 3]; // 💡 [1, 2, 3] store inline on the stack
+    let a = 3; // 3 stores on the stack
+    let b = [1, 2, 3, 4, 5]; // [1, 2, 3, 4, 5] store inline on the stack
 
-    let c = &a;       // 💡 c is a thin pointer        (&i32)      - [ptr]
-    let d = &b;       // 💡 d is also a thin pointer   (&[i32; 3]) - [ptr]
-    let e = &b[1..];  // 💡 [2, 3]; e is a fat pointer (&[i32])    - [ptr, len]
+    let c = &a;        // 💡 c is a thin pointer - [ptr] - points to `a`
+    let d = &b;        // 💡 d is a thin pointer - [ptr] - points to `b`
+    let e = &b[1..3];  // 💡 e is a fat pointer  - [ptr, len] - points to 2nd element of `b` and length is 2
 
-    println!("\nSize of actual data: a: {} bytes, b: {} bytes",
-        size_of_val(&a), size_of_val(&b) // 4 and 12
+    println!("Size of actual data: a: {} bytes, b: {} bytes",
+        size_of_val(&a), size_of_val(&b) // 4, 20
     );
 
     println!("Size of the references: c: {} bytes, d: {} bytes, e: {} bytes",
-        size_of_val(&c), size_of_val(&d), size_of_val(&e) // 8 , 8, 16
+        size_of_val(&c), size_of_val(&d), size_of_val(&e) // 8 , 8, 16 on 64-bit machines
     );
 }
+
+// `d`: A reference to a fixed-size array, &[i32;5]. The compiler knows the length from the type.
+// `e`: A reference to a slice, &[i32]. Since the length is not part of the type, 
+//      it stores [address, length] at runtime, making it a fat pointer.
 ```
 
-> 💡 An array of Copy types stores its data inline (store elements contiguously) wherever it is declared. It lives on the stack as a local variable, in the binary if it is `static`, or on the heap if it is wrapped in a `Box` or `Vec`.
->
->  ```rust
->      STACK
->   [ 1, 2, 3 ]     // let b: [i32; 3] = [1, 2, 3];
->   
->   [ ptr ]         // let d = &b; 💡 pointer points to 0th index element of the array + len(3) is baked into the Type
->   (Thin Ptr) 
->   
->   [ ptr, len ]    // let e = &b[1..]; 💡 pointer points to 1st index element of the array
->    (Fat Ptr)
->   ```
-
-> 💡 An array of non-Copy types also stores its elements inline and contiguously wherever it is declared. However, each element acts as a "header" that contains a pointer to the actual data stored on the heap. Example: `[String; 3]`
->
->  ```rust
->    STACK                             HEAP
->  [ String, String, String ]  ->  "A", "B", "C"     // if `let b = [String::from("A"), String::from("B"), String::from("C")];`
->    3x ( ptr, len, cap)          (3 allocations)
->  
->  [ ptr ]         // let d = &b; 💡 pointer points to 0th String Header
->  (Thin Ptr) 
->  
->  [ ptr, len ]    // let e = &b[1..]; 💡 pointer points to 1st String Header
->   (Fat Ptr)
->  ```
+| Variable Name                                                         | Type       | Location | Size     |
+|-----------------------------------------------------------------------|------------|----------|----------|
+| `a`                                                                   | `i32`      | Stack    | 4 bytes  |
+| `b`                                                                   | `[i32;3]`  | Stack    | 12 bytes |
+| `c` (Stores the full memory address to `a`)                           | `&i32`     | Stack    | 8 bytes  |
+| `d` (Stores the full memory address to `b`)                           | `&[i32;3]` | Stack    | 8 bytes  |
+| `e` (Stores the full memory address to 2nd element of `b` and length) | `&[i32]`   | Stack    | 16 bytes |
+
+```rust
+use std::mem::size_of_val;
+
+fn main() {
+    // 💡 String stores [ptr, cap, len] on the stack, which points to "Hello" on the heap
+    let a = String::from("Hello");
+    
+    // 💡 Vec stores [ptr, cap, len] on the stack, which points to the array of &str on the heap
+    let b = vec!["A", "B", "C", "D", "E"]; 
+
+    let c = &a;       // 💡 c is a thin pointer - [ptr] - points to the String struct `a` on the stack
+    let d = &b;       // 💡 d is a thin pointer - [ptr] - points to the Vec struct `b` on the stack
+    let e = &b[1..3]; // 💡 e is a fat pointer  - [ptr, len] - points to the 2nd element in the heap buffer
+
+    println!("\nSize of stack metadata: a: {} bytes, b: {} bytes",
+        size_of_val(&a), size_of_val(&b) // 24, 24
+    );
+
+    println!("Size of the references: c: {} bytes, d: {} bytes, e: {} bytes",
+        size_of_val(&c), size_of_val(&d), size_of_val(&e) // 8, 8, 16 on 64-bit machines
+    );
+}
+```
 
 ## Shared Borrowing