Chapter 1: Rust 소개

1.1 Rust의 철학과 특징

1.1.1 Rust의 탄생 배경

Rust는 Mozilla Research의 Graydon Hoare가 2006년에 개인 프로젝트로 시작하여, 2010년 Mozilla의 지원을 받아 본격적으로 개발된 프로그래밍 언어입니다. 웹 브라우저 엔진을 더 안전하고 병렬적으로 개발하기 위한 목적으로 시작되었으며, 2015년 1.0 버전이 출시되었습니다.

1.1.2 핵심 철학

안전성(Safety): 메모리 안전성과 스레드 안전성을 컴파일 시점에 보장
동시성(Concurrency): 데이터 레이스 없는 동시성 프로그래밍 지원
성능(Performance): C/C++에 견줄만한 높은 성능
실용성(Practicality): 현대적인 개발자 도구와 풍부한 생태계

1.2 C와 Rust의 주요 차이점

1.2.1 메모리 관리

// C의 메모리 관리
int* data = malloc(sizeof(int));
*data = 42;
free(data);  // 수동 메모리 해제

// Rust의 메모리 관리
let data = Box::new(42);  // 자동으로 스코프 종료시 해제

1.2.2 타입 시스템

C: 약한 타입 시스템, 암시적 형변환 허용
Rust: 강한 타입 시스템, 명시적 형변환 필요

1.2.3 NULL 처리

// C의 NULL 처리
int* ptr = NULL;
if (ptr != NULL) {
    // 작업 수행
}

// Rust의 Option 타입
let option: Option<i32> = None;
if let Some(value) = option {
    // 작업 수행
}

1.2.4 에러 처리

// C의 에러 처리
if (operation() == -1) {
    // 에러 처리
    return -1;
}

// Rust의 Result 타입
match operation() {
    Ok(value) => // 성공 처리
    Err(e) => // 에러 처리
}

1.3 개발 환경 설정

1.3.1 Rust 설치

rustup 설치 (플랫폼별 설치 방법)
- Windows: rustup-init.exe 다운로드 및 실행
- macOS/Linux: curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
주요 구성 요소
- rustc: Rust 컴파일러
- cargo: 패키지 관리자
- rustup: 툴체인 관리자

1.3.2 Cargo 사용법

# 새 프로젝트 생성
cargo new hello_rust
cd hello_rust

# 빌드
cargo build

# 실행
cargo run

# 릴리즈 빌드
cargo build --release

1.3.3 프로젝트 구조

hello_rust/
├── Cargo.toml    # 프로젝트 설정 파일
├── Cargo.lock    # 의존성 버전 고정 파일
└── src/
    └── main.rs   # 소스 코드

1.3.4 첫 번째 Rust 프로그램

// src/main.rs
fn main() {
    println!("Hello, Rust!");
}

1.4 C 개발자를 위한 팁

1.4.1 주요 차이점 요약

가비지 컬렉션 없이 메모리 안전성 보장
포인터 대신 참조자(Reference) 사용
헤더 파일 대신 모듈 시스템 사용
빌드 시스템과 패키지 관리자 통합

1.4.2 개발 도구 추천

VS Code + rust-analyzer
CLion + Rust 플러그인
IntelliJ IDEA + Rust 플러그인

연습 문제

Rust를 설치하고 "Hello, World!" 프로그램을 작성해보세요.
C의 포인터를 사용하는 간단한 프로그램을 Rust로 변환해보세요.
Cargo.toml 파일을 수정하여 외부 크레이트를 추가해보세요.

Chapter 2: C 개발자를 위한 기본 문법

2.1 변수와 상수

2.1.1 변수 선언과 초기화

C에서는 변수가 기본적으로 가변(mutable)이지만, Rust에서는 기본적으로 불변(immutable)입니다.

// C의 변수 선언
int x = 5;
x = 6;  // 가능

// Rust의 변수 선언
let x = 5;    // 불변
let mut y = 5; // 가변
y = 6;        // 가능
x = 6;        // 컴파일 에러!

2.1.2 상수

// C의 상수
#define MAX_POINTS 100000
const int MAX_POINTS = 100000;

// Rust의 상수
const MAX_POINTS: u32 = 100_000;

2.2 기본 데이터 타입

2.2.1 정수형

C	Rust	설명
char	i8	8비트 부호 있는 정수
unsigned char	u8	8비트 부호 없는 정수
short	i16	16비트 부호 있는 정수
int	i32	32비트 부호 있는 정수
long	i64	64비트 부호 있는 정수

2.2.2 부동소수점

let x: f64 = 2.0; // 64비트 부동소수점
let y: f32 = 3.0; // 32비트 부동소수점

2.2.3 불리언

let t: bool = true;
let f: bool = false;

2.2.4 문자와 문자열

// C의 문자열
char str[] = "Hello";

// Rust의 문자열
let s: &str = "Hello";           // 문자열 슬라이스
let string: String = String::from("Hello"); // 소유된 문자열

2.3 제어문

2.3.1 조건문

let number = 6;

// if-else
if number % 4 == 0 {
    println!("number is divisible by 4");
} else if number % 3 == 0 {
    println!("number is divisible by 3");
} else {
    println!("number is not divisible by 4 or 3");
}

// if는 표현식
let condition = true;
let number = if condition { 5 } else { 6 };

2.3.2 반복문

// while 루프
let mut number = 3;
while number != 0 {
    println!("{}!", number);
    number -= 1;
}

// for 루프
for i in 0..5 {
    println!("{}!", i);
}

// loop (무한 루프)
loop {
    println!("again!");
    break; // 루프 탈출
}

2.4 함수

2.4.1 함수 정의

// C의 함수
int add(int a, int b) {
    return a + b;
}

// Rust의 함수
fn add(a: i32, b: i32) -> i32 {
    a + b  // 마지막 표현식이 반환값
}

fn add_with_return(a: i32, b: i32) -> i32 {
    return a + b;  // 명시적 반환도 가능
}

2.4.2 함수 포인터

// C의 함수 포인터
int (*operation)(int, int);
operation = add;

// Rust의 함수 포인터
let operation: fn(i32, i32) -> i32 = add;

2.5 포인터와 참조자

2.5.1 기본 개념

// C의 포인터
int x = 5;
int *ptr = &x;
*ptr = 6;

// Rust의 참조자
let mut x = 5;
let ptr = &mut x;
*ptr = 6;

2.5.2 주요 차이점

Rust의 참조자는 NULL이 될 수 없음
가변 참조자는 한 번에 하나만 존재 가능
참조자의 수명이 컴파일 시점에 검증됨

연습 문제

다음 C 코드를 Rust로 변환해보세요:

int sum(int* arr, int size) {
    int total = 0;
    for(int i = 0; i < size; i++) {
        total += arr[i];
    }
    return total;
}

Rust의 String과 &str 타입의 차이점을 이해하고, 각각을 사용하는 함수를 작성해보세요.
Rust의 불변성을 활용하여 C 코드를 더 안전하게 재작성해보세요.

Chapter 3: 메모리 관리의 혁신

3.1 소유권(Ownership) 개념

3.1.1 소유권 규칙

Rust의 각 값은 소유자(owner)라고 불리는 변수를 가집니다.
한 번에 하나의 소유자만 존재할 수 있습니다.
소유자가 스코프를 벗어나면 값은 자동으로 해제됩니다.

{
    let s1 = String::from("hello"); // s1은 문자열의 소유자
    let s2 = s1;                    // 소유권이 s2로 이동 (move)
    // println!("{}", s1);          // 컴파일 에러! s1은 더 이상 유효하지 않음
}  // s2가 스코프를 벗어나면서 메모리 자동 해제

3.1.2 C와의 비교

// C의 메모리 관리
char* str = malloc(6);
strcpy(str, "hello");
char* str2 = str;     // 두 포인터가 같은 메모리를 가리킴
printf("%s\n", str);  // 여전히 사용 가능
printf("%s\n", str2); // 둘 다 같은 메모리 사용
free(str);           // 수동으로 메모리 해제
// str2는 이제 댕글링 포인터

3.2 C의 malloc/free vs Rust의 RAII

3.2.1 RAII(Resource Acquisition Is Initialization)

struct Buffer {
    data: Box<[u8]>,
}

impl Buffer {
    fn new(size: usize) -> Buffer {
        Buffer {
            data: vec![0; size].into_boxed_slice(),
        }
    }
}
// Buffer가 스코프를 벗어나면 자동으로 메모리 해제

3.2.2 스마트 포인터

// Box<T> - 힙 할당
let x = Box::new(5);

// Rc<T> - 참조 카운팅
use std::rc::Rc;
let data = Rc::new(vec![1, 2, 3]);
let data2 = data.clone();  // 참조 카운트 증가

// Arc<T> - 원자적 참조 카운팅 (스레드 안전)
use std::sync::Arc;
let shared_data = Arc::new(vec![1, 2, 3]);

3.3 빌림(Borrowing)과 참조

3.3.1 불변 참조

fn calculate_length(s: &String) -> usize {
    s.len()
}

let s1 = String::from("hello");
let len = calculate_length(&s1);
// s1은 여전히 유효

3.3.2 가변 참조

fn modify_string(s: &mut String) {
    s.push_str(" world");
}

let mut s1 = String::from("hello");
modify_string(&mut s1);
println!("{}", s1); // "hello world"

3.3.3 참조 규칙

한 시점에 하나의 가변 참조 또는 여러 불변 참조 가능
참조는 항상 유효해야 함

3.4 수명(Lifetime) 이해하기

3.4.1 수명 표기

// 명시적 수명 매개변수
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

3.4.2 구조체의 수명

struct StringHolder<'a> {
    text: &'a str,
}

impl<'a> StringHolder<'a> {
    fn get_str(&self) -> &str {
        self.text
    }
}

3.5 메모리 안전성 보장 메커니즘

3.5.1 컴파일 시점 검사

소유권 이동 추적
빌림 규칙 검증
수명 검증

3.5.2 런타임 오버헤드 없음

// Rust의 메모리 안전성은 컴파일 시점에 보장
let numbers = vec![1, 2, 3, 4, 5];
let first = &numbers[0];
// let first = &numbers[10]; // 컴파일 에러: 범위 체크

println!("첫 번째 요소: {}", first);

연습 문제

다음 C 코드를 Rust의 소유권 시스템을 사용하여 재작성해보세요:

void process_string(char* str) {
    str[0] = 'H';
    printf("%s\n", str);
}

int main() {
    char* text = malloc(6);
    strcpy(text, "hello");
    process_string(text);
    free(text);
    return 0;
}

다음 상황에서 적절한 스마트 포인터를 선택하고 구현해보세요:
- 여러 소유자가 필요한 데이터 구조
- 스레드 간 공유가 필요한 데이터
- 큰 데이터의 힙 할당
수명이 다른 두 참조를 받아서 처리하는 함수를 작성해보세요.

추가 학습 자료

Rust 공식 문서의 소유권 장
실제 프로젝트에서의 메모리 관리 사례
Rust의 스마트 포인터 상세 문서

Chapter 4: 구조체와 열거형

4.1 C struct vs Rust struct

4.1.1 기본 구조체 정의

// C의 구조체
struct Point {
    int x;
    int y;
};

struct Point p = {10, 20};

// Rust의 구조체
struct Point {
    x: i32,
    y: i32,
}

let p = Point { x: 10, y: 20 };

4.1.2 구조체의 메모리 레이아웃

// 메모리 정렬과 패딩
#[repr(C)]  // C와 동일한 메모리 레이아웃 사용
struct AlignedStruct {
    a: u8,    // 1바이트
    b: i32,   // 4바이트
    c: u8,    // 1바이트
}

4.2 impl 블록과 메서드

4.2.1 메서드 구현

impl Point {
    // 생성자 역할의 연관 함수
    fn new(x: i32, y: i32) -> Point {
        Point { x, y }
    }

    // 인스턴스 메서드
    fn distance_from_origin(&self) -> f64 {
        ((self.x.pow(2) + self.y.pow(2)) as f64).sqrt()
    }

    // 가변 메서드
    fn move_by(&mut self, dx: i32, dy: i32) {
        self.x += dx;
        self.y += dy;
    }
}

// 사용 예
let mut point = Point::new(3, 4);
println!("Distance: {}", point.distance_from_origin());
point.move_by(2, 2);

4.2.2 트레이트 구현

// Debug 트레이트 자동 구현
#[derive(Debug)]
struct Rectangle {
    width: u32,
    height: u32,
}

// 사용자 정의 트레이트 구현
trait Area {
    fn area(&self) -> u32;
}

impl Area for Rectangle {
    fn area(&self) -> u32 {
        self.width * self.height
    }
}

4.3 열거형과 패턴 매칭

4.3.1 기본 열거형

// C의 열거형
enum Color {
    RED,
    GREEN,
    BLUE
};

// Rust의 열거형
enum Color {
    Red,
    Green,
    Blue,
}

// 데이터를 포함하는 열거형
enum Shape {
    Circle(f64),              // 반지름
    Rectangle(f64, f64),      // 너비, 높이
    Triangle(f64, f64, f64),  // 세 변의 길이
}

4.3.2 패턴 매칭

fn describe_shape(shape: Shape) -> String {
    match shape {
        Shape::Circle(radius) => {
            format!("원: 반지름 = {}", radius)
        }
        Shape::Rectangle(width, height) => {
            format!("직사각형: 너비 = {}, 높이 = {}", width, height)
        }
        Shape::Triangle(a, b, c) => {
            format!("삼각형: 변의 길이 = {}, {}, {}", a, b, c)
        }
    }
}

4.4 Option과 Result 타입

4.4.1 Option 타입

// NULL 대신 Option 사용
fn divide(numerator: f64, denominator: f64) -> Option<f64> {
    if denominator == 0.0 {
        None
    } else {
        Some(numerator / denominator)
    }
}

// Option 처리
let result = divide(10.0, 2.0);
match result {
    Some(value) => println!("결과: {}", value),
    None => println!("0으로 나눌 수 없습니다"),
}

// if let 사용
if let Some(value) = divide(10.0, 2.0) {
    println!("결과: {}", value);
}

4.4.2 Result 타입

use std::fs::File;

// 에러 처리
fn open_file(path: &str) -> Result<File, std::io::Error> {
    File::open(path)
}

match open_file("config.txt") {
    Ok(file) => println!("파일 열기 성공"),
    Err(error) => println!("에러: {}", error),
}

// ? 연산자 사용
fn read_config() -> Result<String, std::io::Error> {
    let mut file = File::open("config.txt")?;
    let mut content = String::new();
    file.read_to_string(&mut content)?;
    Ok(content)
}

4.5 고급 패턴 매칭

4.5.1 복잡한 패턴

enum Message {
    Move { x: i32, y: i32 },
    Write(String),
    ChangeColor(Color),
}

match message {
    Message::Move { x, y } => println!("이동: x={}, y={}", x, y),
    Message::Write(text) if text.len() < 10 => println!("짧은 메시지: {}", text),
    Message::Write(text) => println!("긴 메시지: {}", text),
    Message::ChangeColor(Color::Red) => println!("빨간색으로 변경"),
    Message::ChangeColor(_) => println!("다른 색상으로 변경"),
}

4.5.2 가드를 사용한 패턴 매칭

let number = Some(4);

match number {
    Some(x) if x < 5 => println!("5보다 작은 수: {}", x),
    Some(x) => println!("5 이상의 수: {}", x),
    None => println!("값이 없습니다"),
}

연습 문제

다음 C 구조체를 Rust로 변환하고 메서드를 추가해보세요:

struct Employee {
    char name[50];
    int age;
    float salary;
};

Result와 Option을 조합하여 사용하는 함수를 작성해보세요. 예를 들어, 파일에서 숫자를 읽어 나누기를 수행하는 함수를 만들어보세요.
다음 상황을 모델링하는 열거형을 만들고 패턴 매칭을 사용해보세요:
- 도형의 넓이 계산 (원, 사각형, 삼각형)
- 계산기 연산 (더하기, 빼기, 곱하기, 나누기)
- 네트워크 패킷 처리 (연결, 데이터 전송, 연결 종료)

Chapter 5: 모듈과 패키지 시스템

5.1 C의 헤더 파일 vs Rust의 모듈

5.1.1 기본 차이점

// C의 헤더 파일 (math.h)
#ifndef MATH_H
#define MATH_H

int add(int a, int b);
int subtract(int a, int b);

#endif

// C의 구현 파일 (math.c)
#include "math.h"

int add(int a, int b) {
    return a + b;
}

int subtract(int a, int b) {
    return a - b;
}

// Rust의 모듈 (math.rs)
pub fn add(a: i32, b: i32) -> i32 {
    a + b
}

pub fn subtract(a: i32, b: i32) -> i32 {
    a - b
}

// main.rs에서 사용
mod math;
use math::{add, subtract};

5.1.2 모듈 트리 구조

mod front_of_house {
    pub mod hosting {
        pub fn add_to_waitlist() {}
        fn seat_at_table() {}
    }

    mod serving {
        fn take_order() {}
        fn serve_order() {}
        fn take_payment() {}
    }
}

pub fn eat_at_restaurant() {
    front_of_house::hosting::add_to_waitlist();
}

5.2 Cargo.toml과 의존성 관리

5.2.1 기본 Cargo.toml 구조

[package]
name = "my_project"
version = "0.1.0"
edition = "2021"
authors = ["Your Name <your.email@example.com>"]

[dependencies]
serde = { version = "1.0", features = ["derive"] }
tokio = { version = "1.0", features = ["full"] }
reqwest = "0.11"

[dev-dependencies]
criterion = "0.3"

[build-dependencies]
cc = "1.0"

5.2.2 의존성 버전 관리

[dependencies]
# 정확한 버전
time = "=0.1.12"

# 범위 지정
rand = ">=0.5.0, <0.7.0"

# 패치 버전만 업데이트
serde = "~1.0.0"  # 1.0.0 <= version < 1.1.0

# 마이너 버전까지 업데이트
log = "^1.0.0"    # 1.0.0 <= version < 2.0.0

5.3 가시성과 접근 제어

5.3.1 기본 규칙

mod plant {
    pub struct Vegetable {
        pub name: String,
        id: i32,  // 비공개 필드
    }

    impl Vegetable {
        pub fn new(name: &str) -> Vegetable {
            Vegetable {
                name: String::from(name),
                id: 1,
            }
        }
    }
}

fn main() {
    let mut v = plant::Vegetable::new("당근");
    v.name = String::from("오이");
    // v.id = 2;  // 에러: 비공개 필드
}

5.3.2 use 키워드

use std::collections::{HashMap, HashSet};
use std::fmt::Result;
use std::io::Result as IoResult;  // 이름 충돌 방지

// 재내보내기
pub use crate::front_of_house::hosting;

5.4 외부 크레이트 사용하기

5.4.1 크레이트 추가

# 명령줄에서 크레이트 추가
cargo add serde --features derive

5.4.2 크레이트 사용 예제

use serde::{Serialize, Deserialize};

#[derive(Serialize, Deserialize, Debug)]
struct Point {
    x: i32,
    y: i32,
}

fn main() {
    let point = Point { x: 1, y: 2 };
    let json = serde_json::to_string(&point).unwrap();
    println!("직렬화된 데이터: {}", json);
}

5.5 작업공간(Workspace)

5.5.1 작업공간 구성

# Cargo.toml
[workspace]
members = [
    "adder",
    "add-one",
    "add-two",
]

workspace/
  ├── Cargo.toml
  ├── adder/
  │   ├── Cargo.toml
  │   └── src/
  ├── add-one/
  │   ├── Cargo.toml
  │   └── src/
  └── add-two/
      ├── Cargo.toml
      └── src/

5.5.2 작업공간 내 의존성

# adder/Cargo.toml
[dependencies]
add-one = { path = "../add-one" }
add-two = { path = "../add-two" }

5.6 테스트와 문서화

5.6.1 단위 테스트

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn it_works() {
        let result = add(2, 2);
        assert_eq!(result, 4);
    }
}

5.6.2 문서 주석

/// 두 수를 더합니다.
///
/// # 예제
///
/// ```
/// let sum = my_crate::add(1, 2);
/// assert_eq!(sum, 3);
/// ```
pub fn add(a: i32, b: i32) -> i32 {
    a + b
}

연습 문제

다음 C 프로젝트를 Rust 모듈 구조로 변환해보세요:

// utils.h, utils.c
// math.h, math.c
// main.c

다음 요구사항을 만족하는 Cargo.toml을 작성해보세요:
- JSON 직렬화/역직렬화 지원
- 비동기 HTTP 클라이언트
- 로깅 기능
- CLI 인터페이스
작업공간을 만들고 다음 구조의 프로젝트를 구현해보세요:
- 코어 라이브러리
- CLI 도구
- 웹 서버
- 공통 유틸리티

Chapter 6: 동시성 프로그래밍

6.1 C의 쓰레드 vs Rust의 쓰레드

6.1.1 기본 쓰레드 생성

// C의 쓰레드
#include <pthread.h>

void* thread_function(void* arg) {
    printf("Thread running\n");
    return NULL;
}

int main() {
    pthread_t thread;
    pthread_create(&thread, NULL, thread_function, NULL);
    pthread_join(thread, NULL);
    return 0;
}

// Rust의 쓰레드
use std::thread;

fn main() {
    let handle = thread::spawn(|| {
        println!("Thread running");
    });

    handle.join().unwrap();
}

6.1.2 데이터 공유

use std::thread;
use std::sync::Arc;  // 원자적 참조 카운팅

fn main() {
    let data = Arc::new(vec![1, 2, 3, 4]);
    let mut handles = vec![];

    for i in 0..3 {
        let data_clone = Arc::clone(&data);
        let handle = thread::spawn(move || {
            println!("Thread {}: {:?}", i, *data_clone);
        });
        handles.push(handle);
    }

    for handle in handles {
        handle.join().unwrap();
    }
}

6.2 메시지 패싱과 채널

6.2.1 기본 채널 사용

use std::sync::mpsc;
use std::thread;

fn main() {
    let (tx, rx) = mpsc::channel();

    thread::spawn(move || {
        let messages = vec![
            String::from("안녕"),
            String::from("from"),
            String::from("thread"),
        ];

        for msg in messages {
            tx.send(msg).unwrap();
        }
    });

    for received in rx {
        println!("받은 메시지: {}", received);
    }
}

6.2.2 다중 프로듀서

use std::sync::mpsc;
use std::thread;

fn main() {
    let (tx, rx) = mpsc::channel();
    let tx1 = tx.clone();

    thread::spawn(move || {
        tx.send("sender 1").unwrap();
    });

    thread::spawn(move || {
        tx1.send("sender 2").unwrap();
    });

    for received in rx {
        println!("Got: {}", received);
    }
}

6.3 뮤텍스와 동기화

6.3.1 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());
}

6.3.2 RwLock 사용

use std::sync::{Arc, RwLock};
use std::thread;

fn main() {
    let data = Arc::new(RwLock::new(vec![1, 2, 3, 4]));
    let mut handles = vec![];

    // 읽기 쓰레드
    for _ in 0..3 {
        let data_ref = Arc::clone(&data);
        handles.push(thread::spawn(move || {
            let numbers = data_ref.read().unwrap();
            println!("Read: {:?}", *numbers);
        }));
    }

    // 쓰기 쓰레드
    let data_ref = Arc::clone(&data);
    handles.push(thread::spawn(move || {
        let mut numbers = data_ref.write().unwrap();
        numbers.push(5);
    }));

    for handle in handles {
        handle.join().unwrap();
    }
}

6.4 Send와 Sync 트레이트

6.4.1 Send 트레이트

// Send 구현 예제
#[derive(Debug)]
struct MySendType {
    data: Vec<i32>,
}

// 자동으로 Send 구현
unsafe impl Send for MySendType {}

fn main() {
    let data = MySendType { data: vec![1, 2, 3] };
    thread::spawn(move || {
        println!("{:?}", data);
    }).join().unwrap();
}

6.4.2 Sync 트레이트

use std::sync::atomic::{AtomicI32, Ordering};
use std::sync::Arc;

struct MySyncCounter {
    count: AtomicI32,
}

impl MySyncCounter {
    fn new() -> Self {
        MySyncCounter {
            count: AtomicI32::new(0),
        }
    }

    fn increment(&self) {
        self.count.fetch_add(1, Ordering::SeqCst);
    }

    fn get_count(&self) -> i32 {
        self.count.load(Ordering::SeqCst)
    }
}

6.5 비동기 프로그래밍

6.5.1 async/await 기본

use tokio;

#[tokio::main]
async fn main() {
    let result = async_operation().await;
    println!("Result: {}", result);
}

async fn async_operation() -> String {
    tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
    String::from("Operation completed")
}

6.5.2 Future 조합

use futures::future::{self, Future};

async fn combine_futures() {
    let future1 = async { "Hello" };
    let future2 = async { "World" };

    let combined = future::join(future1, future2).await;
    println!("{} {}", combined.0, combined.1);
}

연습 문제

다음 C 코드를 Rust의 thread-safe한 버전으로 변환해보세요:

#include <pthread.h>

int counter = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

void* increment(void* arg) {
    for(int i = 0; i < 1000; i++) {
        pthread_mutex_lock(&mutex);
        counter++;
        pthread_mutex_unlock(&mutex);
    }
    return NULL;
}

생산자-소비자 패턴을 구현해보세요:
- 다수의 생산자가 데이터를 생성
- 다수의 소비자가 데이터를 처리
- 채널을 사용하여 통신
다음 기능을 가진 비동기 웹 서버를 구현해보세요:
- 동시에 여러 요청 처리
- 타임아웃 처리
- 에러 처리

Chapter 7: 안전한 시스템 프로그래밍

7.1 unsafe 블록의 적절한 사용

7.1.1 unsafe가 필요한 경우

원시 포인터 역참조
안전하지 않은 함수 호출
가변 정적 변수 접근
외부 함수 인터페이스 구현
Union 접근

7.1.2 원시 포인터 다루기

fn main() {
    let mut num = 5;

    // 원시 포인터 생성
    let raw = &mut num as *mut i32;

    // 안전하지 않은 블록에서 사용
    unsafe {
        *raw = 6;
        println!("raw value: {}", *raw);
    }
}

7.1.3 안전한 추상화 만들기

pub struct SafeWrapper {
    ptr: *mut i32,
}

impl SafeWrapper {
    pub fn new(value: i32) -> Self {
        let boxed = Box::new(value);
        let ptr = Box::into_raw(boxed);
        SafeWrapper { ptr }
    }

    pub fn get(&self) -> i32 {
        unsafe { *self.ptr }
    }

    pub fn set(&mut self, value: i32) {
        unsafe {
            *self.ptr = value;
        }
    }
}

impl Drop for SafeWrapper {
    fn drop(&mut self) {
        unsafe {
            drop(Box::from_raw(self.ptr));
        }
    }
}

7.2 FFI와 C 코드 연동

7.2.1 C 함수 호출하기

// C 함수 선언
#[link(name = "m")]
extern "C" {
    fn sqrt(x: f64) -> f64;
    fn abs(x: i32) -> i32;
}

fn main() {
    unsafe {
        println!("sqrt(16.0) = {}", sqrt(16.0));
        println!("abs(-42) = {}", abs(-42));
    }
}

7.2.2 Rust 함수를 C에서 호출하기

#[no_mangle]
pub extern "C" fn rust_function(x: i32) -> i32 {
    x * 2
}

// C 코드에서 사용
/*
extern int rust_function(int x);

int main() {
    printf("%d\n", rust_function(21));
    return 0;
}
*/

7.2.3 데이터 구조 공유

#[repr(C)]
struct SharedStruct {
    x: i32,
    y: f64,
}

extern "C" {
    fn process_struct(data: *mut SharedStruct);
}

fn main() {
    let mut data = SharedStruct { x: 42, y: 3.14 };
    unsafe {
        process_struct(&mut data);
    }
}

7.3 시스템 콜 다루기

7.3.1 직접 시스템 콜 사용

use std::io::{self, Error};

#[cfg(target_os = "linux")]
fn get_pid() -> io::Result<i32> {
    unsafe {
        let pid = libc::getpid();
        Ok(pid)
    }
}

#[cfg(target_os = "linux")]
fn create_directory(path: &str, mode: u32) -> io::Result<()> {
    use std::ffi::CString;

    let path = CString::new(path)?;
    let ret = unsafe {
        libc::mkdir(path.as_ptr(), mode)
    };

    if ret == 0 {
        Ok(())
    } else {
        Err(Error::last_os_error())
    }
}

7.3.2 안전한 래퍼 만들기

struct File {
    fd: i32,
}

impl File {
    pub fn open(path: &str) -> io::Result<File> {
        use std::ffi::CString;

        let path = CString::new(path)?;
        let fd = unsafe {
            libc::open(path.as_ptr(), libc::O_RDONLY)
        };

        if fd < 0 {
            Err(Error::last_os_error())
        } else {
            Ok(File { fd })
        }
    }
}

impl Drop for File {
    fn drop(&mut self) {
        unsafe {
            libc::close(self.fd);
        }
    }
}

7.4 포인터 조작과 메모리 관리

7.4.1 메모리 정렬과 레이아웃

#[repr(C, packed)]
struct PackedStruct {
    byte: u8,
    int: i32,
    double: f64,
}

#[repr(align(8))]
struct AlignedStruct {
    byte: u8,
    int: i32,
}

fn main() {
    println!("PackedStruct size: {}", std::mem::size_of::<PackedStruct>());
    println!("AlignedStruct size: {}", std::mem::size_of::<AlignedStruct>());
}

7.4.2 커스텀 할당자

use std::alloc::{GlobalAlloc, Layout, System};

struct CustomAllocator;

unsafe impl GlobalAlloc for CustomAllocator {
    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
        println!("Allocating {} bytes", layout.size());
        System.alloc(layout)
    }

    unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
        println!("Deallocating {} bytes", layout.size());
        System.dealloc(ptr, layout)
    }
}

#[global_allocator]
static ALLOCATOR: CustomAllocator = CustomAllocator;

연습 문제

다음 C 함수를 Rust에서 안전하게 래핑해보세요:

void* memcpy(void* dest, const void* src, size_t n);
char* strdup(const char* s);

시스템 콜을 사용하여 다음 기능을 구현해보세요:
- 파일 복사
- 디렉토리 생성 및 삭제
- 프로세스 정보 조회
메모리 풀 할당자를 구현해보세요:
- 고정 크기 블록 관리
- 메모리 재사용
- 스레드 안전성 보장
unsafe 블록을 사용하되 안전한 인터페이스를 제공하는 데이터 구조를 설계해보세요:
- 더블 링크드 리스트
- 순환 버퍼
- 메모리 매핑된 파일

Chapter 8: 고급 기능

8.1 제네릭스와 트레이트

8.1.1 제네릭 함수와 구조체

// 제네릭 구조체
struct Point<T> {
    x: T,
    y: T,
}

// 제네릭 함수
fn swap<T>(a: &mut T, b: &mut T) {
    std::mem::swap(a, b);
}

// 제네릭 구현
impl<T> Point<T> {
    fn new(x: T, y: T) -> Self {
        Point { x, y }
    }
}

8.1.2 트레이트 정의와 구현

// 트레이트 정의
trait Display {
    fn display(&self) -> String;

    // 기본 구현
    fn default_display(&self) -> String {
        String::from("Default display")
    }
}

// 트레이트 구현
impl Display for Point<f64> {
    fn display(&self) -> String {
        format!("({}, {})", self.x, self.y)
    }
}

// 트레이트 바운드
fn print_item<T: Display>(item: &T) {
    println!("{}", item.display());
}

8.1.3 트레이트 객체

// 동적 디스패치
fn process_displayable(items: Vec<Box<dyn Display>>) {
    for item in items {
        println!("{}", item.display());
    }
}

// 트레이트 객체 사용
let items: Vec<Box<dyn Display>> = vec![
    Box::new(Point::new(1.0, 2.0)),
    Box::new(String::from("Hello")),
];

8.2 매크로 시스템

8.2.1 선언적 매크로

// 기본 매크로 정의
macro_rules! say_hello {
    () => {
        println!("Hello!");
    };
    ($name:expr) => {
        println!("Hello, {}!", $name);
    };
}

// 반복 매크로
macro_rules! create_function {
    ($func_name:ident, $type:ty) => {
        fn $func_name(x: $type) -> $type {
            x
        }
    };
}

create_function!(foo, i32);

8.2.2 절차적 매크로

use proc_macro;

#[proc_macro_derive(MyDerive)]
pub fn my_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
    // 매크로 구현
    let ast = syn::parse(input).unwrap();
    // AST 처리
    quote!{
        // 생성된 코드
    }.into()
}

// 속성 매크로
#[proc_macro_attribute]
pub fn route(attr: TokenStream, item: TokenStream) -> TokenStream {
    // 매크로 구현
}

8.3 스마트 포인터

8.3.1 Box

// 힙 할당
let boxed = Box::new(5);

// 재귀적 데이터 구조
enum List {
    Cons(i32, Box<List>),
    Nil,
}

8.3.2 Rc와 Arc

use std::rc::Rc;
use std::sync::Arc;
use std::thread;

// 참조 카운팅
let data = Rc::new(vec![1, 2, 3]);
let data2 = Rc::clone(&data);

// 원자적 참조 카운팅
let shared = Arc::new(vec![1, 2, 3]);
let shared2 = Arc::clone(&shared);

thread::spawn(move || {
    println!("{:?}", *shared2);
});

8.3.3 RefCell와 Cell

use std::cell::{RefCell, Cell};

// 내부 가변성
let data = RefCell::new(5);
*data.borrow_mut() += 1;
println!("{}", data.borrow());

// Cell 사용
let cell = Cell::new(1);
cell.set(2);
println!("{}", cell.get());

8.4 에러 처리 전략

8.4.1 사용자 정의 에러 타입

#[derive(Debug)]
pub enum CustomError {
    IoError(std::io::Error),
    ParseError(std::num::ParseIntError),
    Other(String),
}

impl std::error::Error for CustomError {}

impl From<std::io::Error> for CustomError {
    fn from(err: std::io::Error) -> CustomError {
        CustomError::IoError(err)
    }
}

8.4.2 Result 체이닝

use std::fs::File;
use std::io::Read;

fn read_file_contents(path: &str) -> Result<String, CustomError> {
    let mut file = File::open(path)?;
    let mut contents = String::new();
    file.read_to_string(&mut contents)?;
    Ok(contents)
}

8.4.3 에러 처리 매크로

// anyhow 크레이트 사용
use anyhow::{Context, Result};

fn complex_operation() -> Result<()> {
    let file = File::open("config.txt")
        .context("설정 파일을 열 수 없습니다")?;

    // 작업 수행
    Ok(())
}

연습 문제

다음 기능을 갖는 제네릭 데이터 구조를 구현해보세요:
- 이진 검색 트리
- 우선순위 큐
- 해시맵
다음과 같은 매크로를 작성해보세요:
- JSON 객체 생성 매크로
- 테스트 케이스 생성 매크로
- SQL 쿼리 빌더 매크로
커스텀 스마트 포인터를 구현해보세요:
- 참조 카운팅 포인터
- 순환 참조를 방지하는 포인터
- 로깅 기능이 있는 포인터
다음 상황에 대한 에러 처리 전략을 설계해보세요:
- 네트워크 요청 처리
- 파일 시스템 작업
- 데이터베이스 연동

Chapter 9: 실전 프로젝트

9.1 C 프로그램을 Rust로 포팅하기

9.1.1 포팅 전략

코드 분석 단계
- 의존성 파악
- 메모리 관리 패턴 식별
- 전역 상태 식별
- 동시성 패턴 분석
점진적 포팅

// C 코드
/*
typedef struct {
    int *data;
    size_t size;
} Array;

Array* create_array(size_t size) {
    Array* arr = malloc(sizeof(Array));
    arr->data = malloc(size * sizeof(int));
    arr->size = size;
    return arr;
}
*/

// Rust 포팅
pub struct Array {
    data: Vec<i32>,
}

impl Array {
    pub fn new(size: usize) -> Self {
        Array {
            data: Vec::with_capacity(size),
        }
    }
}

9.1.2 FFI 브리지 작성

#[no_mangle]
pub extern "C" fn rust_array_create(size: usize) -> *mut Array {
    let array = Box::new(Array::new(size));
    Box::into_raw(array)
}

#[no_mangle]
pub extern "C" fn rust_array_free(ptr: *mut Array) {
    if !ptr.is_null() {
        unsafe {
            drop(Box::from_raw(ptr));
        }
    }
}

9.2 성능 최적화 기법

9.2.1 프로파일링

// 시간 측정
use std::time::Instant;

fn measure_time<F, T>(f: F) -> (T, std::time::Duration)
where
    F: FnOnce() -> T,
{
    let start = Instant::now();
    let result = f();
    let duration = start.elapsed();
    (result, duration)
}

// 사용 예
let (result, duration) = measure_time(|| {
    // 측정할 코드
    expensive_operation()
});
println!("Duration: {:?}", duration);

9.2.2 메모리 최적화

// 메모리 사용량 최적화
#[derive(Debug)]
struct CompactData {
    // 비트 필드 사용
    flags: u8,
    // 열거형 최적화
    #[repr(u8)]
    status: Status,
    // 벡터 용량 최적화
    data: Vec<u8>,
}

impl CompactData {
    fn new() -> Self {
        CompactData {
            flags: 0,
            status: Status::Inactive,
            data: Vec::with_capacity(16), // 초기 용량 지정
        }
    }
}

9.2.3 병렬화

use rayon::prelude::*;

fn parallel_process<T: Send>(data: &[T]) -> Vec<T>
where
    T: Clone + Send + Sync,
{
    data.par_iter()
        .map(|item| process_item(item))
        .collect()
}

9.3 디버깅과 테스팅

9.3.1 디버깅 도구

// RUST_BACKTRACE 환경변수 사용
fn main() {
    println!("디버그 빌드: {}", cfg!(debug_assertions));

    // 조건부 컴파일
    #[cfg(debug_assertions)]
    println!("디버그 정보 출력");

    // 디버그 매크로 사용
    dbg!(calculate_something());
}

9.3.2 단위 테스트

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_basic_functionality() {
        let result = add_numbers(2, 2);
        assert_eq!(result, 4);
    }

    #[test]
    #[should_panic(expected = "패닉 메시지")]
    fn test_panic_case() {
        // 패닉이 예상되는 테스트
    }

    #[test]
    fn test_result_handling() -> Result<(), String> {
        let value = operation_that_might_fail()?;
        Ok(())
    }
}

9.3.3 통합 테스트

// tests/integration_test.rs
use my_crate;

#[test]
fn test_external_interaction() {
    let result = my_crate::complex_operation();
    assert!(result.is_ok());
}

9.4 배포와 문서화

9.4.1 문서 주석 작성

/// 두 수를 더합니다.
///
/// # 예제
///
/// ```
/// let sum = my_crate::add(2, 2);
/// assert_eq!(sum, 4);
/// ```
///
/// # 패닉
///
/// 오버플로우가 발생하면 패닉이 발생할 수 있습니다.
pub fn add(a: i32, b: i32) -> i32 {
    a.checked_add(b).expect("오버플로우 발생")
}

9.4.2 릴리즈 준비

[package]
name = "my_project"
version = "0.1.0"
authors = ["Your Name <your.email@example.com>"]
description = "A brief description of my project"
documentation = "https://docs.rs/my_project"
repository = "https://github.com/username/my_project"
license = "MIT OR Apache-2.0"

연습 문제

다음 C 프로그램을 Rust로 포팅해보세요:
- 간단한 메모리 풀 구현
- 이벤트 루프 시스템
- 파일 시스템 캐시
다음 성능 최적화를 수행해보세요:
- 벡터 연산 병렬화
- 메모리 사용량 최적화
- 캐시 친화적 데이터 구조 설계
다음 테스트를 작성해보세요:
- 동시성 관련 테스트
- 성능 벤치마크
- 메모리 누수 테스트
프로젝트 문서화:
- API 문서 작성
- 예제 코드 작성
- README 작성

Chapter 10: 생태계와 도구

10.1 주요 크레이트 소개

10.1.1 시스템 프로그래밍

tokio

비동기 런타임
네트워크 프로그래밍

use tokio;

#[tokio::main]
async fn main() {
   let handle = tokio::spawn(async {
       // 비동기 작업
   });
   handle.await.unwrap();
}

libc

시스템 콜 인터페이스

use libc;

fn get_pid() -> i32 {
   unsafe {
       libc::getpid() as i32
   }
}

mio

저수준 I/O 작업

use mio::*;

let poll = Poll::new()?;
let mut events = Events::with_capacity(1024);

10.1.2 데이터 처리

serde

직렬화/역직렬화

use serde::{Serialize, Deserialize};

#[derive(Serialize, Deserialize)]
struct Point {
   x: i32,
   y: i32,
}

diesel

ORM과 쿼리 빌더

use diesel::prelude::*;

#[derive(Queryable)]
struct User {
   id: i32,
   name: String,
   email: String,
}

10.1.3 웹 개발

actix-web

웹 프레임워크

use actix_web::{web, App, HttpServer, Responder};

async fn index() -> impl Responder {
   "Hello, World!"
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
   HttpServer::new(|| {
       App::new().route("/", web::get().to(index))
   })
   .bind("127.0.0.1:8080")?
   .run()
   .await
}

10.2 개발 도구와 IDE 통합

10.2.1 rust-analyzer 설정

{
    "rust-analyzer.checkOnSave.command": "clippy",
    "rust-analyzer.procMacro.enable": true,
    "rust-analyzer.cargo.loadOutDirsFromCheck": true,
    "rust-analyzer.lens.enable": true
}

10.2.2 디버깅 도구

{
    "version": "0.2.0",
    "configurations": [
        {
            "type": "lldb",
            "request": "launch",
            "name": "Debug executable",
            "cargo": {
                "args": ["build", "--bin=my_project"],
                "filter": {
                    "name": "my_project",
                    "kind": "bin"
                }
            },
            "args": [],
            "cwd": "${workspaceFolder}"
        }
    ]
}

10.2.3 유용한 CLI 도구

# 코드 포맷팅
cargo fmt

# 린트 검사
cargo clippy

# 의존성 검사
cargo audit

# 벤치마크
cargo bench

# 문서화
cargo doc --open

10.3 커뮤니티 리소스

10.3.1 공식 리소스

10.3.2 학습 리소스

온라인 서적
- Rust Book
- Rust by Example
- Asynchronous Programming in Rust
연습 문제
- Rustlings
- Exercism Rust Track
- LeetCode Rust

10.3.3 커뮤니티 참여

포럼과 채팅
- users.rust-lang.org
- Discord 서버
- Reddit r/rust
컨퍼런스
- RustConf
- RustFest
- local Rust meetups

10.4 지속적인 학습 방법

10.4.1 실전 프로젝트 아이디어

시스템 도구
- 파일 시스템 도구
- 프로세스 모니터
- 네트워크 유틸리티
웹 애플리케이션
- REST API 서버
- WebSocket 서버
- 실시간 채팅 시스템
데이터 처리
- 로그 분석기
- 데이터 파이프라인
- 스트리밍 처리기

10.4.2 기여하기

오픈 소스 프로젝트
- 버그 리포트
- 문서화
- 코드 기여
블로그 작성
- 기술 블로그
- 튜토리얼
- 케이스 스터디

연습 문제

다음 기능을 구현하는 작은 프로젝트를 만들어보세요:
- tokio를 사용한 비동기 서버
- serde를 사용한 설정 파일 처리
- diesel을 사용한 데이터베이스 조작
개발 환경을 설정해보세요:
- VS Code와 rust-analyzer 설정
- 디버깅 환경 구성
- CI/CD 파이프라인 구성
커뮤니티 참여:
- 오픈 소스 프로젝트에 기여
- 블로그 포스트 작성
- 로컬 Rust 모임 참여
학습 계획 수립:
- 단기 목표 설정
- 중기 프로젝트 계획
- 장기 커리어 계획

Post Views: 4

C 개발자를 위한 Rust 입문

댓글