Rust for C-Programmers

9.8 Generic Structs

Generics enable creating structs that work with multiple types without duplicating code. In the previous chapter, we discussed generic functions, which allow defining functions that operate on multiple types while maintaining type safety. Rust extends this concept to structs, enabling them to store values of a generic type.

#![allow(unused)]
fn main() {
struct Point<T> {
    x: T,
    y: T,
}
}

9.8.1 Instantiating Generic Structs

You specify the concrete type when creating an instance:

struct Point<T> {
    x: T,
    y: T,
}

fn main() {
    let integer_point = Point { x: 5, y: 10 };
    let float_point = Point { x: 1.0, y: 4.0 };
}

9.8.2 Restricting Allowed Types

By default, a generic struct can accept any type. However, it is often useful to restrict the allowed types using trait bounds. For example, if we want our Point<T> type to support vector-like addition, we can require that T implements std::ops::Add<Output = T>. Then we can define a method to add one Point<T> to another:

use std::ops::Add;

#[derive(Debug)]
struct Point<T> {
    x: T,
    y: T,
}

impl<T: Add<Output = T> + Copy> Point<T> {
    fn add_point(&self, other: &Point<T>) -> Point<T> {
        Point {
            x: self.x + other.x,
            y: self.y + other.y,
        }
    }
}

fn main() {
    let p1 = Point { x: 3, y: 7 };
    let p2 = Point { x: 1, y: 2 };
    let p_sum = p1.add_point(&p2);
    println!("Summed point: {:?}", p_sum);
}

Here, any type T we plug into Point<T> must implement both Add<Output = T> (to allow addition on the fields) and Copy (so we can safely clone the values during addition). This ensures that the add_point method works for numeric types without requiring an explicit clone or reference-lifetime juggling.

You can further expand these constraints—for instance, if you need floating-point math for operations like calculating magnitudes or distances, you might require T: Add<Output = T> + Copy + Into<f64> or similar. The main idea is that trait bounds let you precisely specify what a generic type must be able to do.

9.8.3 Methods on Generic Structs

Generic structs can have methods that apply to every valid type substitution:

impl<T> Point<T> {
    fn x(&self) -> &T {
        &self.x
    }
}