Mut와 Shadowing

Mut는 “변수의 값을 바꿀 수 있다(mutable)”는 의미이고, Shadowing은 “같은 변수명을 사용해서 이전의 변수를 가리는” 기능입니다. Shadowing을 통해 Mut의 기능을 대체할 수도 있고, 둘 다 사용하지 않는다면 변수명을 여러 개 사용해야 하는 번거로움이 있습니다.

1. Mut를 사용한 경우

아래 예시는 x를 mutable(가변) 변수로 선언한 다음
=> let mut x = 9;

x의 값을 바꿔가면서 원하는 값인 final_number를 출력하는 코드입니다.
=> x = times_two(x);
=> x = x + y;
이 때 반환값은 x라고 ;없이 씁니다.

fn times_two(number: i32) -> i32 {
    number * 2
}
fn main() {
    let final_number = {
        let y = 10;
        let mut x = 9;
        x = times_two(x);
        x = x + y;
        x
    };
    println!("The number is now:{}", final_number);
}

그러나, let final_number가 끝나는 지점에는 let 문이므로 ;을 반드시 붙여야 합니다. 안 붙이면 아래와 같이 ;을 기대했는데, println이 발견됐다는 에러가 표시됩니다.

let문은 ;으로 끝나야 하는데, ;이 없어 에러가 남

Rust의 특이한 점이 불변(immutable)이 변수의 기본 상태이고, 변수의 값을 바꿀 수 있게 하려면 mut를 붙여야 한다는 점입니다.

※ 함수 구문

fn times_two(number: i32) -> i32 {
    number * 2
}

Rust에서 함수를 선언할 때는 fn을 사용하고 그 다음에 함수명을 붙이는 것은 다른 언어와 같습니다.

그 다음 괄호 안에 인수명을 입력하는데, 여기서는 number이고,

반드시 인수의 타입을 입력해야 하는데, : 다음에 i32 식으로 “32비트 부호 있는 정수” 타입이라고 명시합니다.

이것이 변수의 경우 추론(inference)이 돼서 타입을 반드시 기재해야 할 필요가 없는 것과 다른 점입니다. 변수의 경우 정수는 i32, 실수는 f64가 기본형입니다.

그리고, 반환 값이 있으면 반환 값의 형식도 입력해야 하는데,
-> 다음에 i32식으로 입력합니다.

따라서, 반환값이 없으면 ‘-> 반환 값 형식’을 입력하지 않습니다.

그리고, 중괄호 안에 함수의 내용을 기록하고, 반환값을 마지막에 입력하는데, 여기서는 반환값이 number * 2로 인수에 2를 곱한 값을 반환하는 것인데, 마지막에 ;을 붙이지 않는 것도 중요한 점의 하나입니다.

2. Shadowing을 사용한 경우

Shadowing은 “그림자처럼 따라 다님”이란 의미이므로, 여기서는 원래 있던 x 변수를 가리는 역할을 합니다.

Shadowing을 이용하게 되면 x = 을 let x =이라고 쓰고,
처음 변수 선언할 때 mut 없이 let x = 9;이라고 씁니다.

fn times_two(number: i32) -> i32 {
    number * 2
}
fn main() {
    let final_number = {
        let y = 10;
        let x = 9;
        let x = times_two(x);
        let x = x + y;
        x
    };
    println!("The number is now:{}", final_number);
}

만약 let mut x = 9;라고 mut를 붙여도 결과는 같지만,
‘변수가 mutable일 필요가 없다”는 경고와
mut를 제거하라는 도움말이 표시됩니다.

가변 변수가 아닌데, mut가 붙어 있어서 경고 메시지가 표시되고, mut를 제거하라는 도우말이 표시됨

3. shadowing과 mut를 사용하지 않은 경우

fn times_two(number: i32) -> i32 {
    number * 2
}
fn main() {
    let final_number = {
        let y = 10;
        let x = 9;
        let twice_x = times_two(x);
        let twice_x_and_y = twice_x + y;
        twice_x_and_y
    };
    println!("The number is now:{}", final_number);
}

1과 2 예제에서는 변수명으로 x 하나만을 사용했는데,

이번 예제 3에서는 x, twice_x, twice_x_and_y라는 변수 3개를 사용해야 해서 매우 번거롭습니다.

변수, 불변성, 데이터 타입

Rust는 안전성을 위해 변수는 기본적으로 불변(immutable) 입니다. 따라서, 필요한 경우 변수의 값을 변경하려면 명시적으로 가변(mut)으로 선언해야 합니다. 변수 선언 시 let을 사용하고, 스칼라 타입은 숫자, 불리언, 문자가 있으며, 타입을 지정해야 하는 정적 타입 언어이나 타입 추론이 가능합니다.


🔹 준비

Code의 터미널 창에서 D:\rust-practice 폴더로 이동한 다음
cargo new day2라고 입력해서 day2 패키지를 만들고
cd day2라고 입력해서 day2 폴더로 이동합니다.

main.rs는 day2 아래 src 폴더에 있습니다.

🔹 변수 선언

fn main() {
let x = 5;
println!("x의 값은: {}", x);
}
  • let 키워드는 변수를 선언합니다.
  • x는 기본적으로 불변 변수입니다. 변수인데 불변이라고 하니 Rust는 참 독특한 개념의 언어입니다.
  • {}는 print, 다시 말해 출력 시 변수가 위치할 자리(placeholder)입니다.

실행

위 코드를 복사해서 에디터의 main.rs의 내용을 덮어쓰고 저장한 다음
cargo run을 실행하면
출력되는 값은 “x의 값은: 5″입니다.

출력 구문 변경

중괄호안에 변수를 넣어
println!(“x의 값은: {x}”);
과 같이 구문을 바꿀 수 있습니다.

main.rs 위의 run 실행

Code를 닫았다가 열면 rust-analyzer가 다시 실행되면서 아래와 같이 main.rs위에 Run|Debug가 생기므로

main.rs 위에 run 명령어가 보이고, 이를 눌러 rust 패키지를 실행할 수 있다.
흰색 동그라미는 파일이 저장되지 않았다는 의미

run을 눌러 실행할 수 있습니다.

cargo run을 할 때는 먼저 파일을 저장해야 하는데 위 run을 누르면 자동으로 파일을 저장하고, cargo run을 실행하므로 너무 편리합니다.

🔁 값을 바꾸려면?

fn main() {
let x = 5;
x = 6; // 에러! 기본 변수는 값 변경 불가
}

오류 메시지: cannot assign twice to immutable variable x
(불편 변수인 x에 값을 두 번 할당할 수 없다)

//는 주석 표시입니다. 다시 말해 // 다음의 문장은 프로그램 실행 시 제외됩니다.

기존 구문을 주석 처리하고 위 구문을 추가할 때
해당하는 2줄을 마우스로 끌어서 선택하고 Ctrl + /키를 누르면 맨 앞에 // 표시가 추가됩니다.

fn main() {
    // let x = 5;
    // println!("x의 값은: {x}");

    let x = 5;
    x = 6; // 에러! 기본 변수는 값 변경 불가    
}

🔧 가변 변수 (mutable)

fn main() {
let mut x = 5;
println!("처음 x: {x}");
x = 6;
println!("바뀐 x: {x}");
}
  • mut 키워드를 사용하면 값 변경이 가능합니다.

실행

실행하면 화면에 아래와 같이 출력됩니다.
처음 x: 5
바뀐 x: 6


🧮 스칼라 타입(Scalar Types)

스칼라(scalar)는 하나의 값으로 표현되는 타입입니다. Rust는 정수(integer), 부동소수형 숫자(floating-point numbers), boolean(논리형), 그리고 문자(char)라는 네 가지 타입을 보유하고 있습니다. Rust는 정적 타입 언어이며, 대부분 타입은 명시하지 않아도 추론됩니다.

정적 타입 언어는 컴파일 시 변수 타입이 결정되는 언어이고, 동적 타입 언어는 런타임 시 변수 타입이 결정되는 언어, 다시 말해, 코드를 실행할 때 알아서 변수 타입을 판단해주는 언어입니다. 그러나 Rust는 정적 타입 언어임에도 변수 타입을 프로그램에서 지정하지 않더라도 변수 타입을 추론한다는 것이 다른 점입니다.

숫자형

정수형은 소수점이 없는 숫자이고, 부동소수형은 소수점이 있는 숫자입니다. 3을 부동소수형으로 표현할 경우 소수점이하가 0이더라도 3.0이라고 써야지 3으로 쓰면 안되며, 최소한 3.이라고 소수점을 찍어야 합니다.

위 코드에서 let a = 10;이라고 변수에 정수를 대입하면 : i32를 입력하지 않아도 rust analyzer가 : i32를 알아서 추가해서 표시합니다. 3.14도 마찬가지로 : f64라는 타입을 자동으로 표시합니다. 이것이 추론입니다.

: i32 또는 : f64가 없어도 프로그램 실행에 전혀 문제가 없으며, 직접 입력하려면 : i32라고 입력해야 합니다. 아래와 같이 Code에서 타입을 입력한 것은 녹색으로 보이고, 추론한 것은 회색으로 보입니다.

숫자형의 종류

불리언 & 문자

let t: bool = true;
let c: char = 'R'; // 유니코드 문자

마찬가지로 : bool을 입려하지 않아도 값이 true이므로 boolean으로 추론되고, 문자 하나를 입력했으므로 : char로 자동으로 표시됩니다. 이때 문자는 반드시 작은따옴표 안에 입력해야 하며, “R”로 바꾸면 에러가 발생합니다.

파이썬은 자유롭게 작은따옴표 또는 큰따옴표를 사용할 수 있는 것과 다릅니다.


※ 문자 한 개(char)가 아니라 “I am a boy”과 같은 문자열은 String 타입으로 구분되므로 나중에 별도로 다루도록 하겠습니다.


📌 변수 섀도잉(Shadowing)

Rust에서는 같은 이름의 변수로 새로운 값을 선언할 수 있습니다.

fn main() {
let x = 5;
let x = x + 1;
let x = x * 2;
println!("x의 값: {x}"); // 12
}
  • let을 반복 사용하면 기존 변수를 덮어쓰는(shadowing) 것처럼 새 변수 선언이 가능합니다.
  • 타입을 변경하는 것도 허용됩니다. 아래는 x가 i32 형식이었다가 char 형식으로 변경된 것을 보여줍니다.

‘R’; 다음의 주석 “// 변수 재정의 가능”도 입력한 것이 아니고 rust analyzer가 알아서 입력한 것입니다. 참 똑똑합니다.

위 코드의 출력 값은
x의 값: 12 (x는 5 -> 6 -> 12가 됨)


🧠 정리

  • 변수는 기본 불변 → 변경하려면 mut 사용
  • 정적 타입 → 타입을 명시하는 것이 원칙이지만 타입 추론 가능
  • Shadowing으로 가변처럼 활용 가능하나, 메모리 안정성을 유의해서 사용하지 않는 것이 바람직함