具有默认实现和所需结构成员的特性

Question

我有一个 rust 特征，它应该为向量添加一个值。为了使add_job函数正常工作，必须确保在为具体结构实现特征时向量存在。

以下代码当然失败了，因为从未实现过作业。它只是为了证明我的意图：

trait Person {
    // default implementation of add job
    fn add_job(&self, job: String) {
        self.jobs.push(job)
    }
}

struct Customer {
    // add_job is used as default implementation 
    // provided by trait
}

impl Person for Customer {
    // some stuff
}

fn main() {
    let mut george = Customer {};
    george.add_job("programmer".to_string());
}

有没有办法让特征也提供结构成员？

可能不是，但是解决上述问题的“生锈”方法是什么？

Answer 1

Traits 不能提供或要求结构字段。尽管有一个RFC (#1546) 是关于在特征中允许字段的。但是，没有任何不稳定的功能允许这样做（还？）。

不过，您仍然可以简化您正在尝试做的事情。我冒昧地重命名和更改您的特征，以便能够提供更全面的示例。

让我们考虑一下我们有一个Jobs特质。其中定义了各种方法，这些方法都需要该jobs: Vec<String>字段。

trait Jobs {
    fn add_job(&mut self, job: String);
    fn clear_jobs(&mut self);
    fn count_jobs(&self) -> usize;
}

使用宏

一种解决方案可能是使用 a macro，它实现了所有这些方法。

macro_rules! impl_jobs_with_field {
    ($($t:ty),+ $(,)?) => ($(
        impl Jobs for $t {
            fn add_job(&mut self, job: String) {
                self.jobs.push(job);
            }

            fn clear_jobs(&mut self) {
                self.jobs.clear();
            }

            fn count_jobs(&self) -> usize {
                self.jobs.len()
            }
        }
    )+)
}

然后，您可以通过使用宏轻松地重用代码。

struct Person {
    jobs: Vec<String>,
}

struct Customer {
    jobs: Vec<String>,
}

impl_jobs_with_field!(Person);
impl_jobs_with_field!(Customer);
// or
impl_jobs_with_field!(Person, Customer);

使用第二个HasJobs特征

另一种解决方案可能是引入第二个HasJobs特征。然后，您可以对if 类型实现使用全面Jobs实现HasJobs。

trait HasJobs {
    fn jobs(&self) -> &[String];
    fn jobs_mut(&mut self) -> &mut Vec<String>;
}

impl<T: HasJobs> Jobs for T {
    fn add_job(&mut self, job: String) {
        self.jobs_mut().push(job);
    }

    fn clear_jobs(&mut self) {
        self.jobs_mut().clear();
    }

    fn count_jobs(&self) -> usize {
        self.jobs().len()
    }
}

现在HasJobs仍然需要为您的所有类型实现。但是如果Jobs有大量的方法。那么实施HasJobs就容易多了。我们也可以使用宏来做到这一点：

macro_rules! impl_has_jobs {
    ($($t:ty),+ $(,)?) => ($(
        impl HasJobs for $t {
            fn jobs(&self) -> &[String] {
                &self.jobs
            }

            fn jobs_mut(&mut self) -> &mut Vec<String> {
                &mut self.jobs
            }
        }
    )+)
}

然后再一次，您只需执行以下操作：

struct Person {
    jobs: Vec<String>,
}

struct Customer {
    jobs: Vec<String>,
}

impl_has_jobs!(Person);
impl_has_jobs!(Customer);
// or
impl_has_jobs!(Person, Customer);

使用Deref和DerefMut

最后，如果Customer总是 a Person，那么您可以更改Person为 astruct并使用组合，即添加person: Person到Customer（和其他类型）。

所以首先，impl Jobs for Person：

struct Person {
    jobs: Vec<String>,
}

impl Jobs for Person {
    fn add_job(&mut self, job: String) {
        self.jobs.push(job);
    }

    fn clear_jobs(&mut self) {
        self.jobs.clear();
    }

    fn count_jobs(&self) -> usize {
        self.jobs.len()
    }
}

然后现在您可以使用Deref和DerefMut取消Customer对Person. 因此所有Person的方法都可以直接通过Customer.

然而，这种解决方案只适用，如果你只有一个“特点”，即你只能Deref Customer到Person。你不会是能够也Deref Customer到SomethingElse。

use std::ops::{Deref, DerefMut};

struct Customer {
    person: Person,
}

impl Deref for Customer {
    type Target = Person;

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

impl DerefMut for Customer {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.person
    }
}