[Rust] 소유권 이해하기: 개념부터 C++과 비교한 예제까지

Rust는 메모리 관리에서 안전성과 성능을 동시에 제공하기 위해 소유권 시스템(Ownership System)을 도입한 혁신적인 언어입니다. C와 달리, 메모리 해제를 개발자가 직접 관리하지 않아도 컴파일 타임에 메모리 안전성을 보장합니다. 이로써 Dangling Pointer나 Data Race 같은 오류를 방지하며, 런타임 성능 저하 없이 동작합니다. 또한, 멀티스레드 환경에서도 Rust는 데이터 경합을 소유권 규칙으로 원천 차단해 안전한 동시성을 제공합니다. C 스타일의 제어와 현대 언어의 안전성을 결합한 Rust는 메모리 안전성을 고민하는 모든 개발자에게 새로운 기준을 제시하는데요. 아래의 C와 Rust의 소유권 개념을 비교하며 소유권을 완전히 이해해봐요!

1. 소유권에 대한 이해

C 또는 C++ 코드를 다뤄본 경험이 있다면, 클래스 인스턴스가 다른 객체를 "소유"한다고 기술한 주석을 종종 볼 수 있습니다. 이 소유권은 소유자가 소유된 객체의 생명 주기를 제어할 권리를 가진다는 의미입니다. 즉, 소유자가 소멸될 때 소유된 객체도 함께 소멸됩니다.

먼저 C++에서의 소유권을 이해하면서 Rust의 소유권을 이해합시다.

1.1. 예제 코드: C++에서의 소유권

std::string s = "frayed knot";

그림1. C++에서의 소유권

위의 코드에서 std::string 객체 s는 힙(heap)에 할당된 버퍼를 소유하며, 이를 통해 문자열 데이터를 관리합니다. 이 객체는 보통 다음과 같은 세 가지 정보로 구성됩니다:

• 포인터: 힙에 할당된 버퍼를 가리킵니다.
• 버퍼 용량: 현재 할당된 최대 크기입니다.
• 문자열 길이: 저장된 텍스트의 실제 길이입니다.

이 모든 정보는 std::string의 private 필드로 관리되며, 외부 사용자에게는 접근이 불가합니다.

1.2. 소유권의 역할

std::string은 자신이 소유한 버퍼를 관리하며, 소멸자(destructor)를 통해 메모리를 안전하게 해제합니다. 과거에는 참조 횟수(reference counting)를 사용해 여러 std::string 객체가 동일한 버퍼를 공유하도록 설계된 라이브러리도 있었습니다. 하지만 최신 C++ 표준에서는 이러한 방식이 권장되지 않으며, 대부분의 현대 라이브러리는 독립적인 버퍼 소유 방식을 따릅니다.

1.3. 설계 유연성

이 예제는 std::string을 통해 C++에서 소유권의 개념을 보여줍니다. 하지만 이는 표준 라이브러리의 관례일 뿐, 사용자는 자신의 타입을 설계할 때 이러한 원칙을 따르거나 변형할 자유가 있습니다. C++은 개발자가 소유권을 명확하게 정의하고 관리하도록 설계된 언어입니다.

참고: 임시 포인터를 생성하는 것이 있지만 사용자가 free를 하여 관리해야합니다.

2. Rust의 소유권: 안전한 메모리 관리

Rust에서는 소유권(Ownership)이 언어의 핵심 개념으로, 컴파일 타임 검사에 의해 강제됩니다. 이는 시스템 프로그래밍 언어로서 메모리 안전성을 확보하는 중요한 기초를 제공합니다. Rust의 소유권 규칙은 코드만으로 값의 수명과 메모리 관리 방식을 명확히 이해할 수 있도록 설계되었습니다.

2.1. Rust의 소유권 규칙

1. 단일 소유자: 모든 값은 단일 소유자(owner)를 가집니다.
2. 수명 결정: 소유자가 범위를 벗어나면 해당 값은 자동으로 해제(dropped)됩니다.
3. 명확한 제어: 값의 수명은 코드의 구조와 동일하게 직관적입니다.

예제 코드: Rust에서의 소유권

fn print_padovan() {
    let mut padovan = vec![1, 1, 1]; // 벡터 생성 및 초기화
    for i in 3..10 {
        let next = padovan[i - 3] + padovan[i - 2];
        padovan.push(next); // 새로운 값 추가
    }
    println!("P(1..10) = {:?}", padovan); // 결과 출력
} // padovan이 범위를 벗어나면서 메모리 해제

위 코드에서 padovan 변수는 Vec<i32> 타입으로, 이는 힙(heap)에 저장된 32비트 정수 벡터입니다. 이 변수의 생명 주기는 함수 블록 내에서만 유효하며, 함수가 종료되면 Rust는 padovan과 해당 힙 버퍼를 자동으로 해제합니다.

2.2. Rust와 C++ 소유권의 차이

• Rust: 소유권 규칙이 언어 차원에서 통합되어 있어, 컴파일 타임에 메모리 안전성을 보장합니다. 따라서 개발자는 메모리 누수나 잘못된 접근을 걱정하지 않아도 됩니다.
• C++: 소유권 관리가 프로그래머의 책임에 의존하며, 명시적으로 소멸자(destructor)와 스마트 포인터를 활용해야 합니다.

2.3. 메모리 레이아웃

Rust의 벡터는 C++의 std::string과 유사한 구조의 memory layout을 가지며 다음과 같은 사실을 꼭 알아두세요:

1. 스택(stack): 포인터, 용량, 길이를 저장합니다.
2. 힙(heap): 실제 데이터 요소를 저장합니다.

Rust는 함수가 종료될 때 padovan의 메모리를 자동으로 정리합니다. 이 과정은 버퍼의 소유권이 벡터에 귀속되어 있다는 점에서, 소유자가 해제되면 버퍼 역시 함께 해제된다는 원칙을 따릅니다.

3. Rust의 Box 타입과 소유권의 확장

Rust의 Box<T>는 힙 메모리를 사용하는 소유권의 대표적인 예입니다. 이는 타입 T에 대한 힙 할당 포인터를 제공하며, Rust의 소유권 모델에 따라 안전하게 관리됩니다.

3.1. Box의 동작 방식

Box::new(v)는 다음과 같은 작업을 수행합니다:

1. 힙 메모리 할당: 타입 T의 크기만큼 공간을 확보합니다.
2. 값 이동: 값 v를 힙으로 이동시킵니다.
3. 포인터 반환: 힙 메모리를 가리키는 Box 객체를 반환합니다.

3.2. 예제: Box의 활용

{
    let point = Box::new((0.625, 0.5)); // 힙 메모리에 튜플 할당
    let label = format!("{:?}", point); // 포인터 값 읽어 문자열 생성
    assert_eq!(label, "(0.625, 0.5)");
} // point와 label이 범위를 벗어나면서 메모리 해제

이 코드의 메모리 구조는 스택 프레임과 힙 메모리 간의 소유권 관계를 보여줍니다:

• point는 힙에 저장된 튜플 (0.625, 0.5)의 소유자입니다.
• label은 point를 참조하여 생성된 문자열의 소유자입니다.
• 블록이 종료되면, 두 변수와 그들이 소유한 메모리가 함께 해제됩니다.

4. 일반적 상황에서의 소유권

Rust에서 변수는 자신이 소유한 값의 수명을 관리합니다. 마찬가지로 구조체, 튜플, 배열, 벡터 등은 다음과 같은 소유권 규칙을 따릅니다:

4.1. 예제: 복잡한 소유권 예제

struct Person { name: String, birth: i32 }

let mut composers = Vec::new();
composers.push(Person { name: "Palestrina".to_string(), birth: 1525 });
composers.push(Person { name: "Dowland".to_string(), birth: 1563 });
composers.push(Person { name: "Lully".to_string(), birth: 1632 });

for composer in &composers {
    println!("{}, born {}", composer.name, composer.birth);
}

 

• 소유권 관계:
  1. composers는 벡터를 소유합니다.
  2. 벡터는 자신의 요소(구조체 Person)를 소유합니다.
  3. 각 구조체는 자신의 필드(name과 birth)를 소유합니다.
  4. 문자열 필드 name은 자신의 텍스트를 소유합니다.

4.2. 소유권 해제와 정리

• 범위를 벗어나면 정리: composers가 스코프를 벗어나면, Rust는 소유권 체계를 역순으로 따라 모든 메모리를 해제합니다.
• 일관된 규칙: 다른 컬렉션(HashMap, BTreeSet 등)에서도 동일한 소유권 규칙이 적용됩니다.

4.3. 소유권 트리와 Rust의 메모리 관리

Rust의 모든 값은 단일 소유자를 가지며, 이는 값의 수명과 해제를 쉽게 예측할 수 있도록 합니다. 동시에 하나의 값은 여러 다른 값을 소유할 수 있습니다. 예를 들어:

• 벡터: composers 벡터는 여러 Person 구조체를 소유합니다.
• 구조체: 각 Person은 자신의 필드를 소유합니다.
• 문자열: 문자열 필드는 자신의 텍스트 데이터를 소유합니다.

이러한 관계는 트리 구조를 형성하며, 트리의 최상위 루트가 범위를 벗어나면 트리 전체가 해제됩니다. Rust의 소유권 트리는 값 간의 관계를 단순하게 유지하여, 복잡한 참조 그래프를 방지합니다.

5. Rust 소유권 정리

5.1. 언제 해제하는가?

Rust에서는 C나 C++에서 사용하는 free나 delete를 호출하지 않습니다. 대신, 다음과 같은 방식으로 메모리를 해제합니다:

1. 변수가 범위를 벗어날 때: 변수와 해당 값, 그리고 그 값이 소유한 모든 항목이 자동으로 해제됩니다.
2. 컬렉션에서 요소를 삭제할 때: 해당 요소와 관련된 모든 소유 항목이 함께 해제됩니다.

Rust의 이 접근 방식은 개발자의 명시적인 해제 코드를 줄이고, 메모리 누수나 잘못된 메모리 접근을 방지합니다.

5.2. Rust 소유권 강제의 장점

Rust의 단일 소유권 규칙은 언어가 더 단순한 관계를 강제하도록 만들어, Rust 프로그램의 구조를 더 쉽게 이해하고 관리할 수 있게 합니다. 이 단순함 덕분에 Rust는 다음과 같은 안전성을 제공합니다:

• 메모리 안전성: 잘못된 메모리 접근 방지
• 데이터 경합 방지: 멀티스레드 환경에서 데이터 동시 접근 문제 제거
• 명확한 수명 관리: 코드에서 값의 수명과 범위가 명확하게 보임

Rust의 이러한 제한은 언뜻 보면 언어의 유연성을 줄이는 것처럼 보일 수 있습니다. 그러나 이 제한은 코드 분석을 더 강력하게 만들어, 오류를 사전에 방지하는 데 기여합니다.

5.3. Rust 소유권의 확장 기능, 요소

Rust는 기본 소유권 개념에 유연성을 추가하기 위해 몇 가지 기능을 제공합니다:

1. 값 이동: 소유권을 다른 소유자로 이동시켜 트리를 생성하거나 재구성할 수 있습니다.
2. Copy 타입: 정수, 부동소수점, 문자와 같은 단순 타입은 복사 시 소유권을 이전하지 않습니다.
3. Rc와 Arc: 참조 카운트를 기반으로 한 포인터를 사용하여, 값을 제한된 조건에서 여러 소유자가 소유할 수 있습니다.
4. 참조(Borrow): 소유권을 가지지 않는 포인터를 사용하여 값을 참조할 수 있습니다. 이는 수명(lifetime) 제한이 적용됩니다.

5.4. C++과 Rust의 소유권 비교

개념	C++	Rust
소유권 관리	개발자가 직접 관리	언어가 자동으로 관리
메모리 해제	delete, free 명시적 호출	소유자가 범위를 벗어나면 자동
소유권 구조	자유로운 참조 그래프 가능	트리 구조로 제한
메모리 안전성	프로그래머의 책임	컴파일 타임에 안전성 보장
확장 기능	스마트 포인터 활용	Rc, Arc, Borrow 등 지원