Rust Memory Management Quiz

0 Passed

0% acceptance

Deep dive into Rust's ownership system, borrowing rules, and advanced memory management patterns for safe and efficient code

40 Questions

~80 minutes

Question 1

What are the three ownership rules in Rust?

Each value has one owner, ownership can be transferred, when owner goes out of scope value is dropped

Values can have multiple owners, borrowing is automatic, garbage collection handles cleanup

Ownership is shared, references are weak, manual memory management

No ownership rules exist

Question 2

What does this ownership example show?

rust

let s1 = String::from("hello");
let s2 = s1;
println!("{}", s1);

Compilation error - ownership transferred to s2, s1 invalid

Prints 'hello' twice

Runtime error

s1 and s2 share ownership

Question 3

What is the difference between stack and heap allocation?

Stack is fast, fixed-size, automatic cleanup; heap is slower, dynamic-size, manual cleanup

Stack is slow, heap is fast

They are identical

Rust doesn't use heap

Question 4

What does Copy trait allow?

Types that can be duplicated by copying bits, both copies remain valid

Types that can be moved only

Types that can be cloned only

Copy doesn't exist

Question 5

What does Clone trait allow?

Explicit deep copying of values

Automatic copying

Moving values

Clone doesn't exist

Question 6

What are borrowing rules?

One mutable reference OR multiple immutable references, references must be valid

Multiple mutable references allowed

References can be invalid

No borrowing rules

Question 7

What does this borrowing example show?

rust

let mut s = String::from("hello");
let r1 = &s;
let r2 = &s;
let r3 = &mut s;

Compilation error - cannot borrow mutable when immutable borrows exist

Succeeds

Runtime error

Creates multiple mutable references

Question 8

What is a lifetime?

Scope for which reference is valid

How long a value lives

Execution time

Lifetimes don't exist

Question 9

What does this lifetime example show?

rust

fn longest<'a>(s1: &'a str, s2: &'a str) -> &'a str {
    if s1.len() > s2.len() { s1 } else { s2 }
}

Function returns reference valid for lifetime 'a

Compilation error

Returns owned string

Lifetime annotation unnecessary

Question 10

What is lifetime elision?

Compiler automatically infers lifetime annotations

Manual lifetime annotation

Lifetime removal

Lifetime elision doesn't exist

Question 11

What is a dangling reference?

Reference to data that has been deallocated

Valid reference

Null pointer

Dangling references don't exist in Rust

Question 12

What does this dangling reference example show?

rust

fn dangle() -> &String {
    let s = String::from("hello");
    &s
}

Compilation error - would return reference to dropped value

Succeeds

Returns valid reference

Runtime error

Question 13

What is RAII?

Resource Acquisition Is Initialization - resources managed by object lifetime

Random Access Integer Array

Resource Allocation Interface

RAII doesn't exist

Question 14

What does Drop trait do?

Defines cleanup logic when value goes out of scope

Defines how to drop references

Defines copying

Drop doesn't exist

Question 15

What does this custom Drop example show?

rust

struct CustomDrop {
    data: String,
}

impl Drop for CustomDrop {
    fn drop(&mut self) {
        println!("Dropping: {}", self.data);
    }
}

Prints message when CustomDrop value is deallocated

Compilation error

Prints immediately

Runtime error

Question 16

What is the difference between & and &mut?

& is immutable borrow, &mut is mutable borrow

They are identical

&mut allows multiple borrows

No difference

Question 17

What is interior mutability?

Mutating data through immutable reference using types like RefCell

Normal mutability

Immutable data

Interior mutability doesn't exist

Question 18

What is the difference between Cell<T> and RefCell<T>?

Cell copies values, RefCell borrows; Cell for Copy types, RefCell for any type

They are identical

Cell is thread-safe

RefCell doesn't exist

Question 19

What is a raw pointer?

Unchecked pointer (*const T, *mut T) that can be null or dangling

Smart pointer

Reference

Raw pointers don't exist

Question 20

What does unsafe keyword allow?

Bypassing Rust's safety guarantees for necessary low-level operations

Making code safe

Automatic safety

unsafe doesn't exist

Question 21

What is memory layout in Rust?

How data is arranged in memory - alignment, padding, size

Code organization

File structure

Memory layout doesn't matter

Question 22

What does #[repr(C)] do?

Uses C-compatible memory layout for struct fields

Makes struct copyable

Adds methods

#[repr(C)] doesn't exist

Question 23

What is ownership transfer (move)?

Transferring ownership from one variable to another, invalidating source

Copying data

Borrowing

Ownership transfer doesn't exist

Question 24

What is partial move?

Moving some fields of struct while leaving others

Moving entire struct

Copying struct

Partial move doesn't exist

Question 25

What does this partial move example show?

rust

struct Person {
    name: String,
    age: u32,
}

let p = Person { name: String::from("Alice"), age: 30 };
let name = p.name;
// p.age is still accessible, p.name is moved

Moves name field, age remains accessible

Compilation error

Moves entire struct

Runtime error

Question 26

What is the difference between String and &str?

String owns heap data, &str borrows existing string slice

They are identical

&str owns data

String doesn't exist

Question 27

What is the difference between Vec<T> and &[T]?

Vec owns heap data, &[T] borrows existing slice

They are identical

&[T] owns data

Vec doesn't exist

Question 28

What is deref coercion?

Automatic conversion from &T to &U where T: Deref<Target = U>

Manual dereferencing

Type casting

Deref coercion doesn't exist

Question 29

What does this deref coercion example show?

rust

fn takes_str(s: &str) { println!("{}", s); }
let s = String::from("hello");
takes_str(&s);

Deref coercion converts &String to &str automatically

Compilation error

Manual conversion needed

Runtime error

Question 30

What is the difference between Sized and ?Sized?

Sized has compile-time known size, ?Sized may have dynamic size

They are identical

?Sized is smaller

?Sized doesn't exist

Question 31

What is DST (Dynamically Sized Type)?

Types with unknown size at compile time like [T] and str

Fixed-size types

Generic types

DST doesn't exist

Question 32

What is memory alignment?

Address requirement for data types (power of 2)

Memory size

Memory location

Memory alignment doesn't matter

Question 33

What is padding in structs?

Unused bytes inserted for alignment requirements

Data bytes

Code bytes

Padding doesn't exist

Question 34

What is the difference between fat and thin pointers?

Thin pointers are single usize, fat pointers contain address + metadata

They are identical

Fat pointers are smaller

No difference

Question 35

What is stack allocation vs heap allocation performance?

Stack is faster (no allocation overhead), heap slower but flexible

Heap is faster

They are identical

Performance doesn't matter

Question 36

What is the borrow checker?

Compile-time analysis ensuring borrowing rules

Runtime checking

Manual checking

Borrow checker doesn't exist

Question 37

What is NLL (Non-Lexical Lifetimes)?

Lifetimes end when variable last used, not scope end

Lexical lifetimes

Manual lifetime management

NLL doesn't exist

Question 38

What is the difference between lifetime bounds and trait bounds?

Lifetime bounds constrain reference validity, trait bounds constrain behavior

They are identical

Lifetime bounds are stricter

No difference

Question 39

What is memory safety?

Prevention of undefined behavior from memory operations

Fast memory access

Large memory usage

Memory safety doesn't matter

Question 40

In a complex data structure with trees of objects that reference each other, shared configuration data accessed by multiple threads, and temporary buffers with varying lifetimes, which memory management patterns would you choose and why?

Rc<RefCell<Node>> for tree with cycles, Arc<Config> for shared config, scoped allocation for buffers

Raw pointers everywhere

Global variables

Manual malloc/free

Other Quiz Categories

JavaScript

47 quizzes

Basics

Variables & Data Types

Operators & Expressions

Python

29 quizzes

Introduction & Core Fundamentals

Data Types & Zero Values

Operators & Expressions

C++

26 quizzes

Basics

Variables & Data Types

Operators & Expression

Java

22 quizzes

Java Basics & JVM Fundamentals

Variables, Data Types & Type Casting

Operators & Expressions

Matlab

21 quizzes

Basics & Environment

Variables and Data Type

Arrays and Matric

TypeScript

19 quizzes

Introduction and Overview

Installation and Configuration

Basic Types and Type Annotations

SQL Database

15 quizzes

Foundations and Basics

Basic Query Selection

Filter, Sort, and Alias Essentials

PHP

15 quizzes

Syntax Building Blocks

Node Structure and Pointer Fundamentals

Singly Linked List

QUIZZES IN Rust

Cargo and Project Setup

40 comprehensive questions on Rust's package manager Cargo, covering project initialization, building, running, project structure, and dependency management — with 15 code examples demonstrating practical Cargo usage.

Variables and Mutability

40 comprehensive questions on Rust's variable system, covering let bindings, mut keyword, shadowing, type inference, and constants — with 12 code examples demonstrating practical variable usage patterns.

Data Types

45 comprehensive questions on Rust's type system, covering scalar types, compound types, type conversions, numeric operations, and string types — with 15 code examples demonstrating practical type usage patterns.

Control Flow

45 comprehensive questions on Rust's control flow constructs, covering if expressions, loops, and control flow keywords — with 15 code examples demonstrating practical control flow usage.

Functions

40 questions covering function parameters, return values, expressions, diverging functions, and function scope in Rust.

Ownership

45 in-depth questions covering Rust's ownership system, move semantics, copy types, resource cleanup through Drop trait, precise drop timing, and ownership transfer patterns — with 12 code examples to solidify understanding.

Borrowing

45 in-depth questions covering Rust's borrowing system, immutable and mutable references, aliasing rules, reference scopes, and borrow checker validation — with 13 code examples to solidify understanding.

Lifetimes

40 in-depth questions covering Rust's lifetime system, lifetime annotations, elision rules, function signatures with lifetimes, struct references, and common lifetime errors — with 11 code examples to solidify understanding.

Strings

40 comprehensive questions on Rust's string types, covering String vs &str, UTF-8 behavior, slicing, mutating strings, and conversions — with 11 code examples demonstrating practical string handling patterns.

Collections

40 comprehensive questions on Rust's collection types, covering Vec, HashMap, VecDeque, iteration patterns, and capacity management — with 11 code examples demonstrating practical collection usage.

Slices

40 comprehensive questions on Rust's slice types, covering borrowed views, indexing, mutable slices, ranges, and slice methods — with 11 code examples demonstrating practical slice usage patterns.

Pattern Matching

40 comprehensive questions on Rust's pattern matching system, covering match expressions, destructuring, guards, wildcards, and enum matching — with 11 code examples demonstrating practical pattern matching techniques.

Enums

40 comprehensive questions on Rust's enum system, covering simple variants, data-carrying variants, enum matching, methods on enums, and Option/Result patterns — with 11 code examples demonstrating practical enum usage.

Struct

40 comprehensive questions on Rust's struct system, covering named fields, tuple structs, methods, associated functions, and field ownership — with 11 code examples demonstrating practical struct usage.

Modules

40 comprehensive questions on Rust's module system, covering module creation, visibility, imports, paths, and the use keyword — with 11 code examples demonstrating practical module organization patterns.

Traits

40 comprehensive questions on Rust's trait system, covering trait definitions, implementations, bounds, associated types, and trait objects — with 11 code examples demonstrating practical trait usage patterns.

Generic

40 comprehensive questions on Rust's generic programming system, covering generic functions, structs, enums, impl blocks, and monomorphization — with 11 code examples demonstrating practical generic usage patterns.

Iterators

Master Rust's powerful iterator system for efficient data processing and transformation

Closures

Master Rust's closure system for capturing environment variables and creating flexible function-like constructs

Error Handling

Master Rust's robust error handling system with Result, Option, and the ? operator for reliable code

File and I/O Operations

Master Rust's file system operations and I/O handling for robust data persistence and streaming

Smart Pointers

Master Rust's smart pointer types for automatic memory management and safe heap allocation

Concurrency

Master Rust's concurrency model with threads, channels, and synchronization primitives for safe parallel programming

Async Programming

Master asynchronous programming in Rust with futures, async/await, and concurrent execution patterns

Memory Management

Deep dive into Rust's ownership system, borrowing rules, and advanced memory management patterns for safe and efficient code

Macros

Master Rust's metaprogramming system with declarative and procedural macros for code generation and compile-time programming

Attributes

Master Rust's attribute system for conditional compilation, testing, documentation, and code generation

Testing

Master comprehensive testing strategies in Rust including unit tests, integration tests, documentation tests, and testing best practices

Crate Architecture

Master the design and organization of Rust crates including module systems, workspace management, dependency handling, and publishing strategies

Performance and Optimization

Master advanced performance techniques in Rust including profiling, benchmarking, memory optimization, and compiler optimizations

Rust Memory Management Quiz

Question 1

Question 2

Question 3

Question 4

Question 5

Question 6

Question 7

Question 8

Question 9

Question 10

Question 11

Question 12

Question 13

Question 14

Question 15

Question 16

Question 17

Question 18

Question 19

Question 20

Question 21

Question 22

Question 23

Question 24

Question 25

Question 26

Question 27

Question 28

Question 29

Question 30

Question 31

Question 32

Question 33

Question 34

Question 35

Question 36

Question 37

Question 38

Question 39

Question 40

What is Memory Management in Rust?

What You Will Practise

Other Quiz Categories

QUIZZES IN Rust

Cargo and Project Setup

Variables and Mutability

Data Types

Control Flow

Functions

Ownership

Borrowing

Lifetimes

Strings

Collections

Slices

Pattern Matching

Enums

Struct

Modules

Traits

Generic

Iterators

Closures

Error Handling

File and I/O Operations

Smart Pointers

Concurrency

Async Programming

Memory Management

Macros

Attributes

Testing

Crate Architecture

Performance and Optimization