如何要求泛型类型的引用实现trait？解决矩阵乘法编译错误

你遇到的问题本质是泛型约束只覆盖了T本身，但代码中实际使用的是&T的乘法操作，而Rust默认不会为所有实现了Mul的T自动推导&T的Mul实现（虽然很多标准库类型有这个实现，但泛型代码必须显式声明约束）。

先看你的原始代码和错误：

原始代码 #

extern crate num_bigint;
extern crate num_traits;

use num_traits::identities::Zero;
use std::ops::{AddAssign, Mul};

#[derive(Debug, Clone)]
struct Matrix<T> {
    n: usize,
    m: usize,
    data: Vec<Vec<T>>,
}

fn m_prd<T>(a: &Matrix<T>, b: &Matrix<T>) -> Matrix<T>
where
    T: Clone + AddAssign + Mul<Output = T> + Zero,
{
    let n = a.n;
    let p = b.n;
    let m = b.m;

    let mut c = Matrix {
        n: n,
        m: m,
        data: vec![vec![T::zero(); m]; n],
    };

    for i in 0..n {
        for j in 0..m {
            for k in 0..p {
                c.data[i][j] += &a.data[i][k] * &b.data[k][j];
            }
        }
    }

    c
}

fn main() {}

错误信息 #

error[E0369]: binary operation `*` cannot be applied to type `&T`
 --> src/main.rs:29:33
 |
29 | c.data[i][j] += &a.data[i][k] * &b.data[k][j];
 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 |
 = note: an implementation of `std::ops::Mul` might be missing for `&T`

问题分析 #

代码中&a.data[i][k] * &b.data[k][j]是对T的引用执行乘法，但你的where约束只要求T: Mul<Output = T>——这只保证了值类型T之间可以相乘，并没有保证引用类型&T之间可以相乘，也没有指定相乘的结果类型是否能被AddAssign接受。

解决方案 #

我们需要补充对引用类型的泛型约束，同时调整AddAssign的约束以匹配乘法结果类型。有两种常用方式：

方式1：显式约束引用类型的乘法（推荐，性能更优）

修改m_prd函数的where子句，添加对任意生命周期的&T的乘法约束，同时明确AddAssign的参数类型：

fn m_prd<T>(a: &Matrix<T>, b: &Matrix<T>) -> Matrix<T>
where
    T: Clone + AddAssign<T> + Zero,
    // 约束任意生命周期的&T可以和&T相乘，结果为T
    for<'a> &'a T: Mul<&'a T, Output = T>,
{
    let n = a.n;
    let p = b.n;
    let m = b.m;

    let mut c = Matrix {
        n: n,
        m: m,
        data: vec![vec![T::zero(); m]; n],
    };

    for i in 0..n {
        for j in 0..m {
            for k in 0..p {
                c.data[i][j] += &a.data[i][k] * &b.data[k][j];
            }
        }
    }

    c
}

这个约束for<'a> &'a T: Mul<&'a T, Output = T>表示：对于任意生命周期'a，&'a T类型可以和另一个&'a T相乘，结果是T类型，刚好能被T: AddAssign<T>接受。

方式2：克隆值避免引用操作（更简单，但有克隆开销）

如果不想处理引用的泛型约束，可以直接克隆矩阵中的值，使用T本身的乘法：

fn m_prd<T>(a: &Matrix<T>, b: &Matrix<T>) -> Matrix<T>
where
    T: Clone + AddAssign + Mul<Output = T> + Zero,
{
    let n = a.n;
    let p = b.n;
    let m = b.m;

    let mut c = Matrix {
        n: n,
        m: m,
        data: vec![vec![T::zero(); m]; n],
    };

    for i in 0..n {
        for j in 0..m {
            for k in 0..p {
                // 克隆值后使用T的乘法
                c.data[i][j] += a.data[i][k].clone() * b.data[k][j].clone();
            }
        }
    }

    c
}

这种方式不需要修改约束，但对于大类型（比如BigInt）或大矩阵，克隆会带来额外的性能开销，所以更推荐第一种方式。

验证兼容性 #

修改后的代码可以同时支持原生类型（如i32、f64）和num_bigint中的BigInt/BigUint，因为这些类型都满足我们添加的引用乘法约束。

内容的提问来源于stack exchange，提问作者Gong-Yi Liao