Rust Smart Pointers Quiz

Rust

0 Passed

0% acceptance

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

40 Questions

~80 minutes

Question 1

What is a smart pointer in Rust?

A pointer type that implements Deref and Drop traits for automatic resource management

A raw pointer with manual memory management

A function pointer

Smart pointers don't exist in Rust

Question 2

What does Box<T> do?

Allocates value on heap and provides ownership

Shares ownership between multiple pointers

Provides interior mutability

Box doesn't exist

Question 3

What does this Box example do?

rust

let b = Box::new(5);
println!("b = {}", b);

Allocates i32 on heap, automatically dereferences for printing

Compilation error

Allocates on stack

Runtime error

Question 4

When would you use Box<T>?

For large values, recursive data structures, or trait objects

For shared ownership

For interior mutability

Never, it's obsolete

Question 5

What is Rc<T>?

Reference counted smart pointer for single-threaded shared ownership

Atomic reference counting for threads

Box with reference counting

Rc doesn't exist

Question 6

What does this Rc example show?

rust

use std::rc::Rc;
let a = Rc::new(vec![1, 2, 3]);
let b = Rc::clone(&a);
println!("Reference count: {}", Rc::strong_count(&a));

Creates shared ownership, reference count is 2

Compilation error

Reference count is 1

Runtime error

Question 7

What is the difference between Rc::clone() and regular clone()?

Rc::clone() increments reference count, doesn't clone data

They are identical

Rc::clone() clones the data

Rc::clone() doesn't exist

Question 8

What is Arc<T>?

Atomic reference counting for thread-safe shared ownership

Single-threaded reference counting

Box with atomic operations

Arc doesn't exist

Question 9

When would you choose Arc<T> over Rc<T>?

When data needs to be shared across threads

For single-threaded code

When performance is critical

Never, Rc is better

Question 10

What is RefCell<T>?

Provides interior mutability with runtime borrow checking

Provides compile-time borrow checking

Box with mutability

RefCell doesn't exist

Question 11

What does this RefCell example do?

rust

use std::cell::RefCell;
let c = RefCell::new(5);
*c.borrow_mut() = 10;
println!("Value: {}", *c.borrow());

Mutates value through shared reference using runtime checking

Compilation error

Compile-time borrow error

Runtime panic

Question 12

What happens if you violate borrowing rules with RefCell?

Runtime panic occurs

Compilation error

Silent data corruption

Nothing happens

Question 13

What is Weak<T>?

Weak reference that doesn't prevent deallocation

Strong reference

Mutable reference

Weak doesn't exist

Question 14

How do you create a Weak<T> from Rc<T>?

Use Rc::downgrade(&rc) to create Weak pointer

Use Rc::clone() with weak flag

Cast Rc to Weak

Cannot create Weak from Rc

Question 15

What does this Weak example show?

rust

use std::rc::{Rc, Weak};
let strong = Rc::new(5);
let weak = Rc::downgrade(&strong);
if let Some(value) = weak.upgrade() {
    println!("Value: {}", value);
}

Creates weak reference, upgrades to access value if it still exists

Compilation error

Always panics

Runtime error

Question 16

What is a reference cycle?

When Rc pointers reference each other, preventing deallocation

When Box pointers cycle

When Weak pointers cycle

Reference cycles don't exist

Question 17

How do you break reference cycles?

Use Weak<T> for one direction of the reference

Use Box<T>

Use RefCell<T>

Reference cycles cannot be broken

Question 18

What does Deref trait provide?

Automatic dereferencing with * and . operators

Manual dereferencing

Reference counting

Deref doesn't exist

Question 19

What does Drop trait do?

Defines cleanup logic when value goes out of scope

Defines how to drop references

Defines dereferencing

Drop doesn't exist

Question 20

What does this custom Drop example do?

rust

struct CustomSmartPointer {
    data: String,
}

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

Prints message when CustomSmartPointer is deallocated

Compilation error

Prints immediately

Runtime error

Question 21

What is the performance cost of Rc<T>?

Reference count updates on clone/drop

Atomic operations

Heap allocation

No performance cost

Question 22

What is the performance cost of Arc<T>?

Atomic reference count updates, more expensive than Rc

Same as Rc

No atomic operations

Faster than Rc

Question 23

What is the performance cost of RefCell<T>?

Runtime borrow checking overhead

Compile-time checking

No overhead

Significant allocation cost

Question 24

What does Rc<RefCell<T>> allow?

Shared mutable data in single-threaded code

Thread-safe shared data

Immutable shared data

This combination doesn't work

Question 25

What does Arc<Mutex<T>> allow?

Thread-safe shared mutable data

Single-threaded shared data

Immutable shared data

This combination doesn't work

Question 26

What is interior mutability?

Mutating data through shared references

Mutating data through mutable references

Mutating data directly

Interior mutability doesn't exist

Question 27

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

Cell works with Copy types, RefCell works with any type

Cell is thread-safe, RefCell is not

They are identical

Cell doesn't exist

Question 28

What does this Cell example show?

rust

use std::cell::Cell;
let c = Cell::new(5);
c.set(10);
println!("Value: {}", c.get());

Interior mutability for Copy types without borrowing

Compilation error

Runtime borrow error

Runtime error

Question 29

What is a common use case for Box<T>?

Recursive data structures like trees or linked lists

Shared ownership

Thread-safe sharing

Interior mutability

Question 30

What is a common use case for Rc<T>?

Graph data structures with shared nodes

Thread-safe data sharing

Single ownership

Heap allocation only

Question 31

What is a common use case for Arc<T>?

Shared data accessed by multiple threads

Single-threaded sharing

Recursive structures

Interior mutability

Question 32

What is a common use case for RefCell<T>?

Mock objects or caches that mutate through shared references

Thread-safe mutation

Shared ownership

Heap allocation

Question 33

What is a common use case for Weak<T>?

Parent-child relationships where child references parent

Strong ownership

Thread-safe sharing

Interior mutability

Question 34

What happens when Rc strong count reaches zero?

Data is deallocated, Weak references become invalid

Data stays allocated

Program panics

Nothing happens

Question 35

What happens when Arc strong count reaches zero?

Same as Rc - data is deallocated

Data stays allocated due to atomic operations

Different from Rc

Program crashes

Question 36

Can you implement Deref for your own types?

Yes, to make your type behave like a smart pointer

No, only built-in types

Only for Box

Deref cannot be implemented

Question 37

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 38

What does this Deref coercion example show?

rust

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

Deref coercion converts &Box<String> to &String to &str

Compilation error

Manual conversion needed

Runtime error

Question 39

What is the memory layout of Box<T>?

Small pointer on stack, data on heap

Data directly on stack

Data and pointer on heap

Box has no memory layout

Question 40

In a complex application with a tree structure where nodes need to reference their parent, shared configuration across threads, and mutable cached data, which smart pointer combination would you choose and why?

Weak<Rc<Node>> for parent refs, Arc<Config> for shared config, Rc<RefCell<Cache>> for mutable cache

Box for everything to keep it simple

Raw pointers for maximum performance

Avoid smart pointers and use global variables

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 Smart Pointers 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 Are Smart Pointers 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