Logo

Developer learning path

News
Rust

Trait Objects in Rust

Introduction to Rust Programming Language
What is Rust? Advantages of Rust History of Rust Installing Rust
Basics of Rust Programming Language
Data Types Variables and Constants Operators Control Flow
Ownership in Rust
What is Ownership? Borrowing and References Slices Memory Management in Rust Garbage Collection in Rust Drop Trait
Functions and Closures in Rust
Defining and Calling Functions Function Parameters and Return Values Closures Higher Order Functions
Structs and Enums in Rust
Structs Defining Structs Tuple Structs Struct Methods Enums Defining Enums Associated Data Enums as Structs
Traits and Generics in Rust
Traits Defining Traits Trait Objects Implementing Traits Generics Defining Generics Trait Bounds Advanced Lifetimes
Concurrency in Rust
What is Concurrency? Threads Creating Threads Communication Between Threads Message Passing Sync and Send Traits Mutexes and Atomic Types Channels
Error Handling in Rust
What are Errors? Panic Result Enum Unwrapping Results Propagating Errors Combinators
Testing and Debugging in Rust
Debugging Rust Code Writing Tests in Rust Unit Tests Integration Tests Running Tests Test Filters Test Options
Advanced Topics in Rust
Unsafe Rust Macros FFI Cargo Rust Standard Library Collections File IO Networking
Rust Applications
Developing Rust Application Rust Web Development Building GUI Applications using Rust
Conclusion
Recap of Rust Programming Language Future of Rust Programming Language.

Trait Objects

57

#description

Trait objects are a fundamental concept in Rust programming that allow for dynamic dispatch of methods. When you specify a trait object, you are actually creating a pointer to an object whose type implements that trait.

In a Rust program, you can define a set of methods using a trait. These methods can then be implemented by any number of different types. When an object that implements the trait is created, it is guaranteed to have all of the methods defined by the trait.

Trait objects allow for a kind of dynamic polymorphism in Rust. Because Rust is a statically typed language, the types of objects are checked at compile time. But with trait objects, the type of an object can be determined at runtime, allowing for runtime polymorphism.

To create a trait object, you would declare your trait as follows:

 
                    
trait MyTrait {
    fn my_method(&self);
}

And then implement the trait for a particular type:

 
                    
struct MyType;

impl MyTrait for MyType {
    fn my_method(&self) {
        println!("This is a method on MyType");
    }
}

Once you've implemented the trait for a type, you can create a trait object that points to any object that implements the trait:

 
                    
fn main() {
    let my_type = MyType;
    let my_trait_object: &dyn MyTrait = &my_type;
    my_trait_object.my_method();
}

In this example, we're creating a trait object that points to my_type. We can then call my_method() on the trait object and it will dynamically dispatch the method to the implementation on MyType.

March 27, 2023

If you don't quite understand a paragraph in the lecture, just click on it and you can ask questions about it.

If you don't understand the whole question, click on the buttons below to get a new version of the explanation, practical examples, or to critique the question itself.