Rust 소유권 시스템 완벽 가이드 | Ownership·Borrowing·Lifetime
이 글의 핵심
Rust 소유권 시스템 완벽 가이드. 소유권·빌림·라이프타임으로 메모리 안전성을 컴파일 타임에 보장. 댕글링 포인터·데이터 레이스 방지. C++와 비교하며 이해하기.
들어가며
Rust의 소유권 시스템은 가비지 컬렉터 없이 메모리 안전성을 보장하는 핵심 기능입니다. 소유권(Ownership), 빌림(Borrowing), 라이프타임(Lifetime) 세 가지 개념으로 구성됩니다.
비유로 말씀드리면, 소유권은 책의 주인이고, 빌림은 책을 빌려주는 것이며, 라이프타임은 빌린 기간입니다. 한 번에 한 명만 책을 소유하고, 빌려준 동안은 주인이 책을 버릴 수 없으며, 빌린 사람이 돌려주기 전에 주인이 사라지면 안 됩니다.
이 글을 읽으면
- 소유권·빌림·라이프타임의 개념을 이해합니다
- 빌림 검사기(Borrow Checker) 규칙을 파악합니다
- C++와 비교하며 차이점을 확인합니다
- 실무에서 자주 만나는 에러를 해결합니다
목차
소유권 기초
소유권 규칙
- 각 값은 하나의 소유자(owner)를 가집니다
- 한 번에 하나의 소유자만 존재합니다
- 소유자가 스코프를 벗어나면 값이 해제됩니다
소유권 이동 (Move)
fn main() {
let s1 = String::from("hello");
let s2 = s1; // s1의 소유권이 s2로 이동
// println!("{}", s1); // 컴파일 에러! s1은 더 이상 유효하지 않음
println!("{}", s2); // OK
}C++와 비교:
// C++11 std::move
std::string s1 = "hello";
std::string s2 = std::move(s1);
std::cout << s1 << std::endl; // 런타임 에러 가능 (정의되지 않은 동작)
std::cout << s2 << std::endl; // OK차이점:
- Rust: 컴파일 타임에 이동 후 사용을 방지
- C++: 런타임에 이동 후 사용 시 정의되지 않은 동작
복사 (Copy)
Copy 트레이트를 구현한 타입은 이동 대신 복사됩니다:
fn main() {
let x = 5;
let y = x; // 복사 (i32는 Copy 트레이트 구현)
println!("x: {}, y: {}", x, y); // 둘 다 사용 가능
}Copy 트레이트를 구현한 타입:
- 모든 정수형 (
i32,u64등) - 불리언 (
bool) - 부동소수점 (
f32,f64) - 문자 (
char) - 튜플 (모든 요소가 Copy일 때)
Copy 트레이트를 구현하지 않은 타입:
StringVec<T>Box<T>- 구조체 (기본값)
함수와 소유권
fn main() {
let s = String::from("hello");
takes_ownership(s); // s의 소유권이 함수로 이동
// println!("{}", s); // 컴파일 에러!
let x = 5;
makes_copy(x); // x는 복사됨
println!("{}", x); // OK
}
fn takes_ownership(some_string: String) {
println!("{}", some_string);
} // some_string이 스코프를 벗어나면서 drop 호출
fn makes_copy(some_integer: i32) {
println!("{}", some_integer);
}반환값과 소유권
fn main() {
let s1 = gives_ownership(); // 소유권을 받음
let s2 = String::from("hello");
let s3 = takes_and_gives_back(s2); // s2의 소유권을 주고 받음
// println!("{}", s2); // 컴파일 에러!
println!("{}", s3); // OK
}
fn gives_ownership() -> String {
let some_string = String::from("yours");
some_string // 소유권을 호출자에게 이동
}
fn takes_and_gives_back(a_string: String) -> String {
a_string // 소유권을 호출자에게 반환
}빌림 규칙
참조 (References)
소유권을 이동하지 않고 값을 사용하려면 참조를 사용합니다:
fn main() {
let s1 = String::from("hello");
let len = calculate_length(&s1); // 참조 전달
println!("'{}' 길이: {}", s1, len); // s1 여전히 사용 가능
}
fn calculate_length(s: &String) -> usize {
s.len()
} // s는 참조이므로 drop되지 않음빌림 규칙
- 불변 참조는 여러 개 가능
- 가변 참조는 하나만 가능
- 불변 참조와 가변 참조는 동시에 존재할 수 없음
불변 참조 (Immutable References)
fn main() {
let s = String::from("hello");
let r1 = &s; // OK
let r2 = &s; // OK
let r3 = &s; // OK
println!("{}, {}, {}", r1, r2, r3);
}가변 참조 (Mutable References)
fn main() {
let mut s = String::from("hello");
change(&mut s);
println!("{}", s); // "hello, world"
}
fn change(some_string: &mut String) {
some_string.push_str(", world");
}가변 참조 제한
한 번에 하나의 가변 참조만 가능:
fn main() {
let mut s = String::from("hello");
let r1 = &mut s;
// let r2 = &mut s; // 컴파일 에러! 이미 가변 참조 존재
println!("{}", r1);
}이유: 데이터 레이스 방지
// 데이터 레이스 예시 (Rust에서는 불가능)
fn main() {
let mut s = String::from("hello");
let r1 = &mut s;
let r2 = &mut s; // 컴파일 에러!
r1.push_str(" world");
r2.push_str("!"); // 동시 수정 불가
}불변·가변 참조 혼용 불가
fn main() {
let mut s = String::from("hello");
let r1 = &s; // OK
let r2 = &s; // OK
// let r3 = &mut s; // 컴파일 에러! 불변 참조 존재
println!("{}, {}", r1, r2);
}참조 스코프 (Non-Lexical Lifetimes)
Rust 2018부터 참조 스코프가 더 유연해졌습니다:
fn main() {
let mut s = String::from("hello");
let r1 = &s;
let r2 = &s;
println!("{}, {}", r1, r2);
// r1, r2는 여기서 더 이상 사용되지 않음
let r3 = &mut s; // OK! r1, r2의 스코프가 끝남
println!("{}", r3);
}댕글링 참조 방지
Rust는 댕글링 참조를 컴파일 타임에 방지합니다:
fn main() {
// let reference_to_nothing = dangle(); // 컴파일 에러!
let valid_string = no_dangle();
println!("{}", valid_string);
}
// fn dangle() -> &String { // 컴파일 에러!
// let s = String::from("hello");
// &s // s가 스코프를 벗어나면서 해제됨
// }
fn no_dangle() -> String {
let s = String::from("hello");
s // 소유권 이동
}C++와 비교:
// C++ 댕글링 포인터 (런타임 에러)
std::string* dangle() {
std::string s = "hello";
return &s; // 컴파일 경고, 런타임 에러
}라이프타임
라이프타임이란?
참조가 유효한 스코프를 명시하는 제네릭 파라미터입니다.
라이프타임 어노테이션
fn main() {
let string1 = String::from("long string");
let string2 = String::from("short");
let result = longest(&string1, &string2);
println!("가장 긴 문자열: {}", result);
}
// 라이프타임 어노테이션 필요
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
if x.len() > y.len() {
x
} else {
y
}
}의미:
'a: 라이프타임 파라미터x,y, 반환값 모두 같은 라이프타임'a를 가짐- 반환값은
x와y중 짧은 라이프타임을 가짐
라이프타임 규칙
컴파일러가 자동으로 추론하는 규칙:
- 각 참조 파라미터는 고유한 라이프타임을 가짐
- 참조 파라미터가 하나면 반환값도 같은 라이프타임
- 메서드에서
&self또는&mut self가 있으면 반환값도 같은 라이프타임
구조체 라이프타임
struct ImportantExcerpt<'a> {
part: &'a str,
}
fn main() {
let novel = String::from("Call me Ishmael. Some years ago...");
let first_sentence = novel.split('.').next().expect("Could not find a '.'");
let i = ImportantExcerpt {
part: first_sentence,
};
println!("{}", i.part);
}정적 라이프타임
'static 라이프타임은 프로그램 전체 기간 동안 유효합니다:
fn main() {
let s: &'static str = "I have a static lifetime.";
println!("{}", s);
}문자열 리터럴은 모두 'static 라이프타임을 가집니다.
실전 구현
벡터 소유권
fn main() {
let v = vec![1, 2, 3, 4, 5];
let first = &v[0]; // 불변 참조
// v.push(6); // 컴파일 에러! 불변 참조 존재
println!("첫 번째 요소: {}", first);
// first 스코프 끝
let mut v2 = v; // 소유권 이동
v2.push(6); // OK
println!("{:?}", v2);
}문자열 슬라이스
fn main() {
let s = String::from("hello world");
let hello = &s[0..5]; // 불변 참조 슬라이스
let world = &s[6..11];
println!("{} {}", hello, world);
let first_word = first_word(&s);
println!("첫 단어: {}", first_word);
}
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[..]
}구조체 소유권
#[derive(Debug)]
struct User {
username: String,
email: String,
active: bool,
}
fn main() {
let user1 = User {
username: String::from("user1"),
email: String::from("[email protected]"),
active: true,
};
// 부분 이동
let user2 = User {
username: user1.username, // 이동
email: String::from("[email protected]"),
active: user1.active, // 복사 (bool은 Copy)
};
// println!("{}", user1.username); // 컴파일 에러!
println!("{}", user1.active); // OK (Copy)
println!("{:?}", user2);
}클로저와 소유권
fn main() {
let x = vec![1, 2, 3];
// move 키워드로 소유권 이동
let equal_to_x = move |z| z == x;
// println!("{:?}", x); // 컴파일 에러! x가 이동됨
let y = vec![1, 2, 3];
assert!(equal_to_x(y));
}C++와 비교
소유권 vs 스마트 포인터
| 개념 | Rust | C++ |
|---|---|---|
| 단독 소유 | T (기본) | std::unique_ptr<T> |
| 공유 소유 | Rc<T> / Arc<T> | std::shared_ptr<T> |
| 참조 | &T / &mut T | T& / const T& |
| 검사 시점 | 컴파일 타임 | 런타임 (일부) |
Rust 소유권
fn main() {
let s1 = String::from("hello");
let s2 = s1; // 이동
// println!("{}", s1); // 컴파일 에러!
}C++ unique_ptr
#include <memory>
#include <iostream>
int main() {
auto s1 = std::make_unique<std::string>("hello");
auto s2 = std::move(s1); // 이동
// std::cout << *s1 << std::endl; // 런타임 에러 (정의되지 않은 동작)
std::cout << *s2 << std::endl; // OK
}Rust 참조
fn main() {
let mut s = String::from("hello");
let r1 = &s;
let r2 = &s;
// let r3 = &mut s; // 컴파일 에러!
println!("{}, {}", r1, r2);
}C++ 참조
#include <string>
#include <iostream>
int main() {
std::string s = "hello";
const std::string& r1 = s;
const std::string& r2 = s;
std::string& r3 = s; // OK (런타임 검사 없음)
std::cout << r1 << ", " << r2 << ", " << r3 << std::endl;
}차이점:
- Rust: 컴파일 타임에 불변·가변 참조 규칙 강제
- C++: 런타임에 동시 수정 가능 (데이터 레이스 위험)
고급 패턴
내부 가변성 (Interior Mutability)
RefCell<T>로 런타임 빌림 검사:
use std::cell::RefCell;
fn main() {
let data = RefCell::new(5);
{
let mut value = data.borrow_mut();
*value += 1;
} // 가변 참조 스코프 끝
println!("{}", data.borrow()); // 6
}Rc와 RefCell 조합
use std::rc::Rc;
use std::cell::RefCell;
#[derive(Debug)]
struct Node {
value: i32,
children: RefCell<Vec<Rc<Node>>>,
}
fn main() {
let leaf = Rc::new(Node {
value: 3,
children: RefCell::new(vec![]),
});
let branch = Rc::new(Node {
value: 5,
children: RefCell::new(vec![Rc::clone(&leaf)]),
});
println!("branch: {:?}", branch);
}Arc와 Mutex (멀티스레드)
use std::sync::{Arc, Mutex};
use std::thread;
fn main() {
let counter = Arc::new(Mutex::new(0));
let mut handles = vec![];
for _ in 0..10 {
let counter = Arc::clone(&counter);
let handle = thread::spawn(move || {
let mut num = counter.lock().unwrap();
*num += 1;
});
handles.push(handle);
}
for handle in handles {
handle.join().unwrap();
}
println!("Result: {}", *counter.lock().unwrap()); // 10
}트러블슈팅
cannot borrow as mutable
문제:
fn main() {
let mut s = String::from("hello");
let r1 = &s;
let r2 = &mut s; // 에러!
println!("{}, {}", r1, r2);
}해결:
fn main() {
let mut s = String::from("hello");
{
let r1 = &s;
println!("{}", r1);
} // r1 스코프 끝
let r2 = &mut s; // OK
println!("{}", r2);
}use of moved value
문제:
fn main() {
let s = String::from("hello");
takes_ownership(s);
println!("{}", s); // 에러!
}
fn takes_ownership(some_string: String) {
println!("{}", some_string);
}해결 1: 참조 사용
fn main() {
let s = String::from("hello");
uses_reference(&s);
println!("{}", s); // OK
}
fn uses_reference(some_string: &String) {
println!("{}", some_string);
}해결 2: clone 사용
fn main() {
let s = String::from("hello");
takes_ownership(s.clone());
println!("{}", s); // OK
}
fn takes_ownership(some_string: String) {
println!("{}", some_string);
}lifetime may not live long enough
문제:
fn longest(x: &str, y: &str) -> &str { // 에러!
if x.len() > y.len() {
x
} else {
y
}
}해결:
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
if x.len() > y.len() {
x
} else {
y
}
}cannot return reference to local variable
문제:
fn dangle() -> &String { // 에러!
let s = String::from("hello");
&s
}해결:
fn no_dangle() -> String {
let s = String::from("hello");
s // 소유권 이동
}마무리
Rust의 소유권 시스템은 메모리 안전성을 컴파일 타임에 보장하는 강력한 기능입니다.
핵심 원칙:
- 각 값은 하나의 소유자만 가짐
- 불변 참조는 여러 개, 가변 참조는 하나만
- 참조는 항상 유효해야 함 (라이프타임)
장점:
- 댕글링 포인터 방지
- 이중 해제 방지
- 데이터 레이스 방지
- 런타임 오버헤드 없음
단점:
- 학습 곡선이 가파름
- 빌림 검사기와 싸워야 함
- 일부 패턴 구현이 복잡함
처음에는 빌림 검사기가 답답하게 느껴질 수 있지만, 익숙해지면 버그 없는 안전한 코드를 작성할 수 있습니다.
C++에서 Rust로 전환하는 개발자라면 Rust 시리즈 인트로와 함께 보시면 도움이 됩니다.