소소한 개발 공부

[Rust] 컬렉션 - 해시맵

이내내 — Fri, 11 Aug 2023 09:01:26 +0900

해시맵 HashMap<K, V> 은 K 타입의 키, V 타입의 값을 해시 함수를 사용해 매핑한 것을 저장

임의의 타입으로 된 키를 이용해 데이터를 찾고 싶을 때 유용

ex) 각 팀의 점수를 해시맵에 저장했을 때 팀 이름이 키, 점수가 값 -> 팀 이름으로 값 찾기 가능

1. 해시맵 생성

new 로 생성, insert로 요소 추가

pub fn insert(&mut self, k: K, v: V) -> Option<V> : K에 해당하는 V가 없다면 None 반환, 있다면 V 반환

use std::collections::HashMap;

let mut scores = HashMap::new();

scores.insert(String::from("Blue"), 10); // 키: Blue, 값: 10
scores.insert(String::from("Yellow"), 50);

* 사용량이 적은 컬렉션이라 prelude 의 자동으로 가져오는 기능에 포함되어 있지 않아 use 해야 함

2. 해시맵 값 접근

get 메서드에 키를 넣어 값을 가져올 수 있음

let team_name = String::from("Blue");
let score = scores.get(&team_name).copied().unwrap_or(0);

println!("{:?}", score); // 10

get 메서드는 Option<&V>를 반환하는데, 해시맵 키에 해당 하는 값이 없다면 None 반환

copied() -> Option<&i32>가 아닌 Option<i32>를 얻을 수 있게 딥카피해서 iterator 반환

unwrap_or([default]} -> 해당 키에 대한 값을 반환, 없는 경우 defuault 로 0 반환

for문도 사용 가능

for (key, value) in &scores {
    println!("{key}: {value}");
}

3. 해시맵 소유권

insert로 K, V를 넣을 때 move 가 일어날 수 있음

- 참조자를 넣거나 clone 으로 딥카피해서 변수의 소유권을 유지

fn main()
{
    let field_name = String::from("Favorite color");
    let field_value = String::from("Blue");

    let mut map = HashMap::new();
    map.insert(field_name, field_value); // 여기서 소유권을 잃음

    println!("{} {}", field_name, field_value); // 소유권 문제 발생
}

let field_name = String::from("Favorite color");
   |         ---------- move occurs because `field_name` has type `String`, which does not implement the `Copy` trait
...
9  |     map.insert(field_name, field_value);
   |                ---------- value moved here
10 |
11 |     println!("{} {}", field_name, field_value);
   |                       ^^^^^^^^^^ value borrowed here after move
   = note: this error originates in the macro `$crate::format_args_nl` which comes from the expansion of the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
help: consider cloning the value if the performance cost is acceptable
   |
9  |     map.insert(field_name.clone(), field_value);
   |                          ++++++++

-> 쓸거면 clone 해서 insert 하라는 뜻

4. 해시맵 업데이트

- 값 덮어쓰기

키-값은 유니크함

키에 이미 값이 할당되어 있는 경우 덮어쓴다! (insert 는 키-값 존재 여부 판단 안 함)

let mut scores = HashMap::new();

scores.insert(String::from("Blue"), 10);
scores.insert(String::from("Blue"), 25);

println!("{:?}", scores); // 이 경우 {"Blue": 25}가 출력됨

- 키가 없을 때만 키, 값 추가하기 : entry

entry(매개변수 : 검색하려는 키) -> 반환:열거형 Entry

열거형 Entry : 해당 키 존재 여부 {Occupied, Vacant}

or_insert : Occupied 일 경우 해당 값을 반환 / Vacant일 경우 새 값 삽입 후 해당 값 반환

pub fn or_insert(self, default: V) -> &'a mut V (가변 참조자 반환)

use std::collections::HashMap;

let mut scores = HashMap::new();
scores.insert(String::from("Blue"), 10);

scores.entry(String::from("Yellow")).or_insert(50);
scores.entry(String::from("Blue")).or_insert(50);

println!("{:?}", scores); // {"Blue": 10, "Yellow": 50}

- 예전 값에 기초해 값 업데이트하기

text 에 각 단어가 몇번 나왔는지 세서 해시맵의 값을 변경시켜주는 예제

* 애스터리스크로 map 의 V에 접근해서 +1 (or_insert가 가변 참조자를 반환해서 역참조로 +1 가능)

let text = "hello world wonderful world";
let mut map = HashMap::new();

for word in text.split_whitespace() {
    let count = map.entry(word).or_insert(0);
    *count += 1;
}

println!("{:?}", map); // {"wonderful": 1, "hello": 1, "world": 2}

이때 map 의 출력 순서가 다를 수 있는데, 해시맵에 대한 반복 처리가 임의의 순서로 일어나기 때문

5. 해시 함수

기본적으로 해시테이블과 관련된 Dos 공격에 저항 기능을 제공하는 SipHash 함수를 사용

가장 빠른 해시 알고리즘은 아니어서 성능은 낮지만 보안을 챙김

- 목적에 따라 다른 hasher를 지정해 해시 함수를 바꿀 수 있음

- hasher: BuildHasher trait을 구현한 타입

- crate.io에 다양한 범용적 해시 알고리즘을 구현한 라이브러리가 있으므로 처음부터 구현하지 않아도 됨

[Rust] use 키워드

이내내 — Thu, 10 Aug 2023 22:44:39 +0900

use 키워드로 경로 가져오기

1. use를 사용함으로써 함수를 가져오는 경로를 단축시킬 수 있다.

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

use crate::front_of_house::hosting;

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

- 파일 시스템의 심볼릭 링크(symbolic link)를 생성하는 것과 유사

(* 심볼릭 링크: 링크를 연결해 원본 파일을 직접 사용하는 것과 같은 효과를 내는 링크)

- use로 가져온 경우도 privacy 규칙이 적용됨 -> 다른 스코프에서는 쓸 수 없음

1.1) 사용된 스코프 내에서만 단축 경로가 적용

아래와 같이 customer에 mod로 스코프를 바꾸면 hosting의 단축경로가 적용되지 않아 사용하지 않았다는 warning이 뜬다.

-> use도 customer 안으로 옮기거나 super::hosting으로 부모 모듈로의 단축 경로를 참조하면 가능

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

use crate::front_of_house::hosting;

mod customer {
    pub fn eat_at_restaurant() {
        hosting::add_to_waitlist();
    }
}

warning: unused import: `crate::front_of_house::hosting`
 --> src/main.rs:7:5
  |
7 | use crate::front_of_house::hosting;
  |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  |
  = note: `#[warn(unused_imports)]` on by default

1.2) 아래와 같이 경로를 모두 작성하는 경우도 가능하지만 함수를 호출할 때 부모 모듈을 명시적으로 보여주는 것이 보편적

가져온 함수가 어디 정의되어 있는지 알기도 좋음

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

use crate::front_of_house::hosting::add_to_waitlist;

pub fn eat_at_restaurant() {
    add_to_waitlist();
}

1.2-1) 구조체나 열거형 등을 가져올 때는 전체 경로를 작성하는 게 보편적

- HashMap 표준 라이브러리 구조체를 use로 가져오는 예시

use std::collections::HashMap;

fn main() {
    let mut map = HashMap::new();
    map.insert(1, 2);
}

1.3) 동일한 이름의 아이템을 여럿 가져오는 경우 부모 모듈을 반드시 명시 -> 누구의 것을 가져오는지 알기 위해

- 동일한 Result 아이템을 같은 스코프에서 사용하는 예시

use std::fmt; // use std::fmt::Result 으로 쓰게되면 누구의 Result를 쓰는지 알 수 없다
use std::io;

fn function1() -> fmt::Result {
    // --생략--
}

fn function2() -> io::Result<()> {
    // --생략--
}

1.3-1) as 키워드로 별칭을 제공해 동일한 이름의 타입 구분 가능

use std::fmt::Result;
use std::io::Result as IoResult;

fn function1() -> Result {
    // --생략--
}

fn function2() -> IoResult<()> {
    // --생략--
}

2. pub use 로 다른 스코프에서도 사용 가능

다른 곳에서 사용할 수 있게 만들기 때문에 다시 내보내기(re-exporting)라고도 함

pub use crate::front_of_house::hosting;

3. 외부 패키지 사용하기

- Cargo.toml 에 외부 패키지를 의존성으로 추가

추가 시 cargo가 crates.io에서 의존성을 다운로드 하여 프로젝트에서 패키지를 사용할 수 있게 됨(use 키워드로 스코프로 가져와 사용)

// Cargo.toml
rand = "0.8.5"

// project
use rand::Rng;

* std 표준 라이브러리도 외부 크레이트이므로, Cargo.toml에 추가할 필요는 없지만 use로 스코프로 가져와야 사용할 수 있음

use std::collections::HashMap;

4. 중첩 경로를 사용해 대량의 use 나열 정리

use 중복되는경로{나뉘는 경로1, 나뉘는 경로2, ...}

use std::cmp::Ordering;
use std::io;

// 이거를, 아래와 같이 중첩 가능
use std::{cmp::Ordering, io};

// 중복되는 경로 그자체인 경우 self 를 중첩 경로에 작성 
use std::io::{self, Write};

5. glob 연산자 *

경로에 글롭 연산자를 붙이면 경로 안에 정의된 모든 public 아이템을 가져올 수 있음

-> all 의 의미

use std::collections::*;

[Rust] 보편적인 프로그래밍 개념(데이터 타입 / 함수 / 주석 / 제어문)

이내내 — Wed, 26 Jul 2023 00:21:28 +0900

1. 데이터 타입

러스트는 타입이 고정된 강타입 언어로, 데이터 타입은 스칼라, 컴파운드(복합타입) 로 나뉜다.

* 강타입(strongly-type): 컴파일 타임에 타입 체크를 하며, 묵시적 형변환이 금지되는 언어

1) 스칼라

하나의 값으로 표현되는 타입

- 정수형 / 부동 소수점 숫자형 / boolean / 문자(char) 가 있음

정수형

정수 타입
bit size	signed	unsigned
8-bit	i8	u8
16-bit	i16	u16
32-bit	i32 (일반적으로 사용)	u32
64-bit	i64	u64
128-bit	i128	u128
32-bit / 64-bit 아키텍처에 따라 다름 - 포인터 타입	isize	usize

정수 리터럴 :

- Decimal -> 100_000 가능

- Hex -> 0xff

- Octal -> 0o77

- Binary -> 0b0010

- Byte(u8 only) -> b'A'

fn main() {
    let tmp = 100_000;
    println!("{}", tmp); // output: 100000
}

부동 소수점 숫자형

- f32 / f64(기본 타입)

아래와 같이 명시적으로 타입을 적지 않은 상태라면 f64로 64bit 의 크기를 갖는다.

fn main() {
    let tmp = 32.2 / 6.5; // -> f64타입
    println!("{}", tmp); // output: 4.953846153846154

    let tmp2 : f32 = 32.2 / 6.5;
    println!("{}", tmp2); // output: 4.9538465
}

Boolean형

true, false 값을 가짐

문자형

char로 작은 따옴표로 표기

Unicode scalar 를 표현하는 값으로 아스키보다 많은 표현 가능

fn main() {
    let c = 'z';
    let z = 'ℤ';
    let heart_eyed_cat = ' ';

    println!("{} {} {}", c, z, heart_eyed_cat); // z ℤ  
 }

2) 컴파운드(복합 타입)

러스트는 복합 타입으로 튜플과 배열을 사용한다.

튜플

서로 다른 타입의 변수를 묶어서도 사용 가능하고, 0, 1, ... n 으로 인덱스를 사용해 원소를 사용할 수도 있다.

fn main() {
    let tup: (i32, f64, u8) = (500, 6.4, 1);
    println!("{} {} {}", tup.0, tup.1, tup.2); // 500 6.4 1
    
    let (tmp1, tmp2, tmp3) = tup;
    println!("{} {} {}", tmp1, tmp2, tmp3); // 500 6.4 1
}

배열

원소가 같은 요소를 묶은 집합. 한번 선언되면 크기가 변하지 않는다.

마찬가지로 각 요소는 인덱스로 접근 가능하다.

또한 순회도 가능 (for 변수 in range)

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

fn main() {
    let a = [1, 2, 3, 4, 5];
    
    for i in 0..a.len() 
    {
        println!("{}", i);
    }
}
//0
//1
//2
//3
//4

2. 함수

- snake case 로 네이밍한다. (ex. function_example())

- 함수 정의는 main 함수의 위치에 종속되지 않는다.

- 매개변수 정의 방식 (두 개 이상인 경우 , 콤마로 구분)

fn main() {
    another_function(5);
}

fn another_function(x: i32) {
    println!("The value of x is: {}", x);
}

- 리턴 타입 정의 방식 (정의되어 있지 않으면 묵시적으로 추론)

fn five() -> i32 {
    5 // 이것도 되고
    // return 5 // 이것도 됨
}

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

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

- { 괄호 } 로 범위 생성 가능

변수는 범위 안에 있는 것만 사용 가능

- 범위 밖에서 변수를 사용하면 -> cannot find value `변수` in this scope를 볼 수 있다.

fn main() {
    {
        let tmp = 32;
    }
    println!("{}", tmp); // error
}

3. 주석

// 이 방식 가능

/* 이 방식 가능 */

4. 제어문

"if 조건식 {조건문 본문}" 의 형태

fn main() {
    let number = 6;

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

아래와 같이 let 문에 if 로 표현식을 쓸 수 있다.

fn main() {
    let condition = true;
    let answer = if condition {
        true
    } else {
        false
    };

    println!("{}", answer); // true
}

while 또한 유사하게 사용할 수 있다.

fn main() {
    let mut number = 3;

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

        number = number - 1;
    }

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

[Rust] 러스트 설치하기 - Windows

이내내 — Mon, 24 Jul 2023 00:53:50 +0900

Windows 에서 Rust 설치하기

1. https://www.rust-lang.org/en-US/install.html 에서 rustup 다운로드

업데이트

명령 프롬프트 창에서

$ rustup update

삭제

$ rustup self uninstall

버전 확인

$ rustc --version

2. 에디터 설정하기

(vscode 를 사용하는 경우라고 가정)

1) rust-analyzer 설치

2) 디버깅 툴 설치

- C/C++ - microsoft

- CodeLLDB

3. 프로젝트 생성

$ cargo new hello_cargo --bin
$ cd hello_cargo

--bin 옵션은 바이너리 파일을 생성하는 옵션

[러스트] 추리 게임

이내내 — Tue, 18 Jul 2023 05:55:52 +0900

- 실습 프로젝트로 러스트를 익혀 보자!

let, match, 메서드, 연관 함수(associated functions), 외부 크레이트(externals crates) 등의 활용을 배워보자.

Q. 1~100 사이의 임의의 정수를 생성한다. 다음으로 플레이어가 프로그램에 추리한 정수를 입력한다. 프로그램은 입력받은 추리값이 정답보다 높거나 낮은지 알려준다. 추리 값이 정답이라면 축하 메시지를 보여주고 종료된다. (=> 업앤다운)

1. 프로젝트 생성

$ cargo new guessing_game --bin
$ cd guessing_game

- cargo new : 프로젝트 이름 guessing_game 을 인자로 받는 명령어로 인자를 이름으로한 프로젝트 디렉터리를 생성한다.

--bin 은 바이너리용 프로젝트를 생성하도록 하는 옵션

생성된 프로젝트는 기본적으로 src/main.rs 를 가지고 있으며 내용은 아래와 같다.

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

cargo run 로 프로젝트를 컴파일 및 실행할 수 있다.

2. 추리값 처리

1) 먼저 사용자로부터 입력을 받아 처리한다.

// io 라이브러리를 가져오기. io 라이브러리는 std 표준 라이브러리에 있음
// 러스트 프로그램은 기본적으로 prelude 라는 라이브러리들을 지원하며, 여기서 심볼을 가져오는데 
// 원하는 타입, 심볼이 prelude에 없다면 use로 가져와야 함.
use std::io;

// main - 함수의 진입점. 여기서부터 프로그램이 시작
fn main() {

// !는 러스트 매크로로, 함수 대신 매크로를 호출. 
// 문자열을 스크린에 출력
    println!("Guess the number!");

    println!("Please input your guess.");

// let 으로 변수를 선언하고 mut 으로 해당 변수를 가변 변수로 명시 
// 가변 변수 guess 를 String 타입으로 선언 및 저장 공간 할당
// guess 변수에 String 인스턴스가 bind 됨 - 값을 확정 짓는 것
// :: 는 new 가 String 타입의 "연관함수" 임을 나타냄 <- 정적 메서드
// new : 빈 String 생성
    let mut guess = String::new();

// io 라이브러리의 연관함수인 stdin 호출
// read_line() 은 &mut guess를 인자로 하는 사용자 입력을 받는 메서드
// read_line 은 입력마다 문자열에 저장하므로 값을 저장할 공간이 필요 -> 매번 변경되므로 가변이어야 함
// & 는 참조자로 메모리를 여러번 복사하지 않고 접근하는 방법을 제공
// (&가 불변이라 &mut 으로 가변으로 바꿈)
    io::stdin().read_line(&mut guess)
        .expect("Failed to read line"); // Result 타입

// 변경자(placeholder) 로 값 출력
    println!("You guessed: {}", guess);
}

2) Result 타입으로 잠재된 실패 다루기

io::stdin().read_line(&mut guess)
    .expect("Failed to read line");

여기서, read_line은 인자로 넘긴 문자열(&mut guess)에 입력을 저장하며, io::Result 값을 반환한다.

Result 타입은 열거형(enumerations, enums)으로

-> 정해진 값만 가질 수 있으며, 이 정해진 값들을 열거형의 variants 라고 한다.

Result 의 variants 는

- Ok : 처리가 성공했음을 나타냄. 내부적으로 성공적으로 생성된 결과를 가짐

- Err : 처리가 실패했음을 나타냄. 그 이유에 대한 정보를 가짐

io::Result는 expect 메서드를 가지는데,

io::Result 가 Ok 일 경우 -> Ok 가 가진 결과값(표준입력으로 들어온 바이트 수)을 반환해 사용할 수 있도록 함.

io::Result 가 Err 일 경우 -> 프로그램이 작동을 멈추고 expect에 인자로 넘겼던 (에러)메시지를 출력하도록 함

- read_line 에서 Err 를 반환했다면, 운영체제로부터 생긴 에러 일 경우가 큼

- expect 를 호출하지 않는 경우, 컴파일은 되지만 Result를 사용하지 않았다는 warning 을 도출

3) prinln! 변경자(placeholder)를 이용한 값 출력

println!("You guessed: {}", guess);

{} 는 변경자로 값이 표시되는 위치를 나타내며, 하나 이상의 값을 표시할 수 있다.

첫번째 {}는 포맷 스트링 뒤 첫번째 값 (여기서는 guess) 를 나타내며,

아래와 같이 {} 의 개수 만큼 포맷 스트링 뒤에 붙는 인자를 보여줄 수 있다.

let x = 5;
let y = 10;

println!("x = {} and y = {}", x, y);
// output: x = 5 and y = 10

3. 비밀번호 생성하기

1~100 사이 매번 랜덤한 번호를 생성한다.

-> rand 크레이트를 활용해보자.

* crate : 패키지 (러스트 코드 묶음)

* rand crate : 다른 프로그램에서 사용되기 위한 용도의 library crate

외부 크레이트를 사용하려면 Cargo.toml 의 [dependencies] 에 추가하면 된다.

[dependencies]

rand = "0.3.14"

- [dependencies]는 프로젝트가 의존하고 있는 외부 크레이트와 그 버전을 명시하는 곳

-> cargo build 혹은 cargo run로 rand 라이브러리를 다운로드

dependencies 에는 rand만 추가했지만, rand 가 libc 에 의존하므로 같이 다운로드 받아진다.

* Cargo 는 Crates.io (러스트 오픈소스) 데이터의 복사본인 레지스트리에서 라이브러리들을 가져온다.

$ cargo build
    Updating registry `https://github.com/rust-lang/crates.io-index`
 Downloading rand v0.3.14
 Downloading libc v0.2.14
   Compiling libc v0.2.14
   Compiling rand v0.3.14
   Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
    Finished dev [unoptimized + debuginfo] target(s) in 2.53 secs

Cargo.lock

Cargo.lock 은 모든 의존 패키지의 버전을 확인하고 이를 기록해 빌드 시 그 안에 명시된 버전을 사용하도록 하는 기능을 한다.

즉, dependencies 에 기재된 버전을 업그레이드 하지 않는 이상, 기재된 버전을 사용함으로써 안정된 버전을 사용하는 것을 보장한다.

-> 크레이트를 업그레이드 하고 싶다면, update 명령어를 사용하자.

이는 새로운 버전을 사용하게 하고, 만약 새 버전이 문제가 없다면 Cargo.lock 에 기재해 사용할 수 있게 한다.

그런데 현재 Cargo.toml에 v.0.3.~ 버전이 기재되어 있으므로 아래처럼 0.3.~ 버전대에서 업그레이드 할 수 있는 버전(0.3.15)을 찾는다.

$ cargo update
    Updating registry `https://github.com/rust-lang/crates.io-index`
    Updating rand v0.3.14 -> v0.3.15

다른 버전대로 업그레이드 하고 싶다면, Cargo.toml 을 변경하면 된다.

[dependencies]

rand = "0.4.0"

임의의 숫자 생성하기

이제 코드에서는 어떻게 달라지는지 보자.

extern crate rand;

use std::io;
use rand::Rng;

fn main() {
    ...
    
// read::thread_rng: OS가 seed 를 정하고 현재 스레드에서만 사용되는 정수 생성기를 반환
// get_range : 두 숫자를 인자로 받고 두 수 사이의 임의의 숫자를 반환(1 ~ 99 중 하나를 반환)
    let secret_number = rand::thread_rng().gen_range(1, 101);

    ...
}

상단에 rand 크레이트를 외부에서 가져오고, use 하는 문구가 추가되었다.

이제 rand:: 를 이용해 rand 내의 모든 것을 호출할 수 있다.

rand::Rng 는 정수 생성기가 구현한 메서드들을 정의한 trait 이다. (trait은 나중에 알아본다.)

각 크레이트에 대한 내용은 cargo doc --open 으로 공식 문서를 열어 확인할 수 있다.

4. 비밀번호와 추리값 비교하기

extern crate rand;

use std::io;
// Less, Greater, Equal 열거형을 나타냄
use std::cmp::Ordering;
use rand::Rng;

fn main() {
    ...

// 여기서 guess 를 u32 타입으로 섀도우해주어 match에서 타입 에러가 나지 않게 한다.
// trim : String 앞, 뒤의 스페이스 제거
// parse : String 을 정수형으로 파싱
// expect : 파싱 실패 시 에러 메시지 출력
    let guess: u32 = guess.trim().parse()
        .expect("Please type a number!");

    ...

// cmp : 두 값을 비교하며, 비교 가능한 모든 것에 대해 호출한다.
// 인자로 &secret_number를 받아 guess 와 비교한다.
// match 는 표현문으로 guess와 secret_number를 비교한 결과에 따라 어떤 println! 이 나올지 결정한다.
    match guess.cmp(&secret_number) {
        Ordering::Less    => println!("Too small!"),
        Ordering::Greater => println!("Too big!"),
        Ordering::Equal   => println!("You win!"),
    }
}

match 표현식은 arm 으로 이뤄져있다.

- arm : match 의 각 케이스 ex) Ordering::Less => println!("Too small!")

매칭은 처음부터 순서대로 수행되는데, 만약 중간(Greater쯤)에서 매칭이 이뤄진다면,

해당하는 코드 (println!)를 실행하고 match문을 빠져나간다. (break 필요 x)

5. 반복으로 여러 번 추리하기

- loop 키워드를 사용해 반복문을 돌린다.

loop {
    문장 ...
}

- break 키워드로 빠져나간다.

break 키워드가 없으면, 무한 루프를 돌기 때문에 Ctrl+c 나 프로그램 내 비정상 종료 (Result expect - Err)일 경우에 빠져나갈 수 있다.

- continue 키워드

원하는 입력을 받지 못한 경우 입력 다음 처리를 건너뛰어 다시 루프를 시작하게 한다.

// 반복 시작
    loop {
        ...
        
// expect -> match 로 바꿔 Err 시 종료를 Err 시 continue 처리로 바꾼다.
        let guess: u32 = match guess.trim().parse() {
            Ok(num) => num,     // <- guess 는 num 값을 갖게 된다.
            Err(_) => continue, // <- 여기서 해당 반복을 건너뛰고 다음 반복을 시작할 수 있다.
        };

        ...
        
        match guess.cmp(&secret_number) {
            Ordering::Less    => println!("Too small!"),
            Ordering::Greater => println!("Too big!"),
            Ordering::Equal   => {
                println!("You win!");
                break; // <- 여기서 loop 를 빠져나갈 수 있다.
            }
        }
    }

* _ 는 모든 값과 매칭할 수 있다.

최종 코드

extern crate rand;

use std::io;
use std::cmp::Ordering;
use rand::Rng;

fn main() {
    println!("Guess the number!");

    let secret_number = rand::thread_rng().gen_range(1, 101);

    loop {
        println!("Please input your guess.");

        let mut guess = String::new();

        io::stdin().read_line(&mut guess)
            .expect("Failed to read line");

        let guess: u32 = match guess.trim().parse() {
            Ok(num) => num,
            Err(_) => continue,
        };

        println!("You guessed: {}", guess);

        match guess.cmp(&secret_number) {
            Ordering::Less    => println!("Too small!"),
            Ordering::Greater => println!("Too big!"),
            Ordering::Equal   => {
                println!("You win!");
                break;
            }
        }
    }
}

[러스트] 불변성

이내내 — Mon, 17 Jul 2023 22:49:03 +0900

모든 프로그래밍 언어 대부분이 가진 개념을 러스트가 어떻게 다루는지 알아본다.

- 변수, 기본 타입들, 함수, 주석, 제어문 등

변수와 가변성

기본 변수는 불변성 즉, 변하지 않는다. => 안전성과 손쉬운 동시성을 가질 수 있음

변수가 불변인 경우, 값이 이름에 bind 되면 해당 값을 변경할 수 없다.

아래 처럼 variables 디렉터리를 생성해 확인해보자.

cargo new --bin variables

src/main.rs

fn main() {
    let x = 5;
    println!("The value of x is: {}", x);
    x = 6;
    println!("The value of x is: {}", x);
}


//
error[E0384]: cannot assign twice to immutable variable `x`
 --> src/main.rs:4:5
  |
2 |     let x = 5;
  |         -
  |         |
  |         first assignment to `x`
  |         help: consider making this binding mutable: `mut x`
3 |     println!("The value of x is: {}", x);
4 |     x = 6;
  |     ^^^^^ cannot assign twice to immutable variable

For more information about this error, try `rustc --explain E0384`.
error: could not compile `variables` (bin "variables") due to previous error

에러가 나는데, 이는 불변성 변수 x에 재할당을 했기 때문이다.

러스트는 변수의 불변성을 보장함으로써 변수의 값이 변경되어 버그가 일어나는 경우(고통의 트래킹!)를 방지함으로써 코드를 더 합리적으로 만들어준다.

그러나 러스트는 가변성의 유용성 역시 놓치지 않았다.

바로, mut 을 사용함으로써 변수를 가변적으로 만드는 것이다.

mut 은 x에 bind된 값을 변경할 수 있게 만든다.

fn main() {
    let mut x = 5;
    println!("The value of x is: {}", x);
    x = 6;
    println!("The value of x is: {}", x);
}

// 
$ cargo run
   Compiling variables v0.1.0 (file:///projects/variables)
    Finished dev [unoptimized + debuginfo] target(s) in 0.30 secs
     Running `target/debug/variables`
The value of x is: 5
The value of x is: 6

가변 변수가 유용한 경우는

대규모 데이터 구조체를 다루는 경우이다. -> 가변 인스턴스를 사용하는 것이 새로 인스턴스를 할당하고 반환하는 것보다 빠를 수 있음

그러나, 데이터 규모가 작을수록 새 인스턴스를 생성하고 함수적 프로그래밍 스타일로 작성하는 것이 더 합리적이고, 약간의 성능 하락을 통해 가독성을 확보할 수 있다면 그것이 더 가치있을 수 있다.

언뜻 불변성의 변수는 상수(constant)와 비슷해보이지만 상수는 mut 을 허용하지 않는다.

상수는 let 대신 const 키워드를 사용하고 값의 타입을 함께 선언해야한다.

상수는 오직 상수 표현식만 설정될 수 있으며 함수 호출의 결과값이나 그 외 런타임에 결정되는 값으로 설정될 수 없다.

다음의 예제처럼 상수 (MAX_POINTS)는 값의 타입과 함께 선언한다.

const MAX_POINTS: u32 = 100_000;

상수는 선언된 영역 내에서 항상 유효하므로 유용하다. (한 게임에서 획득할 수 있는 최대 포인트 등)

Shadowing

let으로 이전에 선언한 변수와 동명의 새 변수를 선언할 수 있고,

새 변수는 이전 변수를 shadow 한다. 이를 첫 변수가 두번째 변수에 의해 shadowed 되었다고 표현한다.

-> 해당 변수명이 두번째 변수의 값을 갖게 된다는 의미

아래의 예제와 같이 활용할 수 있다.

fn main() {
    let x = 5; // x <- 5

    let x = x + 1; // x <- 6 

    let x = x * 2; // x <- 12

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

이는 mut 으로 선언한 것과는 차이가 있는데, let 없이 변수에 새 값을 대입하려고 하면 컴파일 에러가 발생하기 때문.

mut 과 let 의 차이는 let 은 효과적으로 동명의 새 변수를 선언하고 값 타입을 변경할 수 있다는 것이다. (새롭게 정의된 변수이기 때문)

아래 예제에서 spaces 는 처음에 string 값을 가지지만 두번째 라인에서 정수 값을 가진다.

let spaces = "   ";
let spaces = spaces.len();

이를 아래처럼 mut을 사용하면, 가변 변수의 값의 타입을 변경하게 되어 컴파일 에러가 발생한다.

let mut spaces = "   ";
spaces = spaces.len();

[러스트] 러스트 시작하기 - Hello World!

이내내 — Mon, 17 Jul 2023 08:20:48 +0900

https://rinthel.github.io/rust-lang-book-ko/ch01-02-hello-world.html

Hello, World! - The Rust Programming Language

여러분이 러스트를 설치했으니, 이제 여러분의 첫번째 러스트 프로그램을 작성해봅시다. 새로운 언어를 배울 때면 “Hello, world!”라는 텍스트를 스크린에 출력하는 짧은 프로그램을 작성하는

rinthel.github.io

터미널에 아래 명령어를 실행해 폴더를 만들어 프로젝트를 진행해보자.

// home 디렉터리에 projects 디렉터리 생성
$ mkdir ~/projects

// projects 디렉터리로 이동
$ cd ~/projects

// hello_world 디렉터리 생성
$ mkdir hello_world

// hello_world 디렉터리로 이동
$ cd hello_world

파일명은 main.rs

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

터미널에서 main.rs를 실행시켜준다.

// 컴파일
$ rustc main.rs

// 실행
$ ./main
Hello, world!

와! 첫 rust 프로그램을 실행했다!

fn 은 함수를 정의한다.

여기서 main은 모든 실행 가능한 러스트 프로그램 중 첫번째로 실행되는 코드다.

함수 본체는 {}로 감싼다.

위 Hello, world! 를 살펴보자.

1. 러스트 스타일은 탭이 아닌 4개의 스페이스로 들여쓰기를 한다.

2. println! 은 러스트 매크로라고 한다. (함수는 println() 으로 쓰여야 함)

=> ! 는 보통 함수 대신 매크로를 호출한다.

3. "Hello, world!" string 을 사용한다. 매크로에 string 을 인자로 넘기고 이 string 이 화면에 출력된다.

4. 세미콜론 ; 으로 표현식을 끝낸다.

rustfmt 라는 자동 포맷팅 도구가 있으며 코드를 특정한 스타일로 포매팅하고자 할 때 사용할 수 있다.

컴파일

- rustc 로 수행한다.

=> 컴파일 후 실행가능한 바이너리를 출력한다.

러스트는 ahead-of-time compiled 언어로 프로그램을 컴파일하고 나면 실행파일을 통해 러스트를 설치하지 않고도 이를 실행할 수 있다는 의미이다.

간단한 프로그램은 rustc 로 컴파일해도 되지만, 프로젝트가 커지면 컴파일하기 힘들어지기 때문에 Cargo 를 사용한다.

Cargo

- 러스트의 빌드 시스템 및 패키지 매니저

코드를 빌드하고, 라이브러리를 다운해주고, 그 라이브러리를 빌드하는 등 많은 작업을 다룸

(코드가 필요로 하는 라이브러리를 의존성(dependency)라고 함)

cargo 가 있는지 확인하려면 아래처럼 확인 가능

cargo --version

cargo 를 이용해 새로운 프로젝트를 만들어보자.

$ cargo new hello_cargo --bin
$ cd hello_cargo

cargo new hello_cargo --bin => 실행 가능한 바이너리를 생성한다.

--bin => 인자가 라이브러리가 아닌 실행 가능한 애플리케이션으로 만들어준다. (= 바이너리 파일)

cargo는 hello_cargo 디렉터리에 프로젝트 파일(Cargo.toml, src/main.rs)을 생성한다. 또한 .gitignore 와 함께 새로운 Git 저장소도 초기화한다.

Cargo.toml

[package]
name = "hello_cargo"
version = "0.1.0"
authors = ["Your Name <you@example.com>"]

[dependencies]

이 파일은 TOML(Tom’s Obvious, Minimal Language) 이라는 Cargo 환경 설정 포맷이다.

- [package] 는 환경설정을 나타내는 섹션의 시작점

- 다음의 3 라인은 컴파일하기 위해 필요로 하는 정보에 대한 설정. cargo 는 환경에서 사용자의 이름과 이메일 정보를 얻어내므로 정확치 않다면 수정 필요

- [dependencies] 는 프로젝트의 의존성 리스트를 적을 수 있는 섹션의 시작점

러스트는 코드의 패키지를 크레이트(crate)라고 부른다.

cargo는 소스 파일이 src 디렉터리 안에 있을 것으로 예상하기 때문에 소스 코드는 src 안에 넣어두고, 관련 없는 readme, 라이센스 정보, Cargo.toml 등은 상위에 빼놓는다.

Cargo 프로젝트를 빌드하고 실행하기

$ cargo build
   Compiling hello_cargo v0.1.0 (file:///projects/hello_cargo)
    Finished dev [unoptimized + debuginfo] target(s) in 2.85 secs

=> cargo build

이는 실행 파일을 생성하고, 생성된 파일은 ./target/debug/hello_cargo 을 통해 실행할 수 있다. => ./(파일 경로)

cargo build 를 실행하면, Cargo.lock 파일을 최상위 디렉터리에 생성한다. -> 이는 프로젝트에 어떠한 의존성도 가지고 있지 않고 파일의 내용이 얼마 없다. 신경 쓸 필요 x

* 빌드된 파일의 저장경로는 target/debug 이다.

cargo run

- 단숨에 프로젝트를 빌드하고 실행할 수 있다.

만약 코드를 수정한다면, run 내용에 컴파일 내용이 추가된다.

$ cargo run
   Compiling hello_cargo v0.1.0 (file:///projects/hello_cargo)
    Finished dev [unoptimized + debuginfo] target(s) in 0.33 secs
     Running `target/debug/hello_cargo`
Hello, world!

cargo check

- 코드가 컴파일되는지 빠르게 확인해주지만, 실행 파일을 생성하지 않는 컴파일 체크 커맨드 => 실행 파일을 만들지 않아 더 빠르게 컴파일할 수 있다.

실행 파일을 사용할 준비가 되면 cargo build 로 실행파일을 만든다.

릴리즈

cargo build --release

- 최적화와 함께 컴파일 가능

- target/debug 대신 target/release 에 실행 파일 생성

- 배포용 릴리즈 빌드: 빠르게 실행되지만 만들어지는데 오래걸림 vs 개발용 빌드: 빠르게 생성되지만 실행되는데 오래 걸림

[Rust] 설치하기

이내내 — Mon, 17 Jul 2023 08:14:21 +0900

참고 문서 https://rinthel.github.io/rust-lang-book-ko/ch01-01-installation.html

설치하기 - The Rust Programming Language

첫 번째 단계는 러스트를 설치하는 것입니다. 우리는 rustup이라고 하는 러스트 버전 및 관련 도구들을 관리하기 위한 커멘드 라인 도구를 통하여 러스트를 다운로드할 것입니다. 다운로드를 위

rinthel.github.io

러스트 프로그래밍 언어

- 권한 분산에 관한 언어

-> 메모리 관리, 데이터 표현, 동시성에 대한 저수준의 디테일을 다루는 시스템 레벨의 일을 할 수 있음

초심자에게는...

- 속도와 메모리 사용 측면에서 효율적이면서 안정적인 코드를 작성할 수 있음

숙련자에게는...

- 저위험성 연산으로 병령성을 다룸 -> 더 공격적인 최적화가 가능

러스트는?

- 컴파일러 단에서 (찾기 힘든) 버그를 거부함으로써 개발자로 하여금 버그 추적보다 프로그램 로직에 집중할 수 있게 함

- Cargo 라는 의존성 관리자 및 빌드 도구로 의존성을 추가하고 컴파일하고 관리하도록 함

-> 패키지 매니저이자 빌드 시스템

- Rustfmt 으로 일관된 코딩 스타일을 반드시 따르도록 해줌

- Rust Language Server 는 코드 자동완성 및 인라인 에러 메시지를 위한 IDE 로의 결합을 도움

---

러스트 설치하기 - for mac

1. rustup 설치

참고
$ : 일반적인 커맨드 시작
# : 관리자 커맨드 시작
> : 파워쉘 커맨드 시작

설치 커맨드

$ curl https://sh.rustup.rs -sSf | sh

설치 후 다음 로그인 이후에 러스트를 자동적으로 시스템 패스에 추가하는데,

터미널을 재시작하지 않고 러스트를 바로 사용하려면 아래 커맨드를 입력해 시스템 패스 추가

$ source $HOME/.cargo/env

혹은 ~/.bash_profile에 시스템 패스를 추가할 수도 있음(~/.bash_profile 안에 작성)

$ export PATH="$HOME/.cargo/bin:$PATH"

링커 설치 -> 만약 컴파일시에 링커가 없다는 에러가 나오면 c 컴파일러를 설치할 것

2. 러스트 업데이트 및 삭제

// 업데이트
$ rustup update

// 삭제
$ rustup self uninstall

3. 버전 확인

- 제대로 설치되었는지 확인

$ rustc --version
// output ex: rustc x.y.z (abcabcabc yyyy-mm-dd)

로컬 문서 열어보기

- 로컬에서 공식 문서를 볼 수 있음

$ rustup doc

[프로그래머스 | C#] 명예의 전당 (1) List.Sort, heap 삽입-제거 구현

이내내 — Sat, 4 Feb 2023 19:28:10 +0900

https://school.programmers.co.kr/learn/courses/30/lessons/138477

프로그래머스

코드 중심의 개발자 채용. 스택 기반의 포지션 매칭. 프로그래머스의 개발자 맞춤형 프로필을 등록하고, 나와 기술 궁합이 잘 맞는 기업들을 매칭 받으세요.

programmers.co.kr

코드

매 주마다 점수를 받고, 그 주 마다 k 번째 순위 안에 드는 점수 중 가장 낮은 점수를 answer 배열에 넣어 반환한다.

매 주마다 받은 모든 점수는 score 배열에 들어있다.

using System;
using System.Collections.Generic;

namespace ConsoleApplication1
{
    public class 명예의_전당__1_
    {
        // static void Main()
        // {
        //     var answer = solution(3, new [] { 10, 100, 20, 150, 1, 100, 200 });
        //     foreach (var a in answer)
        //     {
        //         Console.Write(a + " ");
        //     }
        // }

        public static int[] solution(int k, int[] score) 
        {
            int[] answer = new int[score.Length];
            List<int> rank = new List<int>();
            for (int i = 0; i < score.Length; i++)
            {
            	// 1)
                if (rank.Count < k)
                {
                    rank.Add(score[i]);
                }
                // 2)
                else
                {
                    if (rank[0] < score[i])
                    {
                        rank[0] = score[i];
                    }
                }
                // 3)
                rank.Sort();
                answer[i] = rank[0];
            }
            return answer;
        }
    }
}

1) k명의 사람이 채워지기 전에는 모든 사람이 k개의 순위권에 든다. 따라서 순위 리스트 rank를 변경하지 않고 값을 Add만 한다.

2) k명이 다 채워졌다면, 순위 리스트를 변경해야한다. 또한 매 주마다 새로운 점수가 들어오기 때문에 새로 들어온 값 score[i]가 현재 순위권 안에 있는 점수보다 크다면 순위 리스트를 변경해야한다.

3) 변경된 순위 리스트를 오름차순으로 정렬한다. 정렬한 후에는 0번째에 있는 값이 가장 낮은 값이 되므로 rank[0]을 answer 배열에 넣는다.

List.Sort

List를 정렬하는 메서드이다.

기본형은 아래와 같으며, 매개변수 comparision은 비교 조건이다.

비교 조건을 넣지 않으면 해결 코드와 같이 오름차순으로 정렬된다.

public void Sort (Comparison<T> comparison);

아래와 같이 비교 조건을 넣어 내림차순으로 만들 수도 있다.

다른 상세한 조건을 넣으려면 비교 클래스를 만들어 매개변수로 넣어 쓸 수도 있다.

using System;
using System.Collections.Generic;

namespace ConsoleApplication1
{
    internal class Program
    {
        static void Main()
        {
            List<int> list = new List<int> { 5, 3, 1, 4, 2 };
            list.Sort(new Comparison<int>((n1, n2) => n2.CompareTo(n1)));
            foreach (var val in list)
            {
                Console.Write($"{val}, ");
            }
            // 출력: 5, 4, 3, 2, 1,
        }
    }
}

https://learn.microsoft.com/ko-kr/dotnet/api/system.collections.generic.list-1.sort?view=net-7.0

List<T>.Sort 메서드 (System.Collections.Generic)

지정된 또는 기본 IComparer<T> 구현 또는 제공된 Comparison<T> 대리자를 사용하여 List<T>의 요소 또는 요소의 일부를 정렬하여 목록 요소를 비교합니다.

learn.microsoft.com

heap 삽입(HInsert), 제거(HDelete)

heap(힙)은 완전 이진 트리로, 모든 노드에 저장된 값이 자식 노드에 저장된 값보다 크거나 같아야 하는 조건을 가진다. 즉, 루트 노드의 값이 가장 커야한다.

힙은 min heap, max heap 이 있는데, max heap은 루트 노드의 값이 가장 큰 조건일 때의 heap이고, min heap은 루트 노드의 값이 가장 작을 때의 heap이다.

문제에 적용해보면 힙에 들어갈 수 있는 점수 수를 k로 제한하고 힙에 점수가 들어갈 때마다 가장 작은 값이 루트에 놓이게 하여 결론적으로 루트 값을 answer 배열에 넣으면 문제를 풀 수 있다.

아래의 코드에서는 min heap의 삽입, 제거를 보인다.

void HInsert(ref List<int> buf, int item)
{
    buf.Add(item);
    int index = buf.Count - 1;
    while (index > 0)
    {
        int parent = (index - 1) / 2;
        if (buf[parent] > buf[index])
        {
            int tmp = buf[parent];
            buf[parent] = buf[index];
            buf[index] = tmp;
            index = parent;
        }
        else break;
    }
}

void HDelete(ref List<int> buf)
{
    int root = buf[0];
    buf[0] = buf[buf.Count - 1];
    buf.RemoveAt(buf.Count - 1);

    int index = 0;
    int last = buf.Count - 1;
    while (index < last)
    {
        int child = index * 2 + 1;
        if (child < last && buf[child] > buf[child + 1])
            child = child + 1;
        if (child > last || buf[index] <= buf[child])
            break;
                    
        int tmp = buf[child];
        buf[child] = buf[index];
        buf[index] = tmp;
        index = child;                                    
    }
}

- 삽입

삽입된 원소는 트리의 가장 마지막에 포함된다. 들어온 원소가 부모 노드의 값보다 작으면 들어온 값과 부모 값을 swap한다. 그 값을 계속 위로 비교-swap한다. 만약 들어온 값이 루트 값 보다 작다면 루트 노드까지 swap이 이루어지며 결론적으로 루트 노드의 값이 바뀌게 된다.

- 삭제

루트 노드의 값을 제거한다. 그 후 트리의 가장 마지막 값을 루트에 넣고 루트에 넣은 값을 자식 노드의 값과 비교하며 자식 노드와 현재 노드를 swap한다. 만약 루트에 들어간 값이 가장 큰 값이라면 루트의 마지막 위치에 놓일 때까지 계속 자식 노드와 비교하며 swap한다.

문제에 적용한다면 아래와 같이 사용할 수 있다.

public static int[] solution(int k, int[] score) 
{
    int[] answer = new int[score.Length];
    List<int> buffer = new List<int>();
    for (int i = 0; i < score.Length; i++)
    {
        HInsert(ref buffer, score[i]);
        if (buffer.Count > k)
            HDelete(ref buffer);
        answer[i] = buffer[0];
    }
    return answer;
}

[C#] 문자열 처리 [자리표시자, 문자열 보간]

이내내 — Thu, 2 Feb 2023 23:07:17 +0900

2023.02.05 추가 (3항 연산자의 경우 문자열 보간)

C# 에서 문자열을 처리하는 방법은 다양하다.

그 중 자리표시자, 문자열 보간에 대해 알아보도록 하자.

자리 표시자

문자열을 출력할 때 가장 쉬운 방법은 아래와 같다.

Console.WriteLine("hello");

출력 메서드 안에 string 문자열을 넣어주면 된다. 그런데 변수를 함께 출력하고 싶다면 어떻게 해야할까?

예를 들어, [나이]를 출력한다고 해보자.

int age = 10;
Console.WriteLine("my age is " + age);
// 출력: my age is 10

+ 연산자로 문자열을 연결할 수 있다.

다른 예시는 자리 표시자를 사용하는 것이다.

int age = 10;
Console.WriteLine("my age is {0}", age);
// 출력: my age is 10

자리 표시자는 위의 코드처럼 문자열 안에 {정수}를 넣어 정수에 해당하는 번지에 있는 변수를 대치시키는 방식이다.

예를 들어 {0}이라면 0 번째 변수를, {1}이라면 1번째 변수를 문자열 내 해당 위치에 대치한다.

자리표시자의 장점은 변수의 위치를 조정할 수 있다는 것이다.

int age = 10;
int tmp = 2;
Console.WriteLine("my age is {1}, {0}", age, tmp);
// 출력: my age is 2, 10

1번째 위치에 있는 tmp가 {1} 자리에 오고 0번째 위치에 있는 age가 {0} 자리에 옴으로써

my age is 2, 10 을 출력한다.

자리표시자는 매개변수가 늘어날수록 호출 문장도 길어진다는 단점이 있다.

C#6에서는 문자열 보간(interpolated string)이 등장한다.

문자열 보간

문자열 보간은 간단하다. "" 쌍따옴표 앞에 $ 문자만 붙여주고, 문자열 안에 변수를 나타낼 때 {} 중괄호를 씌워주기만 하면 된다.

int age = 10;
int tmp = 2;
Console.WriteLine($"my age is {age}, {tmp}");

Console.WriteLine 문장이 자리표시자에 비해 간결해지고 가독성이 좋아졌다.

이처럼 문자열 보간과 자리표시자를 이용해 동적인 값을 포함한 문자열을 처리할 수 있다.

또한 문자열의 포맷을 지정해주려면 : 로 뒤에 어떤 포맷인지 지정해주면 된다.

 // $"{변수:서식}"
 var date = new DateTime(2023, 2, 5);
 Console.WriteLine($"Today is {date:dddd, MMMM dd, yyyy}");
 // 출력: Today is 일요일, 2월 05, 2023
 
 Console.WriteLine($"{3.141592:F1}");
 // 출력: 3.1

문자열 서식에 대한 자세한 내용은 공식 문서에 자세히 나와있다.

https://learn.microsoft.com/ko-kr/dotnet/standard/base-types/composite-formatting#format-string-component

복합 형식 지정

입력으로 개체 목록을 사용하는 .NET 복합 서식 지정과 인덱싱된 자리 표시자를 사용하는 고정 텍스트가 포함된 복합 서식 문자열에 대해 알아봅니다.

learn.microsoft.com

참고로 3항 연산자(?:)의 경우 보간 문자열에서 ":"를 쓰게 되면 서식 지정과 충돌이 나게 된다.

따라서 다음과 같이 괄호로 조건식을 나타내면 해결 가능하다.

Console.WriteLine($"{(3 < 4 ? 3 : 4)}");  // 출력: 3

Console.WriteLine($"{3 < 4 ? 3 : 4}");  // 에러

https://learn.microsoft.com/ko-kr/dotnet/csharp/tutorials/string-interpolation

C#의 문자열 보간

문자열 보간을 사용하여 C#으로 결과 문자열에 서식이 지정된 식 결과를 포함하는 방법을 알아봅니다.

learn.microsoft.com