Rust结构体嵌套的方法复用问题及动态绑定实现咨询

问题背景 #

我有C++开发背景，刚接触Rust。为理解继承背后的代码复用目的，我编写了如下代码：

/* in animal.rs */
//declare Animal here
pub struct Animal;

// implement Animal here
impl Animal
{
    pub fn breathe(&self)
    {
        println!("All animals breathe!");
    }
}

// declare Dog here
pub struct Dog 
{
    pub parent: Animal
}

// implement Dog here
impl Dog
{
    pub fn bark(&self)
    {
        println!("Dogs bark!");
    }
    pub fn breathe(&self)
    {
        self.parent.breathe();
    }
}

/* in main.rs */
mod animal;

fn main() 
{
    let d = animal::Dog {parent : animal::Animal};
    d.bark();
    d.breathe();
}

如果不在Dog中实现breathe函数，编译器就无法找到该方法。而在C++中子类会继承父类的函数，请问这是为什么？

额外问题：能否展示示例代码说明Rust中如何实现动态/晚期绑定？在C++中这是通过virtual函数实现的。

问题解答 #

1. 为什么Rust不会自动继承成员结构体的方法？ #

Rust没有类继承体系，它采用**组合（Composition）**而非继承来实现代码复用。你的代码里Dog只是嵌套了Animal字段，这是普通的结构体组合，并非C++的子类继承关系。

C++中继承是核心特性，编译器会自动为子类生成父类方法的调用逻辑；但Rust强调显式性——结构体不会自动拥有其内部字段的方法。如果想让Dog调用Animal的breathe，要么像你那样显式实现转发方法，要么利用Deref trait实现自动解引用：

/* in animal.rs */
use std::ops::Deref;

pub struct Animal;

impl Animal {
    pub fn breathe(&self) {
        println!("All animals breathe!");
    }
}

pub struct Dog {
    pub parent: Animal,
}

impl Deref for Dog {
    type Target = Animal;

    fn deref(&self) -> &Self::Target {
        &self.parent
    }
}

impl Dog {
    pub fn bark(&self) {
        println!("Dogs bark!");
    }
}

/* in main.rs */
mod animal;

fn main() {
    let d = animal::Dog { parent: animal::Animal };
    d.bark();
    // Deref自动将&Dog转为&Animal，可直接调用breathe
    d.breathe();
}

注意：Deref主要用于智能指针语义，虽能模拟类似继承的调用，但并非为替代继承设计，使用时需符合其语义。

2. Rust中的动态绑定实现 #

Rust通过**Trait对象（Trait Object）**结合dyn关键字实现动态绑定，对应C++的虚函数机制。步骤是：定义包含方法的trait，让不同类型实现该trait，再通过dyn Trait的引用/指针实现运行时动态分派。

示例代码：

// 定义Animal trait，等价于C++带虚函数的抽象基类
trait Animal {
    // 无默认实现的方法，必须由具体类型实现（类似纯虚函数）
    fn breathe(&self);
    // 带默认实现的方法（类似普通虚函数）
    fn speak(&self) {
        println!("This animal makes a sound");
    }
}

// Dog实现Animal trait
struct Dog;
impl Animal for Dog {
    fn breathe(&self) {
        println!("Dog breathes through nose");
    }

    fn speak(&self) {
        println!("Woof!");
    }
}

// Cat实现Animal trait
struct Cat;
impl Animal for Cat {
    fn breathe(&self) {
        println!("Cat breathes through nose");
    }

    fn speak(&self) {
        println!("Meow!");
    }
}

// 接受dyn Animal引用的函数，实现动态绑定
fn interact_with_animal(animal: &dyn Animal) {
    animal.speak();
    animal.breathe();
}

fn main() {
    let dog = Dog;
    let cat = Cat;

    // 运行时根据实际类型调用对应方法
    interact_with_animal(&dog);
    interact_with_animal(&cat);
}

&dyn Animal是 trait 对象，包含实际类型指针和虚表（vtable）指针，运行时通过虚表查找对应方法，和C++虚函数机制本质一致。

内容的提问来源于Stack Exchange，提问作者Soumyajit Roy