时间戳

首页 > 解决方案 > 具有默认实现和所需结构成员的特征

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

有没有办法拥有一个也提供结构成员的特征？

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

标签： rusttraits

解决方案

特征不能提供或要求结构字段。虽然有一个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特征。然后，如果类型实现，您可以使用一揽子实现。JobsHasJobs

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

然后现在您可以使用andDeref取消DerefMut引用Customer. Person因此 allPerson的方法都可以直接通过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
    }
}

推荐阅读