Возможно ли, чтобы одна структура расширила существующую структуру, сохранив все поля?

Ответ 1

Нет ничего, что бы точно соответствовало этому. Есть два понятия, которые приходят на ум.

• Структурная композиция

  struct Person {
      age: u8,
  }
  
  struct Child {
      person: Person,
      has_toy: bool,
  }
  
  impl Person {
      fn new(age: u8) -> Self {
          Person { age: age }
      }
  
      fn age(&self) -> u8 {
          self.age
      }
  }
  
  impl Child {
      fn new(age: u8, has_toy: bool) -> Self {
          Child { person: Person::new(age), has_toy: has_toy }
      }
  
      fn age(&self) -> u8 {
          self.person.age()
      }
  }
  
  fn main() {
      let p = Person::new(42);
      let c = Child::new(7, true);
  
      println!("I am {}", p.age());
      println!("My child is {}", c.age());
  }
  

  Вы можете просто вставить одну структуру в другую. Макет памяти хорош и компактен, но вы должны вручную делегировать все методы от Person до Child или одолжить &Person.

• Черты характера

  trait SayHi {
      fn say_hi(&self);
  }
  
  struct Person {
      age: u8,
  }
  
  struct Child {
      age: u8,
      has_toy: bool,
  }
  
  impl SayHi for Person {
      fn say_hi(&self) {
          println!("Greetings. I am {}", self.age)
      }
  }
  
  impl SayHi for Child {
      fn say_hi(&self) {
          if self.has_toy {
              println!("I'm only {}, but I have a toy!", self.age)
          } else {
              println!("I'm only {}, and I don't even have a toy!", self.age)
          }
      }
  }
  
  fn greet<T>(thing: T)
      where T: SayHi
  {
      thing.say_hi()
  }
  
  fn main() {
      let p = Person { age: 42 };
      let c = Child { age: 7, has_toy: true };
  
      greet(p);
      greet(c);
  }
  

Вы можете объединить эти две концепции, конечно.

Как DK. упоминает, вы можете выбрать Deref или DerefMut. Однако я не согласен с тем, что эти черты должны использоваться таким образом. Мой аргумент сродни аргументу о том, что использование классического объектно-ориентированного наследования просто для повторного использования кода - это неправильная вещь. "Использовать композицию над наследованием" = > "одобрить композицию над Deref". Тем не менее, я действительно надеюсь на языковую функцию, которая позволяет лаконичную делегацию, уменьшая раздражение композиции.

Ответ 2

Rust не имеет наследования структуры любого типа. Если вы хотите, чтобы StructB содержал те же поля, что и StructA, вам нужно использовать композицию.

struct StructB {
    a: StructA,
    // other fields...
}

Кроме того, чтобы уточнить, черты могут определять только методы и связанные с ними типы; они не могут определять поля.

Если вы хотите использовать StructB как StructA, вы можете получить часть этого пути, выполнив Deref и DerefMut, что позволит компилятору непрямо указывать указатели на StructB на указатели на StructA s:

struct StructA;

impl StructA {
    fn name(&self) -> &'static str {
        "Anna"
    }
}

struct StructB {
    a: StructA, 
    // other fields...
}

impl std::ops::Deref for StructB {
    type Target = StructA;
    fn deref(&self) -> &Self::Target {
        &self.a
    }
}

fn main() {
    let b = StructB { a: StructA };
    println!("{}", b.name());
}

Ответ 3

Реализация Deref для умных указателей, которые мы можем получить доступ к данным позади, вроде как наследовать.

struct Person {
  gender: &'static str,
  age:    &'static i32
}

struct Child(Person);

impl std::ops::Deref for Child {
  type Target = Person;
  fn deref(&self) -> &Self -> &Self::Target {
    &self.0
  }
}

fn main() {
  let child = Child(Person{
    gender: 'male',
    age:     6_i32
  });

  println!("your child is {}, {} years old.", child.gender, child.age);
}