Rust Programming

  1. Understanding Ownership
    1. Memory Management Concepts
      1. Stack vs Heap Memory
        1. Stack Allocation Characteristics
          1. Heap Allocation Characteristics
            1. Performance Implications
            2. Automatic Memory Management
              1. Manual Memory Management Problems
                1. Rust's Ownership Solution
                2. Ownership Rules and Principles
                  1. Single Owner Rule
                    1. Scope-Based Deallocation
                      1. Move Semantics
                        1. Value Moves
                          1. Invalidation After Move
                            1. Move vs Copy Types
                            2. Copy Semantics
                              1. Copy Trait
                                1. Implicit Copying
                                  1. Stack-Only Data
                                  2. Clone Semantics
                                    1. Clone Trait
                                      1. Explicit Cloning
                                        1. Deep vs Shallow Copying
                                      2. References and Borrowing
                                        1. Immutable References
                                          1. Creating Immutable References
                                            1. Multiple Immutable References
                                              1. Reference Scope Rules
                                              2. Mutable References
                                                1. Creating Mutable References
                                                  1. Exclusive Mutable Access
                                                    1. Borrowing Rules Enforcement
                                                    2. Reference Lifetime Basics
                                                      1. Dangling Reference Prevention
                                                        1. Reference vs Owned Values
                                                        2. Slices
                                                          1. String Slices
                                                            1. &str Type
                                                              1. String Literal Types
                                                                1. Slicing Strings
                                                                2. Array Slices
                                                                  1. &[T] Type
                                                                    1. Slicing Arrays
                                                                      1. Slice Indexing
                                                                      2. Slice Syntax and Ranges
                                                                        1. Borrowing vs Owning Slices

                                                                      Previous

                                                                      2. Rust Fundamentals

                                                                      Go to top

                                                                      Next

                                                                      4. Structuring Data with Structs