C++ 예외처리

C++ 에서는 아래코드처럼 try catch가 전부이고 문법구조가 간단하기때문에 사용법도 간단합니다. 물론 코드가 길어지는 단점은 있습니다. C++은 아래처럼 사용합니다.

try {
    // 예외 가능성이 있는 코드 작성
    throw std::runtime_error("0으로 나눌 수 없습니다!")
} 
catch (... ) {
    // 예외처리
}

Python 예외처리

# 예외처리 try 구문 작동원리
try:
  print("1. 예외가 발생될 수 있다고 예상되는 코드")
  # raise exception()                      # <- 임의로 에러 발생!!
except:
  print("2. 에러가 발생 하였습니다")
else:
  print("3. 에러가 없을 때 실행할 코드")  
finally:
  print("4. 에러 유무 관계없이 실행할 코드")

파이썬은 try: exception: 의 C++ 의 try, catch에 대응하는 기능인데, 이 둘은 필수로 작성하고 else문과 finally문은 (optional)한 코드입니다. 하지만 구조가 이렇게 잡혀있는만큼 따르면 얻는 잇점도 있기때문에 그 부분을 알고 넘어가고자 합니다.

try:

try문은 파일 입출력이나 네트워크와 연결된 에러가 예상되는 코드를 작성해줍니다.

except:

except에서는 catch와 마찬가지로 에러가 발생한경우 디버깅용 또는 로그용 코드를 작성해도 좋고 에러 알림용 코드를 작성해도 좋습니다.

else: (optional)

이곳은 try문이 성공했을때 실행될 코드를 작성해줍니다. C++과 차이가있다면, C++에서는 try문에 파일 읽는 코드가 있다면, catch문 아래에 파일 객체를 담은 변수를 if문으로 체크해서 try가 성공한것을 확인하고 파일객체를 사용하거나 try가 실패한것을 확인하여 바로 파일을 닫는 등 코드를 작성해야합니다.

파이썬에서는 else: 키워드자체가 파일 읽어오기가 성공되었다는것을 보장해주므로 파일읽기 성공여부를 체크하지 않아도 됩니다. 물론 파일을 읽어온 데이터의 무결성검사는 여전히 해줄 필요가 있습니다.

finally: (optional)

이곳은 예외발생여부와 상관없이 try 예외처리 구문 마지막에 실행되는 코드인데요. try문에서 파일을 읽어왔다면 이곳에서 파일을 닫는 코드가 들어가면 좋습니다.

C++ 사용자라면 else문 finally문 없이 그냥 쓰면 되는거아니야 라고 생각될수도있는데, 예외가 발생할수있는 코드부분을 묶어주면 가독성에도 도움이되고 위에 else 부분에서 언급한것처럼 if문 사용을 줄이는데도 도움이 됩니다.

Python 사용자 입장에서 예외처리 예시

C++과 비교하면 파이썬 예외처리구문의 기능을 전부 다룰수없어서 순수 파이썬 사용자 입장에서도 예시를 한번 살펴보겠습니다.

예시코드는 위 사진처럼 웹사이트에서 학점조회를 할경우 백엔드 데이터얻어오는 코드를 예시로 들었습니다. 아래의 코드 2번을 집중해서 봐주세요 설명은 아래서 이어 하겠습니다.

#[코드 1]
scores = {"유원영": {"국어": 94, "영어": 91, "수학": 89},
          "설지민": {"국어": 88, "영어": 96, "수학": 90},
          "신윤아" :{"국어":86, "영어":88, "수학": 77},
          "장윤아": {"국어": 98, "영어": 76, "수학": 92}}

def score_analysis(data, name):
    print(f"[{name} 성적 분석]")

    for 과목 in ["국어", "영어", "수학"]:
      합계 = 0
      for i in data:
        합계 += data[i][과목]
      학급평균 = 합계 / len(data)
      내점수= data[name][과목]
      편차=내점수-학급평균
      print(f"{과목}:{내점수}점, 학급평균({학급평균}점, 편차= {편차:+})")
    print("\n")

#[코드 2]
def query_test_result(name):
  try:
    print("1. 성적표 데이터 불러오기를 시도합니다.\n")
    # f = open("~/work/workplace/파이썬/성적표.txt", "r")  # 파일 불러오기 or 데이터 베이스 쿼리
    
  except:
    print("2. 성적표 데이터 불러오기 중 알수 없는 오류 발생\n") # 로깅 및 디버깅 용
    print("[시스템에러]: 잠시 후 다시 시도해 주세요.\n")        # 사용자에게 알림 용
  else:
    print("3. 성적표 데이터 불러오기 성공\n")                   # 로깅 및 디버깅 용
    print("[조회성공]: 시험결과를 출력합니다\n")                # 사용자에게 알림 용
    #10/0  # <- 에러발생 유발
    data = scores    # data = f.read()  # 또는 DB 쿼리
    score_analysis(data, name)

  finally:
    print("4. 파일을 닫습니다.\n")
    #f.close()  # <- "Graceful Shutdown" (우아한 종료)

query_test_result("장윤아")

try 에서는 예외가 발생할수있는 데이터베이스 쿼리나 파일입출력같은 코드가 들어가면 좋습니다. 예시에서는 파일 불러오는 코드가 있습니다.

except: 예외가 발생한경우 loggin debugging 용 메시지 출력과함께 사용자 알림 메시지 출력 or 전송 기능을 넣을수있습니다.

else: 파일 읽기가 성공한경우에만 실행되기때문에 또다른 점검없이 f.read()로 파일속 데이터를 읽어오는것을 볼수있습니다.

finally:에서는 f.close()로 파일을 닫는것을 알수있습니다.

else는 왜 필요한가?

• (예외처리 구문 밖은 안됨) 현재 예제코드에서는 파일읽기를 성공했다고 가정하고 f.read()를 사용하는데, 이를 try구문이 끝나고나서 사용할경우. 파일읽기가 실패한경우에도 f.read()를 호출해서 에러가 발생하게 됩니다.
• (try: 구문에서는 안됨) try구문안에 f.read()가있으면 문제없이 모든게 잘 작동하면 상관없겠지만, f.read()를하다가 에러가 발생하게되거나 혹은 다른 코드 (예시에서는 score_analysis(data, name) 이부분에서) 에러가 나더라도 어디서 에러나는지 알수가 없습니다.

finally는 왜필요한가?

• finally는 파일닫기처럼 try문에서 파일을 열었을때 꼭 수행되야하는 작업을 넣어줍니다.
• try 구문 어딘가에서 return이나 break를 통해 try를 빠져나가는것을 시도하면 finally 문이 실행되는것을 보장해줍니다.

loop 라벨링

loop 반복문의겨우 아래 코드처럼 ‘를 사용해 라벨링이 가능하다. 라벨링을 사용해서 inner loop에서 outer loop를 break 한번에 빠져 나올수있다.

fn main() {
    let mut count = 0;
    'counting_up: loop {
        println!("count = {count}");
        let mut remaining = 10;

        loop {
            println!("remaining = {remaining}");
            if remaining == 9 {
                break;
            }
            if count == 2 {
                break 'counting_up;    // <---- 
            }
            remaining -= 1;
        }

        count += 1;
    }
    println!("End count = {count}");
}

while (조건식 필수)

while 루프는 C++이나 JS등 다른언어와 크게 다르지않다.

fn main() {
    let mut number = 3;

    while number != 0 {
        println!("{number}!");

        number -= 1;
    }

    println!("LIFTOFF!!!");
}

for (배열 순회)

for 은 다음처럼 사용하면 배열의 아이템들을 한번씩 순회할수 있다.

fn main() {
    let a = [10, 20, 30, 40, 50];

    for element in a {
        println!("the value is: {element}");
    }
}

for + rev()

rev()는 리버스의 줄임말로 배열 내 숫자를 1, 2, 3을 3, 2 ,1 순서로 number iterator에 넣어줌.

fn main() {
    for number in (1..4).rev() {
        println!("{number}!");
    }
    println!("LIFTOFF!!!");
}

// rev()를 쓰지않을때는 range에 ()가 없어야함
    for number in 1..4 {
        println!("{number}!");
    }

Stack and Heap

스택은 자료구조에서 다들 배웠겠지만, 여기서말하는 스택은 조금 다릅니다. 자료구조의 스택처럼 LIFO 개념은 동일합니다만, 여기서 말하는 Stack은 프로그램을 실행시 정적으로 가지는 메모리입니다. C++에서 Vector를 사용할때 Stack처럼 push로 데이터를 추가하고 pop으로 빼낼수있지만 C++ Vector는 가변메모리로써 Heap에 존재하죠. Stack에 저장될수있는 메모리는 컴파일 시점에 메모리의 크기를 정확히 알수 있어야 합니다.

스택메모리는 프로그램 실행시점부터 순차적으로 메모리를 쌓아올라가기 떄문에, 호출비용이 없고 메모리 낭비가 거의 제로에 가깝습니다. 힙메모리는 메모리 조각조각 사이에서 필요로하는 메모리보다 큰공간을 사용하게되므로 메모리 낭비도있고 빈공간을 찾아야하는 호출비용도 존재합니다.

최적화 기법중에는 stack메모리를 크게할당해둔다음 데이터를 수동으로 stack메모리에서 관리해주는 방법도 있습니다. 하지만 이는 생산성이 떨어지는 단점이 있어서 특별한경우를 제외하고는 잘 사용하지 않습니다. Ownership 개념을위해 짧게 정리하고 넘어갑니다.

fn main() {
    let score: i32 = 100;                                // stack
    let name: String = String::from("김개똥");     // heap
}

name 변수를 일반변수로 설정해도 heap 메모리에 저장되게 됩니다. 만약 문자열을 stack메모리에 올리고싶으면, 아래처럼 사용해야합니다.

let stack_str: [u8; 9] = *b"Hello Rust";

Ownership

오너십은 조건

• 각 변수는 오너십을 갖고있다.
• 오너십은 단 한명만 갖는다.
• 오너가 스코프를 넘어가는경우 값은 사라진다. – 가비지콜렉터 대용기능

scope의 개념

 {                      
        let s = "hello";   // s는 이 라인 이후로 사용 가능

        // s 를 사용
}                            // 여기서부터는 스코프를 떠나서 s는 더이상 사용 불가능

소유권 이동

먼저 아래의 경우 integer 타입 변수는 사이즈를 알고있고, 때문에 x 와 y 모두 5라는값을 스택메모리에 저장하게됩니다.

{
    let x = 5;
    let y = x;
}

문자열 형식의 경우, 힙메모리를 사용하기때문에 아래처럼 코드를 작성할경우 아래 그림처럼 hello 문자열이 담긴 주소(포인터)가 복사되게 된다. 좋게 말하면 포인터 코드를 알지못해도 포인터를 사용한것처럼 낼수있는것이고. 단점이라면, 포인터를 사용하진않지만 실제로는 포인터개념을 알고있어야 Rust를 잘 사용할수 있다는 이야기 이기도 하다.

s2에 s1을 대입하는 순간 소유권이 s2로 이동해서, s1은 사용불가 -> s1을 사용하려 하면 컴파일 에러

{
    let s1 = String::from("hello");
    let s2 = s1;                   // 이 statement 이후 s1은 사용불가
}

drop 타이밍

같은 s변수에 문자열을 두번 초기화 하는 경우엔, 2개의 힙메모리가 할당이 되는데 2 번 statement가 실행되는순간 아래 그림처럼 s변수는 ahoy문자열이 저장된 주소를 가리키게된다.

Rust에서는 메모리를 해제하는것을 drop 함수로 진행하는데 drop함수가 호출되는 부분은 4번 scope를 떠나는 순간이므로 hello라는 메모리는 3번 statement가 실행된 이후에도 메모리에는 실제로 남아있다. 이렇게 작동하는 이유는 좀더 복잡한코드에서 1번과 2번 statement사이에서 s의 소유권을 가져가진 않지만 참조로 읽을수있는 다른객체가 존재할수 있기때문이다.

{
    let mut s = String::from("hello");  // 1
    s = String::from("ahoy");            // 2

    println!("{s}, world!");                // 3
}                                             // 4

deep copy 깊은 복사

만약 문자열을 복사 하고싶다면? 아래처럼 clone() 함수를 사용해주면된다.

    let s1 = String::from("hello");
    let s2 = s1.clone();

    println!("s1 = {s1}, s2 = {s2}");

구조체 객체에 저장할때 소유권을 넘겨주면 되지만 여러 객체에 할당하거나 다른이유로 원본(s1)을 유지하고싶으면 clone 명령어로 깊은복사를 해야한다.

struct User {
    username: String,
}

fn main() {
    let current_name = String::from("김개똥");

    // User 구조체가 username의 소유권을 가져야 하므로 복사본을 만듭니다.
    let user1 = User {
        username: current_name.clone(),
    };

    // 여전히 current_name을 다른 곳(예: 로그 출력)에 쓸 수 있습니다.
    println!("가입 신청자: {}", current_name);
}

Return Values and Scope 함수 리턴과 스코프

아래코드는 https://doc.rust-lang.org/book/ch04-01-what-is-ownership.html 에서 빌려왔다. 이해해야할 포인트가 몇군데 있다. some_string은 gives_ownersihp 함수에서 선언되었지만, 해당 함수가끝나도 yours 문자열은 drop되지않는다. 소유권이 이미 s1변수로 넘어갔기때문이다. 그리고 s2에서 생성된 hello 문자열은 takes_and_gives_back 함수로 소유권을 전달하지만 해당함수 리턴값으로 소유권을 돌려받는다. 여기서 중요한건 그냥 문자열을 전달하듯 사용했을뿐인데, C++에서 포인터를 통해 문자열을 전달했다가 돌려받은것처럼 메모리 복사가 발생하지 않는다는것이다.

fn main() {
    let s1 = gives_ownership();        // gives_ownership moves its return
                                       // value into s1

    let s2 = String::from("hello");    // s2 comes into scope

    let s3 = takes_and_gives_back(s2); // s2 is moved into
                                       // takes_and_gives_back, which also
                                       // moves its return value into s3
} // Here, s3 goes out of scope and is dropped. s2 was moved, so nothing
  // happens. s1 goes out of scope and is dropped.

fn gives_ownership() -> String {       // gives_ownership will move its
                                       // return value into the function
                                       // that calls it

    let some_string = String::from("yours"); // some_string comes into scope

    some_string                        // some_string is returned and
                                       // moves out to the calling
                                       // function
}

// This function takes a String and returns a String.
fn takes_and_gives_back(a_string: String) -> String {
    // a_string comes into
    // scope

    a_string  // a_string is returned and moves out to the calling function
}

fn main() {
    println!("Hello, world!");

    another_function();
}

fn another_function() {
    println!("Another function.");
}

매개변수 타입 명시해야함.

Statements and Expressions

Statement: 하나의 명령줄 “let y = 6;”

Expression

fn main() {
    let y = {
        let x = 3;
        x + 1
    };

    println!("The value of y is: {y}");
}

// 의 코드가 있는경우 아래 블럭을 expression이라 한다
{
    let x = 3;
    x + 1
}
// 여기서 evaluate 는 x+1이되고 이 값이 return이된다.

Return

함수의 반환값은 위의 expression에서 처럼 ; 세미콜론 없이 마지막줄에 작성한다.

Rust에서는 아래코드의 -> i32 와 반환타입이 i32라는것을 명시해야한다.

fn five() -> i32 {
    5
}

fn main() {
    let x = five();

    println!("The value of x is: {x}");
}

five 함수 내의 5를 return expression 이라 한다.

Scalar는 고정된 메모리를 갖고있으며 1개의 값을 저장하는 종류.

Integer

• i8, i16, i32, i128, isize
• u8, u16, u32, u128, usize

타입의 작동방식은 C++과 동일하다. 특징이있다면 Rust에서는 배열인덱싱에서 usize를 써야함.

Compound Types

Tuple

Rust에서 튜플은 다양한 데이터타입도 한곳에 묶을수있다. 분리할땐 아래처럼 사용한다.

사용 용도로는 어떤 데이터셋을 한번에 함수에서 return하거나 매개변수로 받을 때, 클래스 선언하지않고 받을때 사용.

// x, y, z 변수로 빼내어 사용
fn main() {
    let tup = (500, 6.4, 1);

    let (x, y, z) = tup;

    println!("The value of y is: {y}");
}

// 배열처럼 인덱싱하기
fn main() {
    let x: (i32, f64, u8) = (500, 6.4, 1);

    let five_hundred = x.0;

    let six_point_four = x.1;

    let one = x.2;
}

Array 배열

배열은 다른 스칼라타입 변수처럼 스택메모리를 이용합니다.

배열은 항상 같은 타입의 데이터만 같은 변수에 저장가능합니다. Rust에서 배열은 고정 길이를 갖습니다 C++의 기본 배열을 생각하시면 됩니다.

fn main() {
    let a = [1, 2, 3, 4, 5];

    // 타입명시
    let a: [i32; 5] = [1, 2, 3, 4, 5];

    // 같은 값 대입
    let a = [3; 5];
}

Rust의 철학은 컴파일과정에서 최대한 많은 위험을 제거하는것이기때문에 어디서든 잘 작동하게하는 첫번째 이유가 더 큰 이유같습니다.

https://crates.io

자료구조

Collection – 파이썬에서는 배열, 리스트같은 데이터 덩어리를 Collection이라 부릅니다.

• List – C++의 Vector 및 List에 해당, 스택메모리를 사용하는 정적 배열은 없음. 표기 [1, 2, 3]
• Tuple – 수정불가능한 배열 이지만 힙메모리 사용. 하지만 여전히 List보다 메모리낭비가 적고 가비지 컬렉션 비용도 적음.
• Set – C++의 HashSet<T>, 중복 불허, 순서 없음, 해시 기반
• Dictionary – C++의 HashMap<K,V> 해시 테이블 기반 키-값 구조

알고리즘

Lambda 람다

제곱을 구하는 람다 함수

lambda(Python)

lambda x : x * x

lambda(C++11이상)

[](int x) { return x * x; }

Map 변환

리스트의 각 요소의 값을 제곱할 때

map(Python)

res = map(lambda n : n * n, v)

std::transform(C++)

std::transform(v.begin(), v.end(), res.begin(), [](int n) { return n * n; });

Filter 여과

List에서 짝수만 추출하기

filter (Python)

res = filter(lambda x : x % 2 == 0, v)

std::copy_if (C++)

std::copy_if(v.begin(), v.end(), std::back_inserter(res), [](int n) { return n%2==0; } );

Reduce 축약

reduce (Python)

from functools import reduce
v = [1,2,3,4,5]
sum = reduce(lambda a, b: a + b, v)

std::accumulate (C++)

int sum = std::accumulate(v.begin(), v.end(), 0, [](int a, int b) { return a + b; });

기타 파이썬 특징

First-Class Citizen (일급객체)

일급객체란? 다음 세 가지 조건을 모두 만족함.

• 변수 혹은 자료구조 안에 그 객체를 담을수 있다.
• 매개 변수로 전달할 수 있다.
• 리턴값으로 사용될수있다.

일급 객체 목록

• 함수
• 기본 데이터타입 int, float, str

Closure

파이썬에서는 global과 nonlocal 키워드를통해 함수내에서 전역변수를 선언하거나 가져올수있고 상위 함수의 지역변수를 가져와 수정이 가능하다. 이런것을 가능하게 해주는것이 Closure 덕분이다.

클로저(Closure) 하위함수가 상위함수의 변수(프리 변수)를 참조할 때, 상위함수가 종료된 후에도 하위함수가 기존 상위함수의 스코프내부 상태를 참조할 수 있도록 데이터를 기억하고있습니다. 이 클로저가 작동하려면 다음 세 가지 조건을 만족해야합니다.

• 계층구조를가진 nested 함수
• 하위 함수가 상위 함수의 변수를 참조
• 상위 함수에서 하위 함수를 리턴

# 클로저 함수의 예시
def parent_function():
    greeting = 'Hi i'm greeting.'

    def nested_function():  # 조건 1 충족
        print(greeting)  # 조건 2 충족
    
    return nested_function # 조건 3 충족

Rust에서는 기본적으로 난수(Random Number)를 만드는 기능이 포함되어있지 않은데, rand라는 이름의 crate를통해 이 기능을 지원합니다.

명령어로 crate 추가하기

# 최신버전 설치
cargo add rand

# 특정 버전을 정확히 지정 (예: 0.8.0)
cargo add rand@0.8.0

Cargo.toml 파일 수정하기

toml을 편집에서 아래처럼 수정한뒤 빌드를 새로하면 자동으로 설치가됩니다. 다만 이런경우 특정버전을 꼭 명시해야하므로 모른다면 위 명령어를 사용해서

[dependencies]
rand = "0.8.5"

추천 crates

이곳은 한동안 (2026년3월~2026년 9월) 지속적으로 추가할 예정입니다.

winit

• 창 생성 및 이벤트 루프 (Windows Win32/UWP, macOS AppKit 대체 및 공용) – 2026년 현재 사실상 표준

wgpu (WebGPU)

• Rust에서 WebGPU API를 사용하기 위한 핵심 크레이트입니다. 브라우저뿐만 아니라 네이티브(Windows, Mac)에서도 동일한 코드로 Vulkan, Metal, DX12를 추상화해줍니다.

egui

• Immediate Mode GUI 방식으로, 매 프레임마다 UI를 새로 그립니다. 설정이 매우 간편해서 도구나 게임 엔진용 UI에 최적입니다.
• 장점: wgpu와 연동되는 공식 예제가 매우 잘 되어 있습니다. 학습 곡선이 낮습니다.
• 추천 조합: eframe (winit + wgpu + egui를 하나로 묶은 프레임워크)
  

Iced

• Elm 아키텍처를 차용한 Declarative(선언형) UI 라이브러리입니다. 상태 관리가 명확하며 일반적인 앱 느낌의 UI를 만들기에 좋습니다.
• 장점: 성능이 뛰어나고 코드가 깔끔합니다. 최근 wgpu 렌더러 지원이 강력해졌습니다.

rand (난수 생성)

nalgebra 또는 glam

• glam: 게임 개발에 최적화되어 있어 속도가 매우 빠르고 API가 직관적입니다. (추천)
• nalgebra: 과학 계산이나 물리 엔진 수준의 정교한 수학이 필요할 때 사용합니다.

pollster (비동기 실행)

• wgpu의 많은 함수는 비동기(async)로 동작합니다. 하지만 간단한 네이티브 앱에서 tokio 같은 무거운 런타임을 쓰기 부담스러울 때, pollster를 쓰면 간단히 block_on으로 비동기 코드를 실행할 수 있습니다.

rust-analyzer

Rust analyzer는 여러기능을 하는데 컴파일을 하기전 코드 작성중 실시간으로 코드를 정검해줌으로 개발의 편의성을돕고 언어 공부를 쉽게해줍니다. 변수 관련글에 이걸 먼저 소개한 이유가있습니다. C++ 은 변수선언할때 자료형을 int String float등 명시하여 선언합니다. JS나 파이썬같은 언어는 let 이나 var로 어떤 자료형이든 신경쓰지않고 만들수 있어서 편리함을 갖고있습니다. C++도 2010년쯤 auto라는 변수 선언 키워드를만들어 어떤자료형도 담을수있는 키워드를 만들었지요. Rust는 let으로 변수를 선언하는데 rust-analyzer가 자료형을 자동으로 감지해 표시해줍니다. 아래 이미지를 보시면 변수에 문자열을 대입하면 String이 자동으로 생겨나고, 10을 대입하니 i32가 자동으로 생기는걸 알수있습니다. let 하나로 편하게 변수를 만들고 나중에 코드를 볼때는 : i32가 따라다니면서 자료형을 알려주니까 두가지 장점을 모두 갖고있는 셈이죠.

자동으로 생성되어 위 어둡게 표시된 : String과 : i32 부분을 타입 추론 시각화 라고 하는데 직접 명시해줄수도 있습니다. 예를들어 변수에 String이라고 명시해줬는데 값은 숫자를 넣으려한다면 둘중하나는 틀렸으니 컴파일러가 에러를 보여줄겁니다.

자료형 (Data Type)

정수형 (Integer)

부호있는 정수: i8, i32, i64, i128
부호 없는 정수:u8, u32, u64, u128

isize, usize: CPU아키텍쳐에따른 정수형 변수

부동 소수점 (Float, Double)

f32, f64

불리언 (Boolean)

true, false

문자형 (Character)

char // 4바이트, 유니코드 지원

가변 메모리 변수(Heap)

String:new() (문자열 길이에따라 메모리 크기가 변하는 Heap 메모리 사용)
Vec (벡터 가변 배열)

문자열

let mut guess = String::new();
guess = "하이하이"; // 에러!

문자열 수정할 때 꼭 알아야 하는 부분(1)

아래처럼 문자를 수정하는데 1번방식은 새 string 객체로 교체하기때문에 기존 힙메모리는 해제하고 새 객체를 위해 새로운 힙메모리를 사용합니다. 두번째 방법은 기존메모리를 해제하지않고 내용만 지우고 하이하이로 교체합니다. 이것이 비용이 훨씬 적고 빠릅니다.

let mut guess = String::new();

// 1. 아예 새로운 String 객체로 갈아치우기
guess = String::from("하이하이"); 
// 또는
guess = "하이하이".to_string();

// 2. 기존 String 뒤에 내용 추가하기 (보통 이걸 더 많이 씀)
guess.clear(); // 기존 내용 비우기
guess.push_str("하이하이");

문자열 수정할 때 꼭 알아야 하는 부분(2)

다른변수에 있는값을 가져올때는 아래처럼 소유권 이동방식을 사용합니다.

let other_str = String::from("데이터가 아주 큼");
let mut guess = String::new();

// 소유권 이동 (Move)
guess = other_str; 

// 이제 other_str은 사용할 수 없음!

Rust의 메모리관리

C++에서는 힙메모리를 사용하면 free()나 delete를 통해 메모리 해제를 해야했습니다. JS, Python은 가비지 콜렉터가있어서 자동으로 청소가됩니다 Rust는 새로운 소유권 개념을 적용하였습니다. 이 소유권개념은 C++처럼 수동으로 메모리해제를 하지않으면서도, 포인터를 사용하지않으면서도 데이터복사가 일어나는걸 최소화하는데 도움이 됩니다. 소유권 개념이 어떻게 작동하는지 자세히 알아보겠습니다.

소유권 (Ownership)

이동(move)

String은 문자열입니다 크기가 2bytes일수도있고 kb단위로 커질수도있겠죠. 이런건 heap메모리를 사용하고 새로 공간확보하고 지우고하는데 비용이 큽니다. Rust에서는 아래처럼 문자열을 다른변수에 대입하려하면 복사가 일어나지않고 소유권이 이동합니다. 같은코드를 C++에서 작성하면 s1에 “hello”라는 5바이트 데이터가 저장되었다가 s2=s1 을 하는순간 추가로 5바이트를 확보하며 s2, s1 두변수에서 총 10bytes를 추가로 사용합니다. Rust에서는 소유권을 이동해버려서 굳이 s1이 이후에 또 사용이 필요한지 알수없는 상황에서 이를 유지하지 않는것이죠.

let s1 = String::from("hello");
let s2 = s1;    // s1의 소유권이 s2로 '이동'함

//Rust에서는 s1이 소유권을 잃고나서 값을 읽으려고하면 에러가 발생합니다.
// println!("{}", s1); // 에러! s1은 더 이상 값을 가지고 있지 않음.

복사(copy)

정수형같은경우는 용량이 작아서 기본적으로 복사가 됩니다. 또한 스택메모리를 사용하여 메모리확보 비용도없습니다.

let x = 5;
let y = x; // x의 값이 복사되어 y에 들어감

println!("x: {}, y: {}", x, y); // 둘 다 사용 가능!

빌림 (Borrowing) 과 참조(&)

값을 함수를 통해 전달하고 연산할때는 참조개념을 이용하는데 사용방법은 아래와 같습니다. 함수 인자로 &를 넣으면 Rust용어로 빌려 준다는 개념이되고, 함수에서는 &가 붙은 매개변수가 있다면 빌려온변수, 참조변수 라고 부를 수 있습니다.

fn main() {
    let s1 = String::from("hello");
    let len = calculate_length(&s1); // s1의 참조 전달

    println!("'{}'의 길이는 {}입니다.", s1, len); // s1 여전히 사용 가능!
}

fn calculate_length(s: &String) -> usize { // &String: 소유권은 안 받고 빌리기만 함
    s.len()
}

불변 참조(&T)는 여러 개 가질 수 있다. (여러 명이 동시에 읽기 가능)

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

    let r1 = &s; // 첫 번째 읽기 전용 대여
    let r2 = &s; // 두 번째 읽기 전용 대여
    let r3 = &s; // 세 번째 읽기 전용 대여

    println!("{}, {}, 그리고 {}", r1, r2, r3); 
    // ✅ 모두 성공! 아무 문제 없습니다.
}

가변 참조(&mut T)는 딱 하나만 가질 수 있다. (쓰는 사람은 한 명이어야 함)

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

    let r1 = &mut s; // 첫 번째 쓰기 권한 대여
    // let r2 = &mut s; // ❌ 에러! 이미 r1이 빌려갔는데 또 빌릴 수 없음

    r1.push_str(", world");
    println!("{}", r1);
}

//Rust에서 문자열을 입력받을때에도 가변 참조를 사용합니다.
let mut text= String::new();

io::stdin().read_line(&mut text).expect("잘못입력됨");

// &mut text라고해서 문자열변수를 가변참조로 전달하고있죠.

불변 참조와 가변 참조를 동시에 가질 수 없다. (읽고 있는데 누가 값을 바꾸면 안 됨)

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

    let r1 = &s;     // 읽기 전용으로 빌림 (불변 참조)
    let r2 = &s;     // 또 읽기 전용으로 빌림 (불변 참조)
    
    // let r3 = &mut s; // ❌ 에러! r1, r2가 '변하지 않을 것'이라 믿고 읽는 중인데
                     // 갑자기 수정 권한(&mut)을 주면 데이터 일관성이 깨짐

    println!("{}와 {}", r1, r2);
}

Rust의 변수명

변수명은 영어와 숫자 언더스코어_ 만 사용가능한것 은 다른 언어와 비슷합니다. Rust에서는 특별한 기능이 하나있는데 변수명 시작할때 _를 붙이면 이변수는 사용할수도 안할수도 있으니 사용하지않아도 경고를 발생시키지 않게 컴파일러에게 알려줄수 있습니다.

fn main() {
    let x = 5;      // ⚠ 경고: unused variable: `x`
    let _y = 10;    // ✅ 통과: 경고가 뜨지 않음
}