Ereditarietà ruggine: chiamata metodo principale

Question

In che modo Rust chiama "metodo padre"? Come questo in Java:

public class parent{ 
    ... 
    public void doSomething(){ 
     System.out.println("Parent method"); 
    } 
} 
public class child extends parent{ 
    ... 
    public void doSomething(){ 
     super.doSomething(); 
     System.out.println("Child method."); 
    } 
} 

In Vai, siamo in grado di simulare da campi anonimi in struct:

type parent struct{} 

func (self *parent) doSomething() { 
    fmt.Println("parent method") 
} 

type child struct { 
    parent 
} 

func (self *child) doSomething() { 
    self.parent.doSomething() 
    fmt.Println("child method") 
} 
func main() { 
    var c1 child 
    c1.doSomething() 
} 

Come simulare in Rust? Grazie!

Answer 1

Non è proprio la stessa cosa sotto il cofano, ma qualcosa di simile

trait DoThings { 
    fn do_something(&self); 
} 

struct Parent; 

impl DoThings for Parent { 
    fn do_something(&self) { println("doing something"); } 
} 

struct Child { 
    parent: Parent 
} 

impl DoThings for Child { 
    fn do_something(&self) { 
     self.parent.do_something(); 
     println("child"); 
    } 
} 

fn main() { 
    let c = Child { parent: Parent }; 
    c.do_something(); 
} 

Ci sono alcune proposte per rendere le parti di questa automatica (ad esempio, se abbiamo voluto chiamare semplicemente il metodo del genitore direttamente, vale a dire don' t sovrascrivere il metodo nel child, quindi al momento è necessario chiamare esplicitamente il metodo del genitore).

Answer 2

Il punto di ereditarietà è in grado di sovrascrivere un metodo ereditato. I campioni sopra riportati trattano ancora di delega e non di ereditarietà.

Diamo uno sguardo ad alcuni di codice Vai a illustrare questo:

type Base struct {} 
func (Base) Magic() { fmt.Print("base magic") } 
func (self Base) MoreMagic() { 
    self.Magic() 
} 

type Foo struct { 
    Base 
} 

func (Foo) Magic() { fmt.Print("foo magic") } 

Se si esegue il codice sopra questo modo

f := new(Foo) 
f.Magic() 

stamperà "foo magico" alla console e non "magia di base". Tuttavia, se corriamo questo codice

f := new(Foo) 
f.MoreMagic() 

non stamperà "foo magico" così, ma questa volta "magia di base". Questo a causa della mancanza di ereditarietà e quindi non essere in grado di sovrascrivere il metodo Magic (ovvero il collegamento dinamico). Quindi stiamo ancora trattando con delega.

È possibile aggirare questo f.ex. come descritto nella sezione "Inner Patern" nell'articolo this. Non so esattamente di questo riguardo a Rust. A prima vista sembra essere lo stesso.