C++ 개발자를 위한 Rust | 차이점과 전환 가이드

들어가며

C++에서 익숙한 수동 메모리 관리·RAII와 대비해, Rust는 소유권(열쇠 하나)·빌림(대여) 규칙으로 같은 문제를 컴파일 타임에 막는 쪽에 가깝습니다. 문법만 익히는 것보다 이 규칙에 익숙해지는 데 시간을 쓰는 편이 좋습니다.

---

1. 메모리 관리 비교

C++ 방식

#include <memory>

int main() {
    // 수동 메모리 관리
    int* ptr = new int(10);
    *ptr = 20;
    delete ptr;  // 수동 해제 필요
    
    // 스마트 포인터
    auto ptr1 = std::make_unique<int>(10);
    auto ptr2 = std::make_shared<int>(20);
    
    // 자동 해제 (RAII)
}

Rust 방식

fn main() {
    // 자동 메모리 관리
    let x = Box::new(10);
    
    {
        let y = Box::new(20);
    }  // y 자동 해제
    
    // x는 여전히 유효
    println!("{}", x);
}  // x 자동 해제

차이점: Rust는 소유권 시스템으로 컴파일 타임에 메모리 안전성을 보장합니다.

---

2. 소유권 (Ownership)

C++ - 복사 의미론

#include <string>

int main() {
    std::string s1 = "hello";
    std::string s2 = s1;  // 깊은 복사
    
    // s1, s2 모두 사용 가능
    std::cout << s1 << std::endl;
    std::cout << s2 << std::endl;
}

Rust - 이동 의미론

fn main() {
    let s1 = String::from("hello");
    let s2 = s1;  // 소유권 이동
    
    // println!("{}", s1);  // 컴파일 에러!
    println!("{}", s2);  // OK
    
    // 명시적 복사
    let s3 = String::from("world");
    let s4 = s3.clone();
    println!("{} {}", s3, s4);  // 둘 다 OK
}

참조 비교

// C++
void process(const std::string& s) {
    // 참조로 받음
}

// Rust
fn process(s: &String) {
    // 불변 참조
}

fn modify(s: &mut String) {
    // 가변 참조
}

---

3. Null 안전성

C++ - Null 포인터

int* ptr = nullptr;

if (ptr != nullptr) {
    *ptr = 10;
} else {
    std::cout << "Null 포인터" << std::endl;
}

Rust - Option

fn divide(a: i32, b: i32) -> Option<i32> {
    if b == 0 {
        None
    } else {
        Some(a / b)
    }
}

fn main() {
    match divide(10, 2) {
        Some(result) => println!("결과: {}", result),
        None => println!("0으로 나눌 수 없음"),
    }
    
    // 또는
    if let Some(result) = divide(10, 2) {
        println!("결과: {}", result);
    }
}

---

4. 에러 처리

C++ - 예외

#include <stdexcept>

int divide(int a, int b) {
    if (b == 0) {
        throw std::runtime_error("0으로 나눌 수 없음");
    }
    return a / b;
}

int main() {
    try {
        int result = divide(10, 0);
    } catch (const std::exception& e) {
        std::cout << "에러: " << e.what() << std::endl;
    }
}

Rust - Result<T, E>

fn divide(a: i32, b: i32) -> Result<i32, String> {
    if b == 0 {
        Err(String::from("0으로 나눌 수 없음"))
    } else {
        Ok(a / b)
    }
}

fn main() {
    match divide(10, 0) {
        Ok(result) => println!("결과: {}", result),
        Err(e) => println!("에러: {}", e),
    }
    
    // ? 연산자
    let result = divide(10, 2)?;
}

---

5. 동시성

C++ - 스레드

#include <thread>

void task() {
    // 작업
}

int main() {
    std::thread t(task);
    t.join();
}

Rust - 스레드

use std::thread;

fn main() {
    let handle = thread::spawn(|| {
        // 작업
    });
    
    handle.join().unwrap();
}

차이점: Rust는 컴파일 타임에 데이터 레이스를 방지합니다.

---

6. 비교표

특징	C++	Rust
메모리 안전	수동 (RAII)	자동 (소유권)
Null 포인터	가능	Option
데이터 레이스	런타임 에러	컴파일 에러
에러 처리	예외 (try-catch)	Result<T, E>
패키지 관리	CMake, vcpkg	Cargo
학습 곡선	가파름	매우 가파름
성능	매우 빠름	매우 빠름

---

7. 실전 예제

C++ 코드

#include <vector>
#include <memory>

class User {
public:
    std::string name;
    int age;
    
    User(std::string n, int a) : name(n), age(a) {}
};

int main() {
    std::vector<std::shared_ptr<User>> users;
    users.push_back(std::make_shared<User>("Alice", 30));
    users.push_back(std::make_shared<User>("Bob", 25));
    
    for (const auto& user : users) {
        std::cout << user->name << std::endl;
    }
}

Rust 변환

struct User {
    name: String,
    age: u32,
}

impl User {
    fn new(name: String, age: u32) -> Self {
        User { name, age }
    }
}

fn main() {
    let mut users = Vec::new();
    users.push(User::new(String::from("Alice"), 30));
    users.push(User::new(String::from("Bob"), 25));
    
    for user in &users {
        println!("{}", user.name);
    }
}

---

정리

핵심 요약

1. 메모리: Rust가 더 안전 (컴파일 타임 보장)
2. 소유권: Rust의 핵심 (이동 vs 복사)
3. Null: Option로 안전하게
4. 에러: Result<T, E>로 명시적 처리
5. 성능: 둘 다 비슷 (제로 코스트)

전환 팁

• 소유권 이해: 가장 중요한 개념
• 컴파일러 신뢰: 에러 메시지가 매우 친절함
• 작은 프로젝트부터: CLI 도구로 시작

다음 단계

• Rust 시작하기
• Rust 소유권
• C++ 환경 설정

---

관련 글

• C++와 Rust: 두 언어의 상호 운용성과 Memory Safety 논쟁의 실체 [#44-2]
• C++ vs Rust 완전 비교 | 소유권·메모리 안전성·에러 처리·동시성·성능 실전 가이드
• Rust vs C++ 메모리 안전성 | 컴파일러 오류 차이 [#47-3]
• C++ vs Python 비교 |
• 배열과 리스트 | 코딩 테스트 필수 자료구조 완벽 정리