Rust Struct Quiz

0 Passed

0% acceptance

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.

40 Questions

~80 minutes

Question 1

What is a struct in Rust and why are they useful?

A custom data type that groups related values together, allowing you to name and package related data for clarity and reuse

A way to define functions

A replacement for arrays

A way to define constants

Question 2

How do you define a struct with named fields in Rust?

struct StructName { field1: Type1, field2: Type2 }

struct StructName(field1: Type1, field2: Type2)

struct StructName = { field1: Type1, field2: Type2 }

struct StructName [field1: Type1, field2: Type2]

Question 3

How do you create an instance of a struct?

StructName { field1: value1, field2: value2 }

new StructName(field1, field2)

StructName(field1, field2)

StructName::new(field1, field2)

Question 4

What will this struct definition and instantiation create?

rust

struct User {
    username: String,
    email: String,
    sign_in_count: u64,
    active: bool,
}

fn main() {
    let user1 = User {
        email: String::from("[email protected]"),
        username: String::from("someusername123"),
        active: true,
        sign_in_count: 1,
    };
}

A User struct instance with all fields initialized in a different order than defined

Compilation error due to field order mismatch

A User struct with default values for missing fields

Runtime error

Question 5

How do you access fields of a struct instance?

Using dot notation: instance.field_name

Using bracket notation: instance[field_name]

Using arrow notation: instance->field_name

Fields cannot be accessed directly

Question 6

What is a tuple struct and how does it differ from a regular struct?

A struct with unnamed fields accessed by index, useful when field names aren't important

A struct that can be used as a tuple

A tuple that can be used as a struct

There is no difference

Question 7

How do you define a tuple struct?

struct StructName(Type1, Type2, Type3);

struct StructName { field1: Type1, field2: Type2 };

struct StructName = (Type1, Type2);

struct StructName [Type1, Type2];

Question 8

How do you access fields of a tuple struct?

Using dot notation with indices: instance.0, instance.1

Using bracket notation: instance[0], instance[1]

Using field names: instance.field1

Tuple struct fields cannot be accessed

Question 9

What will this tuple struct code output?

rust

struct Color(i32, i32, i32);

fn main() {
    let black = Color(0, 0, 0);
    println!("Black color: ({}, {}, {})", black.0, black.1, black.2);
}

Black color: (0, 0, 0)

Compilation error

Black color: (0, 0, 0

Runtime error

Question 10

How do you implement methods on a struct?

Use impl StructName { fn method_name(&self) { ... } }

Use struct StructName { fn method_name(&self) { ... } }

Methods cannot be implemented on structs

Use class StructName { fn method_name(&self) { ... } }

Question 11

What is the difference between &self, &mut self, and self in method parameters?

&self borrows immutably, &mut self borrows mutably, self takes ownership

&self takes ownership, &mut self borrows immutably

They are all the same

self parameters are not allowed

Question 12

What will this method implementation do?

rust

struct Rectangle {
    width: u32,
    height: u32,
}

impl Rectangle {
    fn area(&self) -> u32 {
        self.width * self.height
    }
}

fn main() {
    let rect = Rectangle { width: 30, height: 50 };
    println!("Area: {}", rect.area());
}

Print 'Area: 1500' by calculating width * height

Compilation error

Print 'Area: 0'

Runtime error

Question 13

How do you implement associated functions (static methods) on a struct?

Use impl StructName { fn function_name() -> Self { ... } } without self parameter

Use static fn in the struct definition

Associated functions cannot be implemented

Use class methods syntax

Question 14

What is a common use case for associated functions?

Creating constructor functions like StructName::new()

Accessing instance fields

Modifying instance data

Associated functions have no common use cases

Question 15

What will this associated function implementation create?

rust

struct Rectangle {
    width: u32,
    height: u32,
}

impl Rectangle {
    fn square(size: u32) -> Rectangle {
        Rectangle { width: size, height: size }
    }
}

fn main() {
    let sq = Rectangle::square(3);
    println!("Square: {}x{}", sq.width, sq.height);
}

A Rectangle instance with width and height both set to 3

Compilation error

A Rectangle with default values

Runtime error

Question 16

How does field ownership work in structs when the struct is moved?

When a struct is moved, ownership of all its fields is transferred

Fields retain their original ownership

Fields are automatically cloned

Fields become invalid

Question 17

What happens when you try to access a field of a moved struct?

Compilation error: value borrowed here after move

The field is still accessible

Runtime error

The field gets a default value

Question 18

How do you modify struct fields when the struct is mutable?

Declare the instance as mut and assign to fields: mut_instance.field = new_value

Use setter methods

Fields cannot be modified

Use the mut keyword on individual fields

Question 19

What will this mutable struct code do?

rust

struct User {
    email: String,
    username: String,
    active: bool,
}

fn main() {
    let mut user1 = User {
        email: String::from("[email protected]"),
        username: String::from("someusername123"),
        active: true,
    };
    user1.email = String::from("[email protected]");
    println!("New email: {}", user1.email);
}

Print 'New email: [email protected]'

Compilation error

Print the original email

Runtime error

Question 20

How do you create a struct with some fields from another struct instance?

Use struct update syntax: StructName { field: value, ..existing_instance }

Copy the struct and modify fields

Use inheritance

This is not possible

Question 21

What will this struct update syntax create?

rust

struct User {
    username: String,
    email: String,
    sign_in_count: u64,
    active: bool,
}

fn main() {
    let user1 = User {
        email: String::from("[email protected]"),
        username: String::from("someusername123"),
        active: true,
        sign_in_count: 1,
    };
    let user2 = User {
        email: String::from("[email protected]"),
        ..user1
    };
    println!("User2 active: {}", user2.active);
}

Print 'User2 active: true' with other fields copied from user1

Compilation error

Print 'User2 active: false'

Runtime error

Question 22

How do you destructure a struct in a let binding?

Use let StructName { field1, field2 } = instance;

Use let (field1, field2) = instance;

Use let [field1, field2] = instance;

Structs cannot be destructured

Question 23

What will this struct destructuring do?

rust

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

fn main() {
    let p = Point { x: 0, y: 7 };
    let Point { x, y } = p;
    println!("x: {}, y: {}", x, y);
}

Print 'x: 0, y: 7' by extracting fields into variables

Compilation error

Print 'x: 0, y: 0'

Runtime error

Question 24

How do you implement the Debug trait for a struct to enable println! formatting?

Use #[derive(Debug)] above the struct definition

Implement Debug manually with fmt method

Both A and B are valid

Debug cannot be implemented for structs

Question 25

What is the difference between tuple structs and regular structs?

Tuple structs have unnamed fields, regular structs have named fields

Tuple structs are immutable, regular structs are mutable

Tuple structs use less memory

There is no functional difference

Question 26

When should you use tuple structs instead of named field structs?

When you want to give a tuple a specific name but don't need named fields

When performance is critical

When you need inheritance

Tuple structs should never be used

Question 27

How do you handle structs with many fields in function parameters?

Pass references &StructName to avoid moving large structs

Pass by value since structs are small

Use global variables

Split the struct into smaller structs

Question 28

What is the unit-like struct and when is it useful?

A struct with no fields: struct UnitStruct; useful for implementing traits on types

A struct with one field

A struct that behaves like a unit type

Unit-like structs are not useful

Question 29

How do you implement the Display trait for custom formatting?

Implement fmt method in impl Display for StructName block

Use #[derive(Display)]

Display is automatically implemented

Use println! formatting

Question 30

What will this Display implementation do?

rust

use std::fmt;

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

impl fmt::Display for Point {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "({}, {})", self.x, self.y)
    }
}

fn main() {
    let p = Point { x: 3, y: 4 };
    println!("{}", p);
}

Print '(3, 4)' using the custom Display implementation

Compilation error

Print the debug representation

Runtime error

Question 31

How do you create methods that modify struct fields?

Use &mut self parameter to borrow mutably and modify fields

Use &self and return a new instance

Methods cannot modify fields

Use self parameter to take ownership

Question 32

What is the difference between methods and associated functions?

Methods take self parameter and operate on instances, associated functions don't take self and are called on the type

Associated functions take self, methods don't

They are identical

Methods are static, associated functions are instance methods

Question 33

How do you implement getter and setter methods for struct fields?

Getters return &field, setters take &mut self and new_value parameter

Use automatic getter/setter generation

Getters and setters are not idiomatic in Rust

Use public fields instead

Question 34

What happens to struct field ownership when implementing Drop trait?

Drop implementation controls cleanup of owned fields when the struct goes out of scope

Fields are automatically cleaned up

Drop has no effect on field ownership

Fields lose their ownership

Question 35

How do you handle structs containing references?

Use lifetimes to ensure referenced data outlives the struct

References cannot be stored in structs

Use Rc for reference counting

Use raw pointers

Question 36

What is struct field visibility and how does it work?

Fields are private by default, can be made public with pub keyword

All fields are public by default

Fields inherit struct visibility

Field visibility cannot be controlled

Question 37

How do you create a struct with borrowed fields?

struct StructName<'a> { field: &'a Type } using lifetime parameters

struct StructName { field: &Type }

Borrowed fields are not allowed

Use Rc<Type> for borrowed data

Question 38

What is the builder pattern and how is it implemented with structs?

A pattern using method chaining to construct complex structs, with each method returning Self

A pattern using inheritance for struct construction

A pattern using macros for struct creation

The builder pattern is not used in Rust

Question 39

How do you implement Clone trait for a struct?

Use #[derive(Clone)] for automatic implementation or manual impl Clone

Clone is automatically implemented

Use copy() method

Clone cannot be implemented for structs

Question 40

In a complex application managing user profiles with multiple optional fields, how would you design the user struct to handle missing data gracefully?

Use Option<T> for optional fields: struct User { name: String, email: Option<String>, phone: Option<String> }

Use nullable types or default values

Use separate structs for different user types

Use a HashMap for all user data

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

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 Struct 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

About This Structs Quiz

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