Rust Programming Language

Giriş

Açıklaması şöyle

[S]ome common Rust packages depend on C code and will need a C compiler.

Kalıtım

Örnek

Şöyle yaparız

trait Animal {
  fn talk(&self);
}

struct Dog;
struct Cat;
impl Animal for Dog {
  fn talk(&self) {
    println("I am a dog");
  }
}
impl Animal for Cat {
  fn talk(&self) {
    println("I am a cat");
  }
}

Şöyle yaparız. Box<> C++’taki unique_ptr<> gibidir.

fn main() {
  let animals : Vector<Box<dyn Animal>> = vec![Box::new(Dog{}),Box::new(Cat{})];
  for animal in animals.iter() {
    animal.talk();
  }
}

Ownership

Örnek

Elimizde şöyle bir kod olsun. p1 değişkeni p2 değişkenine atanınca nesnenin sahipliği devredilir. p1 değişkenine erişmek istersek derleyici bunu yakalar.

let p1 = Person::new();
p2 = p1;
println!("person {#:?}", p2)
println!("person {#:?}", p1) //compile error

Clone

Deep copy şeklinde çalışır

Örnek

Şöyle yaparız.

let p1 = Person::new();
let p2 = p1.clone();
do_something(p2);
println!("{:?}", p1); //works ok

Borrowing

Nesnenin sahipliği devredilmez.

Örnek - Numeric Primitive Tipler

Nesne sahipliği yoktur. Görmek için şöyle yaparız.

fn sum(left: i32, right: i32) -> i32 {
  left + right
}

fn main() {
  let a = 42;
  let b = 1;
  let s = sum(a, b);

  println!("this sum of {} and {} is {}", a, b, s); // no error!
}

Örnek - Passing By Reference Olmazsa

Hata alırız. Görmek için şöyle yaparız.

fn sum(vector: Vec<i32>) -> i32 {
  let mut sum = 0;

  for item in vector {
    sum = sum + item
  }

  sum
}

fn main() {
  let v = vec![1,2,3];
  let s = sum(v);

  println!("sum of {:?}: {}", v, s); // ERROR: v was MOVED!
}

Düzeltmek için şöyle yaparız.

fn sum(vector: &Vec<i32>) -> i32 { // borrow signature
  let mut sum = 0;

  for item in vector {
    sum = sum + item
  }

  sum
}

fn main() {
  let v = vec![1,2,3];
  let v_ref = &v;  // v_ref borrows v
  let s = sum(v_ref);

  println!("sum of {:?}: {}", v_ref, s); // no error
}

Örnek -  Passing By reference

Şöyle yaparız.

let p1 = Person::new();
do_something(&p1);
println!("p = {}",p1); //continue using p1 since ownership has been was never passed on

fn do_something(p: &Person) {
  //logic
}

Örnek - Passing By Mutable reference

Şöyle yaparız.

let mut p1 = Person::new();
do_something(&mut p1);
println!("mutated info {}",p2)

fn do_something(p: &mut Person, new_name: String) {
   p.name = String::from(new_name);
}

Vector

Örnek

Şöyle yaparız

fn main() {
  let a = vec![1, 2, 3]; // a growable array literal
  let b = a;             // move: `a` can no longer be used

  println!("a: {:?}", b);
}