러스트 (Rust) 의 슬라이스 (Slice) 개념

러스트 (Rust) 슬라이스란?

• 컬렉션 중 일련의 연속된 요소들을 참조한다고 표현할 수 있다.
• 배열, 문자열과 같이 메모리상에 나열된 긴 데이터 중 일부를 짤라서 참조한다.

메모리로 문자열을 가리킬 때의 문제

fn main() {
    let mut s = String::from("hello world");

    let word = first_word(&s); // word는 5를 갖게 될 것입니다.

    s.clear(); // 이 코드는 String을 비워서 ""로 만들게 됩니다.

    // word는 여기서 여전히 5를 갖고 있지만, 5라는 값을 의미있게 쓸 수 있는 스트링은 이제 없습니다.
    // word는 이제 완전 유효하지 않습니다!
}

// 첫번째 단어가 몇글자인지 반환하는 함수이다.
// ' '를 발견하면, ' '의 위치 인덱스를 반환하고, 없다면 문자열 길이를 반환한다.
fn first_word(s: &String) -> usize {
    let bytes = s.as_bytes();

    // enumerate() 는 반복자의 각 요소를 (인덱스, 값) 튜플 형태로 반환한다.
    for (i, &item) in bytes.iter().enumerate() {
        println!("i: {}, item: {}", i, item);

        // 문자열에 공백이 존재한다면, early return
        if item == b' ' {
            return i;
        }
    }

    s.len()
}

• first_word() 함수는 첫번째 문자의 길이를 반환한다.
• 첫번째 문자란 띄어쓰기 () 가 등장하기 전까지로 정의한다.
• first_word() 가 반환한 값과 first_word() 의 파라미터로 참조된 문자열(s) 는 코드 상에서 하나가 지워져도 큰 이변없이 동작은 하지만, 실제로 둘은 긴밀한 관계가 있다.
• 코드 중간에 s.clear() 가 수행되어 s 가 메모리 상에서 사라지면, first_word() 가 반환한 값 (word) 은 '더이상 싱크가 맞지 않는 데이터'가 된다.
  • 원본 문자열이 사라졌음에도 불구하고, 이를 인지하지 못한 채 word 값을 이용하면 의도치 않은 결과가 나올 수 있다. 코드상에서 논리적으로는 오류가 없어서 더욱 위험하다.

이렇게 스트링을 다룰 때, 문자열과 별개로 구한 길이 값까지 싱크가 맞도록 할 수는 없을까?

스트링 슬라이스

스트링 슬라이스는 문자열 관련 값의 싱크와 관련된 문제를 완벽히 해결하며, 또한 편리하다.

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

let hello = &s[0..5];
let world = &s[6..11];

• &s[0..5] 와 &s[6..11] 과 같이 표현되는 것이 스트링 슬라이스이다.
• &참조문자열[start_index..end_index] 형식으로 표현되는데, end_index 에 해당하는 숫자는 슬라이스에 포함되지 않는다.
  • &s[0..5] 는 hello 를 표현한다.
  • &s[6..11] 은 world 를 표현한다.

스트링 슬라이스의 생략 문법

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

let slice = &s[0..2];
let slice = &s[..2];

• start_index 가 0 이라면 생략 가능하다.

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

let len = s.len();

let slice = &s[3..len];
let slice = &s[3..];

• end_index 가 len 이라면 생략 가능하다.

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

let len = s.len();

let slice = &s[0..len];
let slice = &s[..];

• start_index 가 0 이고, end_index 가 len 이라면 둘 다 생략 가능하다.

스트링 슬라이스를 반환하기

fn first_word(s: &String) -> &str {
    let bytes = s.as_bytes();

    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return &s[0..i];
        }
    }

    &s[..]
}

• &str 타입으로 반환 가능하다.

스트링 슬라이스의 싱크가 어긋났을 때

fn main() {
    let mut s = String::from("hello world");

    let word = first_word(&s);

    s.clear(); // Error!

    println!("the first word is: {}", word);
}

• 위의 코드는 에러를 일으킨다.
• s 와 word 는 서로 연관관계가 깊은 값이다. 그러나, 코드상에서 이게 명시적으로 드러나진 않는다.
• 러스트에서는 word 가 s 의 슬라이스임을 알기 때문에, s.clear() 를 수행하려 하면 에러가 난다.
  • 만일, 에러 없이 s.clear() 가 수행됐다면, word 는 댕글링 참조자 (Dangling Reference) 가 되고 만다.

17:6 error: cannot borrow `s` as mutable because it is also borrowed as
            immutable [E0502]
    s.clear(); // Error!
    ^
15:29 note: previous borrow of `s` occurs here; the immutable borrow prevents
            subsequent moves or mutable borrows of `s` until the borrow ends
    let word = first_word(&s);
                           ^
18:2 note: previous borrow ends here
fn main() {

}
^

스트링 리터럴은 사실 슬라이스의 일종이다

let s = "Hello, world!";

• s 의 타입은 생략되었지만, &str 이다.
• &str 은 바이너리의 특정 지점을 가리키고 있는 것이다.
• &str 은 불변 참조자이다.

함수 파라미터 슬라이스로 받기

fn first_word(s: &String) -> &str {
}

fn first_word(s: &str) -> &str {
}

아래의 시그니처를 사용하면, 파라미터 s 와 반환 값에 대해 일관성 있는 함수를 사용할 수 있다.

fn main() {
    let my_string = String::from("hello world");

    // first_word가 `String`의 슬라이스로 동작합니다.
    let word = first_word(&my_string[..]);

    let my_string_literal = "hello world";

    // first_word가 스트링 리터럴의 슬라이스로 동작합니다.
    let word = first_word(&my_string_literal[..]);

    // 스트링 리터럴은 *또한* 스트링 슬라이스이기 때문에,
    // 아래 코드도 슬라이스 문법 없이 동작합니다!
    let word = first_word(my_string_literal);
}

배열의 슬라이스

let a = [1, 2, 3, 4, 5];

let slice = &a[1..3];

• 배열도 위의 코드처럼 슬라이스로 이용이 가능하다.
• 이 슬라이스는 &[i32] 타입을 갖는다.

정리

• 소유권, 빌림, 슬라이스 개념은 모두 러스트 프로그램의 메모리 안정성을 컴파일 타임에 보장하는 것이다.
• 러스트 언어는 언어 이용자에게 메모리 사용에 대한 제어권을 주지만, 스코프를 벗어났을 때 바로 메모리를 해제한다.
  • 이러한 특징으로 인해 결과적으로 추가적인 코드 작성이나 디버깅을 하지 않아도 된다.