oop - Rust 等同于 C++ 的虚函数是什么？

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 的函数一起使用，并在另一个类上实现 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

keep some functions undefined

我正在添加隐含的“并且有一些函数调用那个待定义的函数”。

作为E_net4 says , 使用 trait :

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

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

然后您可以为 Base 实现特征:

struct Base {
    stuff: i32,
}

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

作为Matthieu M. says , Rust 没有继承，所以使用组合:

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
    }
}

您也可以通过使用 generic 来结合这两个概念。受类型参数约束。

---

我会强烈支持 Dietrich Epp's point .使用新语言应该涉及检查新范例。以代码重用为目的的继承通常不是一个好主意，即使在支持它的语言中也是如此。相反，创建更小的构建 block 并将它们组合在一起。