什么是等价于C语言虚函数的Rust？

Question

我试图在Rust中实现一些类似于类中的C虚拟函数的东西，我会有一个带有数据的基本结构，然后我会保留一些未定义的函数，如以下示例：

class A {
    int stuff;
public:
    virtual void foo(int a, int b) = 0;
    void function_that_calls_foo() { /*...*/ foo(1, 2); /*...*/ }
}

class B: public A { void foo(int a, int b) { /* ... */ } }

我试图用函数指针来实现它，但是没有成功。我可以在A的函数中使用trait，并在另一个类中实现A，但是我会丢失结构的数据。什么最好(最快？)Rust中实现这种东西的方式？

struct A {
    ...
}

impl A {
    fn function_that_calls_foo(&self) {
        ...
        self.foo(a, b);
        ...
    }
}

struct B {
    a: A;
}

impl B {
    fn xxx(&self) {
        a.function_that_calls_foo(1, 2);
    }

    fn foo(&self, a: i32, b: i32) {...}
}

Answer 1

保持某些函数未定义

我正在添加隐式的“并有一些调用该待定义函数的函数”。

正如E_net4所说，使用trait：

trait Foo {
    fn foo(&self, a: i32, b: i32) -> i32;

    fn function_that_calls_foo(&self) {
        println!("{}", self.foo(1, 2));
    }
}

然后，您可以为< code>Base实现trait:

struct Base {
    stuff: i32,
}

impl Foo for Base {
    fn foo(&self, a: i32, b: i32) -> i32 {
        self.stuff + a + b
    }
}

正如Matthieu M.所说，锈菌没有遗传性，所以使用组合：

struct Base {
    stuff: i32,
}

impl Base {
    fn reusable(&self) -> i32 {
        self.stuff + 1
    }
}

struct Alpha {
    base: Base,
    modifier: i32,
}

impl Foo for Alpha {
    fn foo(&self, a: i32, b: i32) -> i32 {
        (self.base.reusable() + a + b) * self.modifier
    }
}

通过采用受类型参数约束的泛型，也可以组合这两个概念。

我强烈支持迪特里希·埃普的观点。使用一种新的语言应该包括检查新的范例。为了代码重用而继承通常不是一个好主意，即使在支持它的语言中也是如此。相反，创建较小的构建块并将它们组合在一起。