[Rust 입문] 4. 소유권, 참조자, 라이프타임

소유권 (Ownership)

1. rust의 각각의 값은 해당값의 오너(owner)라고 불리는 변수를 가지고 있다.

2. 한번에 하나의 오너만 존재할 수 있다.

3. 오너가 스코프 밖으로 벗어날 때 값은 버려진다.

fn main() {
	{
    let a: u32 = 1234;
    println!("a : {}", a);
	}
	let b = 4321;
	println!("b : {}", b);
}

힙에 데이터를 저장하는 타입과 소유권

let s = String::from("hello");

let mut s = String::from("hello");
s.push_str(", world!");
println!("{}", s); // `hello, world!`

변수의 이동과 복사

let x = 5;
let y = x;
println!("x : {}, y : {}", x, y);

let s_x = String::from("hello~");
let s_y = s_x;
println!("s_y : {}", s_y);

let s1 = String::from("hello");
let s2 = s1.clone();

println!("s1 = {}, s2 = {}", s1, s2);

함수와 소유권

인자로 넘길 때의 변수의 소유권 이전

fn main() {
    let v_int = 1234;
    let v_str = String::from("string");
    get_integer(v_int); // get_integer 내의 var로 "값 복사" 가 일어남.
    get_string(v_str); // get_string 내의 var로 "값 이동" 이 일어남.
    println!("v_int : {}", v_int);
    //println!("v_str : {}", v_str);
}

fn get_integer(var: i32) {
    println!("var : {}", var);
} // var 변수 파기

fn get_string(var: String) {
    println!("var : {}", var);
} // var 변수 파기

값을 리턴받을 때의 소유권 이전

fn main() {
    let v_str = String::from("string");
    let v_str = pipe(v_str); // get_integer 내의 var로 "값 복사" 가 일어남.
    println!("v_str : {}", v_str);
}

fn pipe(var: String) -> String {
    println!("{}에 대해 소유권을 잠시 가지지만 아무 동작도 하지 않는 함수", var);
    var
} // var 변수 이동

함수로 소유권을 이전하지 않고 인자를 사용하는 법

fn main() {
    let s1 = String::from("hello");
    let (s2, len) = strlen(s1);
    println!("The length of '{}' is {}.", s2, len);
}

fn strlen(s: String) -> (String, usize) {
    let length = s.len();
    (s, length)
}

참조자

fn main() {
    let s = String::from("hello");
    let len = strlen(&s);
    println!("The length of '{}' is {}.", s, len);
}

fn strlen(s: &String) -> usize {
    s.len() // 여기서 s는 main 함수 내의 s를 잠시 빌려온 것이다.
}

가변 참조자

fn main() {
    let mut s = String::from("hello");
    addstr(&mut s);
    println!("new string : {}.", s);
}

fn addstr(s: &mut String) {
    s.push_str(", world");
}

fn main() {
    let mut s = String::from("hello");
    let borrow = &s;
    println!("borrow string : {}.", borrow);
}

참조자와 가변 참조자와 멀티스레드 프로그래밍

가변 참조자는 특정 스코프 내에 가변 참조자를 하나밖에 만들 수 없으며 동일한 값에 불변 참조자가 존재할 때 가변 참조자를 만들 수 없다.

슬라이스

스트링 슬라이스

fn main() {
    let mut string = String::from("hello world");
    let pos = get_two_char_index(&string);
    println!("string : {}, pos : {}", string, pos);
    string.clear();
    println!("string : {}, pos : {}", string, pos);
}

fn get_two_char_index(s: &String) -> usize {
    if s.len() <= 2 {
        s.len()
    } else {
        2
    }
}

fn main() {
    let mut string = String::from("hello world");
    let substr = get_two_char(&string);
    println!("string : {}, substr : {}", string, substr);
    string.clear(); // clear 함수에서 가변 참조자를 만들기 때문에 E0502 에러 발생
    println!("string : {}, substr : {}", string, substr);
}

fn get_two_char(s: &String) -> &str {
    if s.len() <= 2 {
        s
    } else {
        &s[..2]
    }
}

라이프타임

let str_a = "Hello, world!"; // 프로그램이 종료될때까지 유효한 변수
let str_ref; // 프로그램이 종료될때까지 유효한 참조자 변수 (초기화 되어 있지 않아 현재 사용 불가)
{
  let str_b = "Hello"; // 이 스코프 내에서만 유효한 변수
  str_ref = &str_b; // str_a를 참조하면 괜찮지만 str_b는 스코프를 나가면 무효화되어 댕글링 포인터가 된다.
  println!("str_ref : [{}]", str_ref); // str_a, str_b 에 대해서 모두 정상 동작
}
println!("str_ref : [{}]", str_ref); // str_b를 참조할 시 에러

라이프타임 파라미터

fn int_max<'a>(a: &'a u32, b: &'a u32) -> &'a u32 {
    if a > b {
        a
    } else {
        b
    }
}

정적 라이프타임 파라미터