Generic structs in Rust

Introduction

Generic structs let you create flexible data containers that can hold any type of data. This helps you reuse code without repeating it for each data type.

When you want a struct to work with different types of data without rewriting it.

When you have a collection or container that can hold various data types.

When you want to write functions or methods that work with many types inside a struct.

When you want to keep your code clean and avoid duplication for similar structs with different types.

Syntax

Rust

struct StructName<T> {
    field: T,
}

The <T> after the struct name means it uses a generic type called T.

You can use any name instead of T, but T is common and stands for 'Type'.

Examples

A struct Point that can hold any type for x and y.

Rust

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

A struct with two different generic types T and U.

Rust

struct Pair<T, U> {
    first: T,
    second: U,
}

Creating a Point with integers.

Rust

let int_point = Point { x: 5, y: 10 };

Creating a Point with floating-point numbers.

Rust

let float_point = Point { x: 1.2, y: 3.4 };

Sample Program

This program creates two Point structs with different types: integers and floats. It then prints their values.

Rust

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

fn main() {
    let int_point = Point { x: 5, y: 10 };
    let float_point = Point { x: 1.2, y: 3.4 };

    println!("int_point: x = {}, y = {}", int_point.x, int_point.y);
    println!("float_point: x = {}, y = {}", float_point.x, float_point.y);
}

Important Notes

Generic structs help avoid writing many similar structs for different types.

You can add methods to generic structs using impl<T> StructName<T>.

Rust checks types at compile time, so using generics is safe and efficient.

Summary

Generic structs let you create flexible containers for any data type.

Use <T> after the struct name to define a generic type.

They help keep your code clean and reusable.