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

不过，您仍然可以简化您正在尝试执行的操作。我冒昧地重命名和更改了你的特征，以便能够提供更全面的例子。

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

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

使用宏

一种解决方案是使用 实现所有这些方法的 ，它实现了所有这些方法。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

另一种解决方案可能是引入第二个特征。然后，如果某个类型实现，则可以使用一揽子实现。HasJobsJobsHasJobs

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

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

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);

使用 和DerefDerefMut

最后，如果始终是 ，那么您可以更改为 a 并使用组合，即 add to（和其他类型）。CustomerPersonPersonstructperson: PersonCustomer

所以首先，：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 来取消对 .因此，所有的方法都可以通过 直接获得。CustomerPersonPersonCustomer

但是，此解决方案仅在您只有一个“特征”时才有效，即您只能 .你也不能.DerefCustomerPersonDerefCustomerSomethingElse

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