Stack and Heap

스택은 자료구조에서 다들 배웠겠지만, 여기서말하는 스택은 조금 다릅니다. 자료구조의 스택처럼 LIFO 개념은 동일합니다만, 여기서 말하는 Stack은 프로그램을 실행시 정적으로 가지는 메모리입니다. C++에서 Vector를 사용할때 Stack처럼 push로 데이터를 추가하고 pop으로 빼낼수있지만 C++ Vector는 가변메모리로써 Heap에 존재하죠. Stack에 저장될수있는 메모리는 컴파일 시점에 메모리의 크기를 정확히 알수 있어야 합니다.

스택메모리는 프로그램 실행시점부터 순차적으로 메모리를 쌓아올라가기 떄문에, 호출비용이 없고 메모리 낭비가 거의 제로에 가깝습니다. 힙메모리는 메모리 조각조각 사이에서 필요로하는 메모리보다 큰공간을 사용하게되므로 메모리 낭비도있고 빈공간을 찾아야하는 호출비용도 존재합니다.

최적화 기법중에는 stack메모리를 크게할당해둔다음 데이터를 수동으로 stack메모리에서 관리해주는 방법도 있습니다. 하지만 이는 생산성이 떨어지는 단점이 있어서 특별한경우를 제외하고는 잘 사용하지 않습니다. Ownership 개념을위해 짧게 정리하고 넘어갑니다.

fn main() {
    let score: i32 = 100;                                // stack
    let name: String = String::from("김개똥");     // heap
}

name 변수를 일반변수로 설정해도 heap 메모리에 저장되게 됩니다. 만약 문자열을 stack메모리에 올리고싶으면, 아래처럼 사용해야합니다.

let stack_str: [u8; 9] = *b"Hello Rust";

Ownership

오너십은 조건

• 각 변수는 오너십을 갖고있다.
• 오너십은 단 한명만 갖는다.
• 오너가 스코프를 넘어가는경우 값은 사라진다. – 가비지콜렉터 대용기능

scope의 개념

 {                      
        let s = "hello";   // s는 이 라인 이후로 사용 가능

        // s 를 사용
}                            // 여기서부터는 스코프를 떠나서 s는 더이상 사용 불가능

소유권 이동

먼저 아래의 경우 integer 타입 변수는 사이즈를 알고있고, 때문에 x 와 y 모두 5라는값을 스택메모리에 저장하게됩니다.

{
    let x = 5;
    let y = x;
}

문자열 형식의 경우, 힙메모리를 사용하기때문에 아래처럼 코드를 작성할경우 아래 그림처럼 hello 문자열이 담긴 주소(포인터)가 복사되게 된다. 좋게 말하면 포인터 코드를 알지못해도 포인터를 사용한것처럼 낼수있는것이고. 단점이라면, 포인터를 사용하진않지만 실제로는 포인터개념을 알고있어야 Rust를 잘 사용할수 있다는 이야기 이기도 하다.

s2에 s1을 대입하는 순간 소유권이 s2로 이동해서, s1은 사용불가 -> s1을 사용하려 하면 컴파일 에러

{
    let s1 = String::from("hello");
    let s2 = s1;                   // 이 statement 이후 s1은 사용불가
}

drop 타이밍

같은 s변수에 문자열을 두번 초기화 하는 경우엔, 2개의 힙메모리가 할당이 되는데 2 번 statement가 실행되는순간 아래 그림처럼 s변수는 ahoy문자열이 저장된 주소를 가리키게된다.

Rust에서는 메모리를 해제하는것을 drop 함수로 진행하는데 drop함수가 호출되는 부분은 4번 scope를 떠나는 순간이므로 hello라는 메모리는 3번 statement가 실행된 이후에도 메모리에는 실제로 남아있다. 이렇게 작동하는 이유는 좀더 복잡한코드에서 1번과 2번 statement사이에서 s의 소유권을 가져가진 않지만 참조로 읽을수있는 다른객체가 존재할수 있기때문이다.

{
    let mut s = String::from("hello");  // 1
    s = String::from("ahoy");            // 2

    println!("{s}, world!");                // 3
}                                             // 4

deep copy 깊은 복사

만약 문자열을 복사 하고싶다면? 아래처럼 clone() 함수를 사용해주면된다.

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

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

구조체 객체에 저장할때 소유권을 넘겨주면 되지만 여러 객체에 할당하거나 다른이유로 원본(s1)을 유지하고싶으면 clone 명령어로 깊은복사를 해야한다.

struct User {
    username: String,
}

fn main() {
    let current_name = String::from("김개똥");

    // User 구조체가 username의 소유권을 가져야 하므로 복사본을 만듭니다.
    let user1 = User {
        username: current_name.clone(),
    };

    // 여전히 current_name을 다른 곳(예: 로그 출력)에 쓸 수 있습니다.
    println!("가입 신청자: {}", current_name);
}

Return Values and Scope 함수 리턴과 스코프

아래코드는 https://doc.rust-lang.org/book/ch04-01-what-is-ownership.html 에서 빌려왔다. 이해해야할 포인트가 몇군데 있다. some_string은 gives_ownersihp 함수에서 선언되었지만, 해당 함수가끝나도 yours 문자열은 drop되지않는다. 소유권이 이미 s1변수로 넘어갔기때문이다. 그리고 s2에서 생성된 hello 문자열은 takes_and_gives_back 함수로 소유권을 전달하지만 해당함수 리턴값으로 소유권을 돌려받는다. 여기서 중요한건 그냥 문자열을 전달하듯 사용했을뿐인데, C++에서 포인터를 통해 문자열을 전달했다가 돌려받은것처럼 메모리 복사가 발생하지 않는다는것이다.

fn main() {
    let s1 = gives_ownership();        // gives_ownership moves its return
                                       // value into s1

    let s2 = String::from("hello");    // s2 comes into scope

    let s3 = takes_and_gives_back(s2); // s2 is moved into
                                       // takes_and_gives_back, which also
                                       // moves its return value into s3
} // Here, s3 goes out of scope and is dropped. s2 was moved, so nothing
  // happens. s1 goes out of scope and is dropped.

fn gives_ownership() -> String {       // gives_ownership will move its
                                       // return value into the function
                                       // that calls it

    let some_string = String::from("yours"); // some_string comes into scope

    some_string                        // some_string is returned and
                                       // moves out to the calling
                                       // function
}

// This function takes a String and returns a String.
fn takes_and_gives_back(a_string: String) -> String {
    // a_string comes into
    // scope

    a_string  // a_string is returned and moves out to the calling function
}