BudiBaduQuiziBadu

Rust Borrowing Quiz

Rust
0 Passed
0% acceptance

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.

45 Questions
~90 minutes
1

Question 1

What is borrowing in Rust?

A
Transferring ownership permanently
B
Granting temporary access to a value without transferring ownership
C
Copying values implicitly
D
Moving values between threads
2

Question 2

What is the syntax for creating an immutable reference?

A
&value
B
&mut value
C
*value
D
ref value
3

Question 3

What is the syntax for creating a mutable reference?

A
&value
B
&mut value
C
*value
D
mut &value
4

Question 4

How many immutable references to the same value can exist simultaneously?

A
Zero
B
One
C
As many as you want
D
Only in the same scope
5

Question 5

Can you have a mutable reference and an immutable reference to the same value at the same time?

A
Yes, always
B
No, never
C
Only if they are in different scopes
D
Only for primitive types
6

Question 6

What will this code do?

rust
fn main() {
    let mut x = 5;
    let r1 = &x;
    let r2 = &x;
    println!("r1 = {}, r2 = {}", r1, r2);
}
A
Print 'r1 = 5, r2 = 5'
B
Compilation error
C
Runtime panic
D
Only r1 is valid
7

Question 7

What will this code do?

rust
fn main() {
    let mut x = 5;
    let r1 = &mut x;
    let r2 = &x;
    println!("r1 = {}, r2 = {}", r1, r2);
}
A
Print 'r1 = 5, r2 = 5'
B
Compilation error
C
Runtime panic
D
Only r1 is valid
8

Question 8

What are the borrowing rules in Rust?

A
One mutable reference OR multiple immutable references
B
Multiple mutable references allowed
C
References can outlive the owner
D
No restrictions on references
9

Question 9

What happens when you try to modify a value through an immutable reference?

A
It works
B
Compilation error
C
Runtime panic
D
The value becomes mutable
10

Question 10

What is dereferencing in Rust?

A
Creating a reference
B
Accessing the value a reference points to
C
Moving ownership
D
Copying a value
11

Question 11

What will this code print?

rust
fn main() {
    let x = 5;
    let r = &x;
    println!("x = {}, r = {}", x, *r);
}
A
x = 5, r = 5
B
Compilation error
C
x = 5, r = address
D
Runtime error
12

Question 12

Can you dereference a mutable reference to modify the value?

A
Yes, with *mut_ref = new_value
B
No, mutable references can't be dereferenced
C
Only for primitive types
D
Only in unsafe code
13

Question 13

What is the scope of a reference?

A
From creation until the end of the program
B
From creation until the referenced value is dropped
C
From creation until the reference is used
D
References have no scope
14

Question 14

What will this code do?

rust
fn main() {
    let r;
    {
        let x = 5;
        r = &x;
    }
    println!("{}", r);
}
A
Print 5
B
Compilation error
C
Runtime panic
D
Print garbage value
15

Question 15

What is the borrow checker?

A
A runtime garbage collector
B
A compile-time analyzer that enforces borrowing rules
C
A linter for style issues
D
A debugger for reference errors
16

Question 16

When does the borrow checker run?

A
At runtime
B
At compile time
C
When the program starts
D
Only when there are errors
17

Question 17

What is a dangling reference?

A
A reference that points to a valid value
B
A reference that points to memory that has been freed
C
A reference that is never used
D
A reference to a constant
18

Question 18

How does Rust prevent dangling references?

A
Garbage collection
B
Lifetime checking
C
Runtime bounds checking
D
Manual memory management
19

Question 19

What will this code do?

rust
fn main() {
    let mut s = String::from("hello");
    let r1 = &s;
    let r2 = &s;
    s.push_str(" world");
    println!("{} {}", r1, r2);
}
A
Print 'hello world hello world'
B
Compilation error
C
Runtime panic
D
Print 'hello hello'
20

Question 20

What will this code do?

rust
fn main() {
    let mut s = String::from("hello");
    let r = &mut s;
    r.push_str(" world");
    println!("{}", r);
}
A
Print 'hello world'
B
Compilation error
C
Runtime panic
D
Print 'hello'
21

Question 21

Can you have multiple mutable references to the same value?

A
Yes, always
B
No, never
C
Only in different scopes
D
Only for primitive types
22

Question 22

What is the difference between &T and &mut T?

A
No difference
B
&T allows reading, &mut T allows reading and writing
C
&T is for primitives, &mut T is for structs
D
&T moves ownership, &mut T borrows
23

Question 23

What will this code do?

rust
fn main() {
    let mut x = 5;
    {
        let y = &mut x;
        *y = 10;
    }
    println!("{}", x);
}
A
Print 10
B
Print 5
C
Compilation error
D
Runtime panic
24

Question 24

What happens to references when they go out of scope?

A
They are dropped
B
The referenced value is dropped
C
Memory is leaked
D
They become invalid
25

Question 25

Can you return a reference from a function?

A
Yes, always
B
No, never
C
Only if the referenced value is static
D
Only for primitive types
26

Question 26

What will this code do?

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

fn main() {
    let r = return_ref();
    println!("{}", r);
}
A
Print 'hello'
B
Compilation error
C
Runtime panic
D
Undefined behavior
27

Question 27

What is implicit dereferencing?

A
Automatically adding * when accessing fields
B
Converting references to values
C
Moving ownership
D
Copying values
28

Question 28

What will this code print?

rust
fn main() {
    let s = String::from("hello");
    let r = &s;
    println!("Length: {}", r.len());
}
A
Length: 5
B
Compilation error
C
Runtime panic
D
Length: 0
29

Question 29

What are the benefits of borrowing over ownership?

A
Faster performance
B
Avoiding unnecessary copies
C
Allowing multiple access patterns
D
All of the above
30

Question 30

When should you use borrowing instead of ownership?

A
When you only need temporary access
B
When the caller needs to use the value again
C
When you want to avoid copies
D
All of the above
31

Question 31

What will this code do?

rust
fn main() {
    let mut vec = vec![1, 2, 3];
    let first = &vec[0];
    vec.push(4);
    println!("{}", first);
}
A
Print 1
B
Compilation error
C
Runtime panic
D
Print 4
32

Question 32

What is reference aliasing?

A
Creating multiple names for the same reference
B
Having multiple references to the same value
C
Moving ownership
D
Copying values
33

Question 33

Why does Rust restrict aliasing with mutation?

A
Performance reasons
B
To prevent data races and maintain safety
C
Because it's complicated to implement
D
To force ownership transfers
34

Question 34

What is the NLL (Non-Lexical Lifetimes) feature?

A
A garbage collector
B
More precise lifetime analysis
C
A new reference type
D
Runtime borrow checking
35

Question 35

What will this code do with NLL?

rust
fn main() {
    let mut x = 5;
    let r = &x;
    println!("{}", r);
    let y = &mut x;
    *y = 10;
    println!("{}", y);
}
A
Compilation error
B
Print 5 then 10
C
Runtime panic
D
Print 10 then 10
36

Question 36

What is a borrow split?

A
Dividing a reference into smaller parts
B
Creating separate borrows for different parts of a value
C
Moving ownership partially
D
Copying part of a value
37

Question 37

What will this code do?

rust
struct Point {
    x: i32,
    y: i32,
}

fn main() {
    let mut p = Point { x: 1, y: 2 };
    let rx = &mut p.x;
    let ry = &mut p.y;
    *rx = 10;
    *ry = 20;
    println!("{} {}", p.x, p.y);
}
A
Print '10 20'
B
Compilation error
C
Runtime panic
D
Print '1 2'
38

Question 38

What is the purpose of the RefCell<T> type?

A
To bypass borrow checking at runtime
B
To create immutable references
C
To move ownership
D
To copy values
39

Question 39

When should you use RefCell<T>?

A
Always, for performance
B
When you need interior mutability in single-threaded code
C
For all mutable data
D
Never, it's unsafe
40

Question 40

What is the difference between & and &mut borrows?

A
Performance only
B
& allows shared access, &mut allows exclusive access
C
Syntax only
D
& moves, &mut borrows
41

Question 41

What will this code do?

rust
fn main() {
    let s = String::from("hello");
    let len = calculate_length(&s);
    println!("Length of '{}' is {}", s, len);
}

fn calculate_length(s: &String) -> usize {
    s.len()
}
A
Print 'Length of hello is 5'
B
Compilation error
C
Runtime panic
D
Print garbage
42

Question 42

Why is borrowing important for function parameters?

A
Performance
B
Allows the caller to retain ownership
C
Prevents copies
D
All of the above
43

Question 43

What is the relationship between borrowing and lifetimes?

A
They are unrelated
B
Lifetimes track how long borrows are valid
C
Borrowing creates lifetimes
D
Lifetimes replace borrowing
44

Question 44

What is the main advantage of Rust's borrowing system over garbage collection?

A
Faster runtime performance
B
Compile-time memory safety guarantees
C
Simpler syntax
D
Automatic optimization
45

Question 45

When implementing a library API, how should you design borrowing in your function signatures?

A
Always take ownership
B
Always borrow
C
Use borrowing when the function doesn't need ownership, ownership when it consumes the value
D
Use Rc<T> for everything

Other Quiz Categories

JavaScript
47 quizzes
Basics
Variables & Data Types
Operators & Expressions
Python
29 quizzes
Introduction & Core Fundamentals
Data Types Overview
Type Casting
Golang
29 quizzes
Basics & Syntax
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
Variable Naming
Data Types Overview
Linked List
11 quizzes
Introduction
Node Structure and Pointer Fundamentals
Singly Linked List

QUIZZES IN Rust

1

Cargo and Project Setup

80

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.

2

Variables and Mutability

40

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.

3

Data Types

45

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.

4

Control Flow

45

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.

5

Functions

40

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

6

Ownership

45

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.

7

Borrowing

45

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.

8

Lifetimes

40

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.

9

Strings

40

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.

10

Collections

40

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.

11

Slices

40

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.

12

Pattern Matching

40

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.

13

Enums

40

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.

14

Struct

40

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.

15

Modules

40

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.

16

Traits

40

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.

17

Generic

40

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.

18

Iterators

40

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

19

Closures

40

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

20

Error Handling

40

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

21

File and I/O Operations

40

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

22

Smart Pointers

40

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

23

Concurrency

40

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

24

Async Programming

40

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

25

Memory Management

40

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

26

Macros

40

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

27

Attributes

40

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

28

Testing

40

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

29

Crate Architecture

40

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

30

Performance and Optimization

40

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