如何在Rust中为多个结构体实现trait时避免重复代码？

Rust没有Java那样的类继承机制，但可以通过组合+Trait默认实现或者宏自动生成代码来解决你遇到的重复实现问题，以下是具体方案：

方案一：Trait默认实现 + 组合（推荐） #

核心思路就是让Trait的大部分方法提供默认实现，默认实现里直接委托给内部的BaseA实例，同时要求实现Trait的类型必须能返回BaseA的引用。这样每个结构体只需要实现少数自定义方法，以及返回BaseA的方法就行。

示例代码：

trait A {
    // 要求所有实现该Trait的类型必须提供BaseA的引用
    fn base(&self) -> &BaseA;

    // 所有方法默认委托给BaseA的实现
    fn method1(&self) {
        self.base().method1()
    }

    fn method2(&self) {
        self.base().method2()
    }

    // ... 以此类推，把method3到method100都写成默认委托的形式
}

struct BaseA {}
impl A for BaseA {
    fn base(&self) -> &BaseA {
        self
    }

    fn method1(&self) {
        println!("i am BaseA 1");
    }

    fn method2(&self) {
        println!("i am BaseA 2");
    }

    // ... 这里实现method3到method100的具体逻辑
}

struct B {
    base: BaseA,
}

impl A for B {
    fn base(&self) -> &BaseA {
        &self.base
    }
    // 不需要写任何其他方法，全部用Trait的默认实现
}

struct C {
    base: BaseA,
}

impl A for C {
    fn base(&self) -> &BaseA {
        &self.base
    }

    // 只重写需要自定义的方法，其余自动用BaseA的逻辑
    fn method1(&self) {
        println!("i am C 1");
    }
}

这个方案完全避免了重复代码，每个结构体只需要写两行代码（实现base()）加上少数自定义方法，其余100个方法自动复用BaseA的逻辑。

方案二：用宏自动生成实现代码 #

如果你的Trait无法修改（比如是第三方库的Trait），或者有特殊逻辑不适合用默认实现，可以写一个宏来帮你自动生成委托代码——只需要指定要重写的方法，其余方法自动委托给内部的base字段。

要是方法数量真的到100个，用过程宏（类似#[derive]那种）会更方便，不过这里先给一个简易的声明宏思路：

// 定义宏，自动生成A的实现，参数是结构体名和要重写的方法列表
macro_rules! impl_A {
    ($struct:ident, [$($override_method:ident),*]) => {
        impl A for $struct {
            // 先生成所有要重写的方法
            $(
                fn $override_method(&self) {
                    println!("i am {} {}", stringify!($struct), stringify!($override_method));
                }
            )*

            // 生成其余方法的委托逻辑（这里以method1和method2为例，可扩展到100个）
            fn method1(&self) {
                $(if stringify!($override_method) == "method1" {
                    return;
                })*
                self.base.method1()
            }

            fn method2(&self) {
                $(if stringify!($override_method) == "method2" {
                    return;
                })*
                self.base.method2()
            }

            // ... 扩展到method3到method100
        }
    };
}

// 使用宏为C实现A，只重写method1
impl_A!(C, [method1]);

过程宏的实现会更灵活，能自动遍历所有Trait方法，不过编写过程宏需要用到proc-macro2等 crate，适合复杂场景。

关于Rust不支持继承的说明 #

Rust设计上更推崇组合优于继承，继承容易导致复杂的层级耦合和菱形继承问题，而组合能更清晰地表达依赖关系，同时保持代码的灵活性。上面的方案就是组合思想的典型应用——通过将BaseA作为结构体的内部字段，复用其逻辑，同时避免了继承的弊端。

内容的提问来源于stack exchange，提问作者Jack_Du