Rust for C-Programmers

2.11 Traits: Shared Behavior

Traits define a set of methods that a type must implement, serving a purpose similar to interfaces in other languages or abstract base classes in C++. They are fundamental to Rust’s approach to abstraction and code reuse, allowing different types to share common functionality.

2.11.1 Defining a Trait

A trait is defined using the trait keyword, followed by the trait name and a block containing the signatures of the methods that implementing types must provide.

// Define a trait named 'Drawable'
trait Drawable {
    // Method signature: takes an immutable reference to self, returns nothing
    fn draw(&self);
}

2.11.2 Implementing a Trait

Types implement traits using an impl Trait for Type block, providing concrete implementations for the methods defined in the trait.

// Define a simple struct
struct Circle;

// Implement the 'Drawable' trait for the 'Circle' struct
impl Drawable for Circle {
    // Provide the concrete implementation for the 'draw' method
    fn draw(&self) {
        println!("Drawing a circle");
    }
}

2.11.3 Using Trait Methods

Once a type implements a trait, you can call the trait’s methods on instances of that type.

// Definitions needed for the example to run
trait Drawable {
    fn draw(&self);
}
struct Circle;
impl Drawable for Circle {
    fn draw(&self) {
        println!("Drawing a circle");
    }
}
fn main() {
    let shape1 = Circle;
    // Call the 'draw' method defined by the 'Drawable' trait
    shape1.draw(); // Output: Drawing a circle
}

2.11.4 Comparison with C

C lacks a direct equivalent to traits. Achieving similar polymorphism typically involves using function pointers, often grouped within structs (sometimes referred to as “vtables”). This approach requires manual setup and management, lacks the compile-time verification provided by Rust’s trait system, and can be more error-prone. Rust’s traits provide a safer, more integrated way to define and use shared behavior across different types.