C++ im Vergleich zu RUST

//Rust
fn main() {
  println!("Hello World");
  std::process::exit(0);
}

 fn add(a: i32, b: f32) -> f64 {
   // local function
   let d = a as f64  + b as f64;
   // last line without ";" is equal to "return d;"
   d
 }
 
 pub fn run_add() {
   let d = add(12, 34.0);
  println!("{}", d);
}

 //Rust
 struct Thing {
   m_foo: i32,
   m_bar: i32
 }
 
 impl Thing {
   pub fn new(foo: i32) -> Self {
     // return a new constructed Thing
    Self {
      m_foo: foo,
      m_bar: 0
    }
  }
  pub fn get_type_description() -> &'static str {
    // return a static immutable string reference
    "This is a Thing type."
  }

  pub fn get_foo(&self) -> i32 {
    // does not mutate object
    // full return statement
    return self.m_foo;
  }
  pub fn get_bar(&self) -> i32 {
    // does not mutate object
    // short return statement
    self.m_bar
  }
  pub fn set_bar(&mut self, bar: i32) {
    // mutates object
    self.m_bar = bar;
  }
}

pub fn use_thing() {
  let foo = 12;
  let mut thing = Thing::new(foo);
  thing.set_bar(13);
  let n = thing.get_foo() + thing.get_bar();
  println!("Description = {}", Thing::get_type_description());
  println!("n = {}", n);
}

 pub trait Animal {
   fn get_name(&self) -> String;
   fn speak(&self);
 }
 
 struct Cat {
   m_name: String
 }
 
impl Cat {
  pub fn new(name: &str) -> Self {
    Self {
      m_name: name.to_string()
    }
  }
}

impl Animal for Cat {
  fn get_name(&self) -> String {
    self.m_name.clone()
  }
  fn speak(&self) {
    println!("Meow");
  }
}

struct Dog {
  m_name: String
}

impl Dog {
  pub fn new(name: &str) -> Self {
    Self {
      m_name: name.to_string()
    }
  }
}

impl Animal for Dog {
  fn get_name(&self) -> String {
    self.m_name.clone()
  }
  fn speak(&self) {
    println!("Woof");
  }
}

fn talk_with_animal(animal: &dyn Animal) {
  println!("Animals's name is: {}", animal.get_name());
  animal.speak();
}

pub fn handle_animals() {
  let c = Cat::new("Kitty");
  let d = Dog::new("Sparky");

  let a: &dyn Animal = &c;
  talk_with_animal(a);

  let a: &dyn Animal = &d;
  talk_with_animal(a);
}

  // Rust
  use std::ops::Add;
  use std::ops::AddAssign;
  use std::ops::Sub;
  use std::ops::SubAssign;
  use std::ops::Mul;
  use std::ops::MulAssign;
  use std::ops::Div;
  use std::ops::DivAssign;
 
 // struct must derive Copy and Clone, 
 // otherwise operator parameters are consumed and cannot be used again
 #[derive(Copy, Clone)]
 pub struct Point {
   pub x: f32,
   pub y: f32
 }
 
 impl Point {
   pub fn new(x: f32, y: f32) -> Self {
     Self { 
       x: x, 
       y: y
     }
   }
 }
 
 impl Add for Point {
   type Output = Point;    
   fn add(self, other: Self) -> Self::Output {
     Point::new(self.x + other.x, self.y + other.y)
   }
 }
 impl AddAssign for Point {
   fn add_assign(&mut self, other: Self) {
     self.x += other.x;
     self.y += other.y;
   }
 }
 impl Sub for Point {
   type Output = Self;
       
   fn sub(self, other: Self) -> Self::Output {
     Point::new(self.x - other.x, self.y - other.y)
   }
 }
 impl SubAssign for Point {
   fn sub_assign(&mut self, other: Self) {
     self.x -= other.x;
     self.y -= other.y;
   }
 }
 impl Mul<f32> for Point {
   type Output = Self;
       
   fn mul(self, factor: f32) -> Self::Output {
     Point::new(self.x * factor, self.y * factor)
   }
 }
 impl MulAssign<f32> for Point {
   fn mul_assign(&mut self, factor: f32) {
     self.x *= factor;
     self.y *= factor;
   }
 }
 impl Div<f32> for Point {
   type Output = Self;
       
   fn div(self, denominator: f32) -> Self::Output {
     Point::new(self.x / denominator, self.y / denominator)
   }
 }
 impl DivAssign<f32> for Point {
   fn div_assign(&mut self, denominator: f32) {
     self.x /= denominator;
     self.y /= denominator;
   }
 }
         
 pub fn use_point_operators() {
   let p1 = Point::new(1.0, 2.0);
   let p2 = Point::new(2.0, 3.0);
     
   let p3 = p1 + p2;
   assert_eq!(p3.x, p1.x + p2.x);
   assert_eq!(p3.y, p1.y + p2.y);
 
   let p4 = p2 - p1;
   assert_eq!(p4.x, p2.x - p1.x);
   assert_eq!(p4.y, p2.y - p1.y);
 
   let p5 = p2 * 10.0;
   assert_eq!(p5.x, p2.x * 10.0);
   assert_eq!(p5.y, p2.y * 10.0);
 
   let p6 = p5 / 5.0;
   assert_eq!(p6.x, p5.x / 5.0);
   assert_eq!(p6.y, p5.y / 5.0);
 }