如何在Rust中实现类似继承特性，且父级定义构造函数？

空枚举方案的本质问题 #

你用空枚举的思路走不通，核心原因是空枚举（比如enum A {}）没有任何变体，无法创建实例。Rust不允许直接写出Self来构造空枚举的实例——这种类型从根本上就不存在合法的值，所以struct_type: Self这行代码必然编译失败，这个方案本身不可行。

可行替代：用单元结构体作为标记类型 #

既然需要一个“标记”类型区分不同实现，同时能创建实例，用**单元结构体（Unit Struct）**代替空枚举是最合适的选择。单元结构体（比如struct A;）是零大小类型，不占用内存空间，和空枚举的定位一致，但它可以被实例化，完美解决你的问题。

修复后的完整代码如下：

trait SomeType {
    fn new() -> SomeStruct<Self> where Self: Sized {
        SomeStruct {
            struct_type: Self,
            some_value: 1,
        }
    }

    fn foo(&self) -> i32;
}

struct SomeStruct<T> {
    struct_type: T,
    some_value: i32,
}

// 用单元结构体替代空枚举
struct A;
impl SomeType for A {
    fn foo(&self) -> i32 { 1 }
}

struct B;
impl SomeType for B {
    fn foo(&self) -> i32 { 2 }
}

struct C;
impl SomeType for C {
    fn foo(&self) -> i32 { 3 }
}

impl<T> SomeStruct<T> {
    fn bar(&self) -> i32 where T: SomeType {
        self.some_value + self.struct_type.foo()
    }
}

fn main() {
    let a = A::new();
    let b = B::new();
    let c = C::new();
    println!("{}", a.bar() + b.bar() + c.bar()); // 输出：9
}

方案生效的原因 #

• 单元结构体A;可以直接实例化，所以Self在这里是合法的（A的实例就是A本身）。
• 单元结构体是零大小类型，编译时会被优化掉，不会带来额外内存开销。
• 保留了你想要的泛型构造函数new，不需要为每个标记类型重复实现构造逻辑，核心逻辑集中在SomeStruct和SomeType trait中，和你Python代码的继承模式逻辑对齐。

另一种思路：不存储标记类型 #

如果你不想在SomeStruct里存储标记类型，也可以把bar方法移到SomeType trait中，用关联常量或实例字段实现：

trait SomeType {
    fn new() -> Self where Self: Sized;
    fn foo(&self) -> i32;
    fn bar(&self) -> i32 {
        // 可以把some_value作为trait的关联常量或者实例字段
        1 + self.foo()
    }
}

struct A {
    some_value: i32,
}

impl SomeType for A {
    fn new() -> Self {
        A { some_value: 1 }
    }
    fn foo(&self) -> i32 { 1 }
}

// B、C的实现类似...

fn main() {
    let a = A::new();
    println!("{}", a.bar());
}

这种方式更偏向Rust的trait多态模式，和你最初的泛型结构体思路略有不同，但同样避免了重复代码。

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