Trait objects overview in Rust - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Rust code using a trait object?

Consider the following Rust code that uses a trait object to call a method on different types:

Rust

trait Speak {
    fn speak(&self) -> String;
}

struct Dog;
struct Cat;

impl Speak for Dog {
    fn speak(&self) -> String {
        String::from("Woof")
    }
}

impl Speak for Cat {
    fn speak(&self) -> String {
        String::from("Meow")
    }
}

fn animal_speak(animal: &dyn Speak) {
    println!("{}", animal.speak());
}

fn main() {
    let dog = Dog;
    let cat = Cat;
    animal_speak(&dog);
    animal_speak(&cat);
}

A Woof\nMeow

B Meow\nMeow

C Woof\nWoof

D Meow\nWoof

💡 Hint

Remember that the trait object calls the method implemented for the actual type.

The function animal_speak takes a reference to a trait object &dyn Speak. When called with &dog, it calls Dog's implementation of speak, which returns "Woof". When called with &cat, it calls Cat's implementation, returning "Meow".

🧠 Conceptual

intermediate

What is a key limitation of trait objects in Rust?

Which of the following is a limitation when using trait objects in Rust?

A Trait objects can be copied freely without ownership concerns.

B Trait objects allow storing multiple types without any restrictions.

C Trait objects cannot be used with traits that have generic methods.

D Trait objects require the trait to be implemented only for primitive types.

💡 Hint

Think about what kind of methods can be called through a trait object.

Trait objects use dynamic dispatch and require the trait to be 'object safe'. Traits with generic methods are not object safe and cannot be used as trait objects.

🔧 Debug

advanced

Why does this Rust code fail to compile when using a trait object?

Examine the code below and identify why it fails to compile:

Rust

trait Draw {
    fn draw(&self);
    fn resize<T>(&self, scale: T);
}

struct Circle;

impl Draw for Circle {
    fn draw(&self) {
        println!("Drawing a circle");
    }
    fn resize<T>(&self, scale: T) {
        println!("Resizing circle");
    }
}

fn paint(shape: &dyn Draw) {
    shape.draw();
}

fn main() {
    let c = Circle;
    paint(&c);
}

A The method draw is missing a return type, causing a compilation error.

B The trait Draw is not object safe because it has a generic method, so it cannot be used as a trait object.

C The struct Circle does not implement the Draw trait correctly because it lacks a constructor.

D The function paint requires ownership of the shape, but a reference is provided.

💡 Hint

Check the trait methods and their signatures for object safety rules.

Traits used as trait objects must be object safe. Having a generic method like resize<T> makes the trait not object safe, so &dyn Draw is invalid.

📝 Syntax

advanced

Which option correctly creates a boxed trait object in Rust?

Given the trait Speak and struct Dog implementing it, which code snippet correctly creates a boxed trait object?

Rust

trait Speak {
    fn speak(&self) -> String;
}

struct Dog;

impl Speak for Dog {
    fn speak(&self) -> String {
        String::from("Woof")
    }
}

fn main() {
    // Which line correctly creates a boxed trait object?
}

A let pet: Box<dyn Speak> = Dog::new();

B let pet: Box<Speak> = Box::new(Dog);

C let pet: Box<dyn Speak> = Box::new(&Dog);

D let pet: Box<dyn Speak> = Box::new(Dog);

💡 Hint

Remember the syntax for trait objects and boxing in Rust.

Trait objects require dyn keyword. Box::new(Dog) creates a boxed instance. Option D uses correct syntax. Option D misses dyn. Option D calls a non-existent constructor. Option D boxes a reference, which is not the intended trait object.

🚀 Application

expert

How many items are in the vector after this Rust code runs?

Consider this Rust code that stores different types implementing a trait in a vector of trait objects:

Rust

trait Animal {
    fn name(&self) -> &str;
}

struct Dog;
struct Cat;

impl Animal for Dog {
    fn name(&self) -> &str { "Dog" }
}

impl Animal for Cat {
    fn name(&self) -> &str { "Cat" }
}

fn main() {
    let mut animals: Vec<Box<dyn Animal>> = Vec::new();
    animals.push(Box::new(Dog));
    animals.push(Box::new(Cat));
    animals.push(Box::new(Dog));
    animals.push(Box::new(Cat));
    animals.pop();
    animals.push(Box::new(Dog));
    println!("Number of animals: {}", animals.len());
}

A 4

B 2

C 5

D 3

💡 Hint

Count the pushes and pops carefully to find the final length.

The vector starts empty. It pushes 4 items, then pops 1 (removes last), then pushes 1 more. So total items = 4.