Links in Readme.md, New concepts (/src/*.rs)

2026-04-06 22:03:09 -07:00
parent f750099b06
commit 8e9480b598
6 changed files with 369 additions and 5 deletions
--- a/Rust_Concepts/src/clone.rs
+++ b/Rust_Concepts/src/clone.rs
@@ -0,0 +1,97 @@
+/* Rust Concepts: https://sociocyber.site/rust_concepts_v2.html
+   Concept: Clone 
+   Usage: clone from variable a value into new variable , not borrowing, not shadowing.
+   let variable2 = variable1.clone() 
+
+   (heap-space1)      (heap-space2)
+      (data1)   ->      (data1)
+*/
+
+fn main() {
+	let owner1 = String::from("I am saved only in one heap-space1, not others. Value in heap-space1 Not coped into heap-space2."); // owner
+	let owner2 = owner1; // Move ownership (pointer only) from owner1 to owner2. Then owner1 not accsessable. Can't be used. 
+	//println!("owner1 {}", owner1); // NOT ACCESS, not-valid compiler mark this variable as not accsessable. Pointer (--> heap --> ['v' 'a' 'l' 'u' 'e']) moved in new owner2 
+	 							    // compiler: value borrowed here after move
+	println!("Owner2: {}", owner2);
+	/*
+		╔════════════════════════════════════════════════════════════════════════════╗
+		║        MOVE ownership (Default Behavior) let owner2 = owner1;              ║
+		╚════════════════════════════════════════════════════════════════════════════╝
+
+		* owner1 ptr (pointer) moved into (owner2)
+
+		STACK                              HEAP
+		┌─────────────────────┐            ┌──────────────────────────────────┐
+		│ owner1: String      │            │ "I am saved only in one..."      │
+		│ ┌─────────────────┐ │            │ [Offset: 0]                      │
+		│ │ ptr ────────────┼─┼──────────► │ [Length: 97 bytes]               │
+		│ │ len: 97         │ │            │ [Capacity: 97]                   │
+		│ │ cap: 97         │ │            └──────────────────────────────────┘
+		│ └─────────────────┘ │
+		└─────────────────────┘
+		        │
+		        │ let owner2 = owner1;  (MOVE: transfer ownership)
+		        │
+		        ▼
+		┌─────────────────────┐            ┌──────────────────────────────────┐
+		│ owner1: ❌ INVALID  │            │ "I am saved only in one..."      │
+		│ (moved out)         │            │ [Same address1 in memory]         │
+		└─────────────────────┘            └──────────────────────────────────┘
+
+		┌─────────────────────┐
+		│ owner2: String      │
+		│ ┌─────────────────┐ │ (address1)
+		│ │ ptr ────────────┼─┼──────────► (points to SAME address1 heap allocation)
+		│ │ len: 97         │ │
+		│ │ cap: 97         │ │
+		│ └─────────────────┘ │
+		└─────────────────────┘
+		(VALID: still accessible)
+	*/
+
+	// But with "Clone" we can not just move ownership, we can copy value from heap, to new memory area (new heap address space) 
+	let owner_1 = String::from("I am saved in 2 heap-spaces. (I am a copy from heap-space1, if you see me in heap-space2)"); // ACCESSABLE! Valid, Not shaddowed. Compiler not mark this. Ownership not moved.
+	let owner_2 = owner_1.clone(); // Clone heap-space1 to new heap-space2 (copy a value, not borrowing, NOT mark owner_1 to not accsessable)
+	println!("heap-space1: {}", owner_1); // valid
+	println!("heap-space2: {}", owner_2); // valid
+
+	/*
+		╔════════════════════════════════════════════════════════════════════════════╗
+		║                     CLONE (Deep Copy) .clone()                             ║
+		╚════════════════════════════════════════════════════════════════════════════╝
+
+		STACK                              HEAP (Heap-space1) 	Pointers point to 0x1000 and 0x2000
+		┌─────────────────────┐            ┌──────────────────────────────────┐
+		│ owner_1: String     │            │ "I am saved in 2 heap-spaces..." │
+		│ ┌─────────────────┐ │            │ [Address: 0x1000]                │
+		│ │ ptr ────────────┼─┼──────────► │ [Length: 99 bytes]               │
+		│ │ len: 99         │ │            │ [Capacity: 99]                   │
+		│ │ cap: 99         │ │            └──────────────────────────────────┘
+		│ └─────────────────┘ │
+		└─────────────────────┘
+		        │
+		        │ let owner_2 = owner_1.clone();  (CLONE: deep copy heap data)
+		        │ 
+		        ▼   [After]                 Heap-space1  	    Pointers point to 0x1000 and 0x2000
+		┌─────────────────────┐            ┌──────────────────────────────────┐
+		│ owner_1: String ✓   │            │ "I am saved in 2 heap-spaces..." │
+		│ ┌─────────────────┐ │            │ [Address: 0x1000] ◄── ORIGINAL   │
+		│ │ ptr ────────────┼─┼──────────► │ [Length: 99 bytes]               │
+		│ │ len: 99         │ │            │ [Capacity: 99]                   │
+		│ │ cap: 99         │ │            └──────────────────────────────────┘
+		│ └─────────────────┘ │
+		└─────────────────────┘
+		(VALID: still accessible)
+	                                         Heap-space2 		Pointers point to 0x2000 and 0x3000
+		┌─────────────────────┐            ┌──────────────────────────────────┐
+		│ owner_2: String ✓   │            │ "I am saved in 2 heap-spaces..." │
+		│ ┌─────────────────┐ │            │ [Address: 0x2000] ◄── COPY       │
+		│ │ ptr ────────────┼─┼──────────► │ [Length: 99 bytes]               │
+		│ │ len: 99         │ │            │ [Capacity: 99]                   │
+		│ │ cap: 99         │ │            └──────────────────────────────────┘
+		│ └─────────────────┘ │
+		└─────────────────────┘
+		(VALID: still accessible)
+	*/
+
+}