Rust 的常量泛型（Const Generics）允许你在泛型中使用常量值作为参数。这一特性在 Rust 1.51 版本中稳定。通过常量泛型，你可以编写更灵活和通用的代码，尤其是在处理数组等固定大小的数据结构时。

一、基本用法

常量泛型允许你将常量值作为泛型参数传递。常量的类型必须是const泛型参数所支持的类型，通常是整数类型（如usize、i32等）。

struct Array<T, const N: usize> {
    data: [T; N],
}

impl<T, const N: usize> Array<T, N> {
    fn new(data: [T; N]) -> Self {
        Array { data }
    }

    fn len(&self) -> usize {
        N
    }
}

fn main() {
    let array = Array::new([1, 2, 3, 4]);
    println!("Array length: {}", array.len()); // 输出: Array length: 4
}

在这个例子中，Array结构体有一个泛型参数T和一个常量泛型参数N，N表示数组的长度。new方法接受一个长度为N的数组，并返回一个Array实例。len方法返回数组的长度，即常量N。

二、常量泛型的限制

1. 常量类型：常量泛型参数的类型必须是usize、i32、u32等整数类型。目前不支持其他类型的常量泛型参数。

2. 常量表达式：常量泛型参数的值必须是编译时常量表达式。你不能使用运行时计算的值作为常量泛型参数。

3. 复杂表达式：常量泛型参数的值可以是简单的字面量，也可以是复杂的常量表达式，但必须能够在编译时求值。

三、常量泛型的应用场景

1. 固定大小的数组：在处理固定大小的数组时，常量泛型非常有用。你可以编写通用的代码来处理不同长度的数组，而不需要为每种长度编写单独的实现。

2. 矩阵和向量：在数学库中，矩阵和向量通常有固定的维度。常量泛型可以帮助你编写通用的矩阵和向量操作代码。

3. 类型级别的计算：常量泛型可以用于类型级别的计算，例如在编译时计算数组的索引或大小。

四、示例：矩阵乘法

struct Matrix<T, const ROWS: usize, const COLS: usize> {
    data: [[T; COLS]; ROWS],
}

impl<T, const ROWS: usize, const COLS: usize> Matrix<T, ROWS, COLS> {
    fn new(data: [[T; COLS]; ROWS]) -> Self {
        Matrix { data }
    }
}

impl<T, const ROWS: usize, const COLS: usize, const OTHER_COLS: usize> 
    Matrix<T, ROWS, COLS> 
where
    T: Copy + Default + std::ops::Mul<Output = T> + std::ops::Add<Output = T>,
{
    fn multiply<U>(&self, other: &Matrix<U, COLS, OTHER_COLS>) -> Matrix<T, ROWS, OTHER_COLS> 
    where
        U: Copy + Default + std::ops::Mul<T, Output = T>,
    {
        let mut result = Matrix {
            data: [[T::default(); OTHER_COLS]; ROWS],
        };

        for i in 0..ROWS {
            for j in 0..OTHER_COLS {
                for k in 0..COLS {
                    result.data[i][j] = result.data[i][j] + self.data[i][k] * other.data[k][j];
                }
            }
        }

        result
    }
}

fn main() {
    let a = Matrix::new([[1, 2, 3], [4, 5, 6]]);
    let b = Matrix::new([[7, 8], [9, 10], [11, 12]]);
    let c = a.multiply(&b);

    println!("{:?}", c.data);
}

在这个例子中，Matrix结构体有两个常量泛型参数ROWS和COLS，分别表示矩阵的行数和列数。multiply方法实现了矩阵乘法，并且可以处理不同大小的矩阵。

五、总结
Rust 的常量泛型为编写通用且类型安全的代码提供了强大的工具。通过使用常量泛型，你可以在编译时处理固定大小的数据结构，减少运行时开销，并提高代码的可重用性。尽管目前常量泛型还有一些限制，但随着 Rust 的发展，这些限制可能会逐渐被解除。