■ String 구조체의 chars 메소드를 사용해 반복자를 구하는 방법을 보여준다. ▶ 예제 코드 (RS)
|
1 2 3 4 5 6 7 |
use std::str; let source_string : String = String::from("ABCDEFGHIJKLMNOPQRSTUVWXYZ".to_string()); let mut source_chars: str::Chars = source_string.chars(); |
■ hound 크레이트를 설치하는 방법을 보여준다. ▶ Cargo.toml
|
1 2 3 4 5 6 |
... [dependencies] hound = "3.4.0" |
■ image 크레이트를 설치하는 방법을 보여준다. ▶ Cargo.toml
|
1 2 3 4 5 6 |
... [dependencies] image = "0.23.14" |
■ String 구조체 : split_whitespace 메소드를 사용해 공백 문자를 기준으로 문자열을 분리하는 방법을 보여준다. ▶ 예제 코드 (RS)
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
use std::str; fn main() { let source_string : String = String::from("A B C D E"); let token_split_whitespace : str::SplitWhitespace = source_string.split_whitespace(); for token in token_split_whitespace { let token_trimmed : &str = token.trim(); println!("{}", token_trimmed); } } |
■ 역 폴란드 표기법(RPN ; Reverse Polish Notation)의 수식을 계산하는 방법을 보여준다. ▶ 예제 코드 (RS)
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 |
use std::io; use std::str; fn main() { let mut vector : Vec<f64> = vec![]; println!("역 폴란드 표기법으로 수식을 입력해 주시기 바랍니다 : "); let mut input_string : String = String::new(); io::stdin().read_line(&mut input_string).expect("입력 문자열에서 에러가 발생했습니다."); let token_split_whitespace : str::SplitWhitespace = input_string.split_whitespace(); for token in token_split_whitespace { let token_trimmed : &str = token.trim(); match token_trimmed.parse::<f64>() { Ok(value) => { vector.push(value); continue; }, Err(_) => 0.0, }; let value2 : f64 = vector.pop().unwrap(); let value1 : f64 = vector.pop().unwrap(); match token_trimmed { "+" => vector.push(value1 + value2), "-" => vector.push(value1 - value2), "*" => vector.push(value1 * value2), "/" => vector.push(value1 / value2), _ => panic!("계산 불가 연산자 : {}", token_trimmed) } } println!("{}", vector.pop().unwrap()); } |
■ 절대/상대 경로를 사용해 모듈을 지정하는 방법을 보여준다. ▶ 예제 코드 (RS)
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 |
mod aaa { pub mod bbb { pub mod ccc { pub fn print() { println!("aaa::bbb::ccc::print"); } } } pub mod ddd { pub mod eee { pub fn print() { println!("aaa::ddd:eee:print"); } } pub mod fff { pub fn print() { super::eee::print(); super::super::bbb::ccc::print(); } } } } fn main() { aaa::bbb::ccc::print(); aaa::ddd::eee::print(); crate::aaa::ddd::fff::print(); } |
■ 모듈을 파일로 분리해서 사용하는 방법을 보여준다. ▶ src/random/linear.rs
|
1 2 3 4 5 6 7 8 9 10 11 12 |
use std::num::Wrapping; pub fn get_random_value(seed : &mut u32) -> u32 { let (a, c) = (134775813u32, 12345u32); *seed = (Wrapping(*seed) * Wrapping(a) + Wrapping(c)).0; return *seed; } |
▶ src/random/xorshift.rs
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
pub fn get_random_value(seed : &mut u32) -> u32 { let mut y : u32 = *seed; y ^= y << 13; y ^= y >> 17; y ^= y << 5; *seed = y; return y; } |
▶ src/random/mod.rs
|
1 2 3 4 |
pub mod linear; pub mod xorshift; |
▶ src/main.rs
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
mod random; use crate::random::{linear, xorshift}; fn main() { let mut seed : u32 = 1u32; let random_value1 : u32 = linear::get_random_value(&mut seed); let random_value2 : u32 = xorshift::get_random_value(&mut seed); println!("{}, {}", random_value1, random_value2); } |
test_project.zip
■ 단일 파일에서 복수 모듈를 사용하는 방법을 보여준다. ▶ 예제 코드 (RS)
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 |
mod random { pub mod linear { use std::num::Wrapping; pub fn get_random_value(seed : &mut u32) -> u32 { let (a, c) = (134775813u32, 12345u32); *seed = (Wrapping(*seed) * Wrapping(a) + Wrapping(c)).0; return *seed; } } pub mod xorshift { pub fn get_random_value(seed : &mut u32) -> u32 { let mut y : u32 = *seed; y ^= y << 13; y ^= y >> 17; y ^= y << 5; *seed = y; return y; } } } use random::{linear, xorshift}; fn main() { let mut seed1 : u32 = 12345u32; let mut seed2 : u32 = 12345u32; for i in 0..10 { let random_value1 : u32 = linear::get_random_value (&mut seed1) % 6 + 1; let random_value2 : u32 = xorshift::get_random_value(&mut seed2) % 6 + 1; println!("{:2} : {}, {}", i + 1, random_value1, random_value2); } } /* 1 : 1, 3 2 : 4, 4 3 : 3, 5 4 : 4, 3 5 : 5, 6 6 : 6, 1 7 : 5, 1 8 : 2, 3 9 : 3, 5 10 : 6, 5 */ |
■ super 키워드를 사용해 상위 모듈을 참조하는 방법을 보여준다. ▶ 예제 코드 (RS)
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 |
mod main_module { pub mod subsidary_module1 { pub fn get_value() -> u32 { return 1; } } pub mod subsidary_module2 { pub fn get_value() -> u32 { return super::subsidary_module1::get_value() + 1; } } } use main_module::subsidary_module2::get_value; fn main() { println!("{}", get_value()); } /* 2 */ |
■ 선형 합동법 알고리즘을 사용해 난수를 생성하는 방법을 보여준다. ▶ 예제 코드 (RS)
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 |
use std::num::Wrapping; fn get_seed(seed : &mut u32) -> u32 { let (a, c) = (134775813u32, 12345u32); *seed = (Wrapping(*seed) * Wrapping(a) + Wrapping(c)).0; return *seed; } fn get_random_value(seed : &mut u32, minimum_value : u32, maximum_value : u32) -> u32 { let random_value : u32 = get_seed(seed) % (maximum_value - minimum_value + 1) + minimum_value; return random_value; } fn main() { let mut seed : u32 = 12345u32; for i in 0..10 { let random_value : u32 = get_random_value(&mut seed, 1, 10); println!("{}, {}", i + 1, random_value); } } /* 1, 9 2, 2 3, 1 4, 2 5, 5 6, 2 7, 9 8, 6 9, 7 10, 4 */ |
■ Option<T> 열거형과 match문을 사용하는 방법을 보여준다. ▶ 예제 코드 (RS)
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 |
fn print_bmi(height : f32, weight : Option<f32>) { let bmi_option : Option<f32> = match weight { Some(weight) => Some(weight / (height / 100.0).powf(2.0)), None => None }; let message_string_slice : &str = match bmi_option { Some(n) if n < 18.5 => "저체중", Some(n) if n < 23.0 => "정상", Some(n) if n < 25.0 => "비만전단계", Some(n) if n < 30.0 => "1단계 비만", Some(n) if n < 35.0 => "2단계 비만", Some(_) => "3단계 비만", None => "계산 불가" }; println!("BMI : {:.1}, 결과 : {}", bmi_option.unwrap(), message_string_slice); } fn main() { let height : f32 = 162.3; print_bmi(height, Some(48.0)); print_bmi(height, Some(72.3)); print_bmi(height, None ); } |
■ match문에서 매치 가드를 사용하는 방법을 보여준다. ▶ 예제 코드 (RS)
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 |
fn main() { for i in 1..=100 { let message : String = match i { n if n % 15 == 0 => "FizzBuzz".to_string(), n if n % 3 == 0 => "Fizz".to_string(), n if n % 5 == 0 => "Buzz".to_string(), _ => format!("{}", i) }; println!("{}", message); } } /* 1 2 Fizz 4 Buzz Fizz 7 8 Fizz Buzz 11 Fizz 13 14 FizzBuzz 16 17 Fizz 19 Buzz Fizz 22 23 Fizz Buzz 26 Fizz 28 29 FizzBuzz 31 32 Fizz 34 Buzz Fizz 37 38 Fizz Buzz 41 Fizz 43 44 FizzBuzz 46 47 Fizz 49 Buzz Fizz 52 53 Fizz Buzz 56 Fizz 58 59 FizzBuzz 61 62 Fizz 64 Buzz Fizz 67 68 Fizz Buzz 71 Fizz 73 74 FizzBuzz 76 77 Fizz 79 Buzz Fizz 82 83 Fizz Buzz 86 Fizz 88 89 FizzBuzz 91 92 Fizz 94 Buzz Fizz 97 98 Fizz Buzz */ |
■ match문으로 패턴 매칭을 사용해 FizzBuzz 문제를 푸는 방법을 보여준다. ▶ 예제 코드 (RS)
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 |
fn main() { for value in 1..=100 { match (value % 3, value % 5) { (0, 0) => println!("FizzBuzz"), (0, _) => println!("Fizz"), (_, 0) => println!("Buzz"), _ => println!("{}", value) } } } /* 1 2 Fizz 4 Buzz Fizz 7 8 Fizz Buzz 11 Fizz 13 14 FizzBuzz 16 17 Fizz 19 Buzz Fizz 22 23 Fizz Buzz 26 Fizz 28 29 FizzBuzz 31 32 Fizz 34 Buzz Fizz 37 38 Fizz Buzz 41 Fizz 43 44 FizzBuzz 46 47 Fizz 49 Buzz Fizz 52 53 Fizz Buzz 56 Fizz 58 59 FizzBuzz 61 62 Fizz 64 Buzz Fizz 67 68 Fizz Buzz 71 Fizz 73 74 FizzBuzz 76 77 Fizz 79 Buzz Fizz 82 83 Fizz Buzz 86 88 89 FizzBuzz 91 92 Fizz 94 Buzz Fizz 97 98 Fizz Buzz PS D:\rust\test_project> cargo run Compiling test_project v0.1.0 (D:\rust\test_project) Finished dev [unoptimized + debuginfo] target(s) in 0.50s Running `target\debug\test_project.exe` 1 2 Fizz 4 Buzz Fizz 7 8 Fizz Buzz 11 Fizz 13 14 FizzBuzz 16 17 Fizz 19 Buzz Fizz 22 23 Fizz Buzz 26 Fizz 28 29 FizzBuzz 31 32 Fizz 34 Buzz Fizz 37 38 Fizz Buzz 41 Fizz 43 44 FizzBuzz 46 47 Fizz 49 Buzz Fizz 52 53 Fizz Buzz 56 Fizz 58 59 FizzBuzz 61 62 Fizz 64 Buzz Fizz 67 68 Fizz Buzz 71 Fizz 73 74 FizzBuzz 76 77 Fizz 79 Buzz Fizz 82 83 Fizz Buzz 86 Fizz 88 89 FizzBuzz 91 92 Fizz 94 Buzz Fizz 97 98 Fizz Buzz */ |
■ enum 키워드를 사용해 열거형을 만드는 방법을 보여준다. ▶ 예제 코드 (RS)
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 |
enum Currency { Currency100(isize), Currency500(isize), Currency1000(isize), Currency5000(isize), Currency10000(isize), Currency50000(isize) } impl Currency { fn calculate_amount(&self) -> isize { match *self { Currency::Currency100 (value) => value * 100, Currency::Currency500 (value) => value * 500, Currency::Currency1000 (value) => value * 1000, Currency::Currency5000 (value) => value * 5000, Currency::Currency10000(value) => value * 10000, Currency::Currency50000(value) => value * 50000 } } } fn main() { let currency_vector : Vec<Currency> = vec! [ Currency::Currency100(3), Currency::Currency500(2), Currency::Currency1000(6), Currency::Currency5000(1), Currency::Currency10000(8), Currency::Currency50000(3) ]; let total_amount : isize = currency_vector.iter().fold(0, |total_amount, v| total_amount + v.calculate_amount()); println!("전체 금액 : {}", total_amount); } |
■ Iterator 트레잇의 take 메소드를 사용하는 방법을 보여준다. ▶ 예제 코드 (RS)
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 |
struct NumberIterator { maximum : usize, value : usize } impl NumberIterator { fn new(minimum : usize, maximum : usize) -> Self { return NumberIterator { maximum : maximum, value : minimum }; } } impl Iterator for NumberIterator { type Item = usize; fn next(&mut self) -> Option<Self::Item> { if self.value > self.maximum { return None; } self.value += 1; return Some(self.value - 1); } } fn main() { let iterator : NumberIterator = NumberIterator::new(10, 19); for value in iterator.take(5) { println!("{}", value); } } /* 10 11 12 13 14 */ |
■ Iterator 트레잇의 for_each 메소드를 사용하는 방법을 보여준다. ▶ 예제 코드 (RS)
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 |
struct NumberIterator { maximum : usize, value : usize } impl NumberIterator { fn new(minimum : usize, maximum : usize) -> Self { return NumberIterator { maximum : maximum, value : minimum }; } } impl Iterator for NumberIterator { type Item = usize; fn next(&mut self) -> Option<Self::Item> { if self.value > self.maximum { return None; } self.value += 1; return Some(self.value - 1); } } fn main() { let iterator : NumberIterator = NumberIterator::new(10, 14); iterator.for_each(|value| println!("{}", value)); } /* 10 11 12 13 14 */ |
■ Iterator 트레잇의 enumerate 메소드를 사용하는 방법을 보여준다. ▶ 예제 코드 (RS)
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 |
struct NumberIterator { maximum : usize, value : usize } impl NumberIterator { fn new(minimum : usize, maximum : usize) -> Self { return NumberIterator { maximum : maximum, value : minimum }; } } impl Iterator for NumberIterator { type Item = usize; fn next(&mut self) -> Option<Self::Item> { if self.value > self.maximum { return None; } self.value += 1; return Some(self.value - 1); } } fn main() { let iterator : NumberIterator = NumberIterator::new(10, 15); for (index, value) in iterator.enumerate() { println!("{} : {}", index, value); } } /* 0 : 10 1 : 11 2 : 12 3 : 13 4 : 14 5 : 15 */ |
■ Iterator 트레잇을 사용해 피보나치 수열을 구하는 반복자를 만드는 방법을 보여준다. ▶ 예제 코드 (RS)
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 |
struct FibonacciIterator { a : usize, b : usize } impl FibonacciIterator { fn new() -> Self { return FibonacciIterator { a : 1, b : 1 }; } } impl Iterator for FibonacciIterator { type Item = usize; fn next(&mut self) -> Option<Self::Item> { let temporary_value : usize = self.a; self.a = self.b; self.b += temporary_value; return Some(self.a); } } fn main() { let fibonacci_iterator1 : FibonacciIterator = FibonacciIterator::new(); for (index, value) in fibonacci_iterator1.enumerate() { if index >= 10 { break; } print!("{},", value); } println!(""); let fibonacci_iterator2 : FibonacciIterator = FibonacciIterator::new(); fibonacci_iterator2.take(10).for_each(|value : usize| print!("{},", value)); print!("\n") } |
■ Iterator 트레잇을 구현해 소수를 구하는 반복자를 만드는 방법을 보여준다. ▶ 예제 코드 (RS)
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 |
struct PrimeIterator { n : u8 } impl PrimeIterator { fn new() -> Self { return PrimeIterator { n : 1 }; } fn is_prime(&self) -> bool { for i in 2..self.n { if self.n % i == 0 { return false; } } return true; } } impl Iterator for PrimeIterator { type Item = u8; fn next(&mut self) -> Option<Self::Item> { loop { self.n += 1; if std::u8::MAX == self.n { return None } if self.is_prime() { return Some(self.n); } } } } fn main() { let prime_iterator : PrimeIterator = PrimeIterator::new(); for n in prime_iterator { print!("{},", n); } } |
■ AddAssign 트레잇을 사용해 구조체의 제네릭 메소드를 만드는 방법을 보여준다. ▶ 예제 코드 (RS)
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 |
#[derive(Debug)] struct Point<T> { x : T, y : T } impl<T> Point<T> where T : std::ops::AddAssign { fn new(x : T, y : T) -> Self { return Self { x, y }; } fn add(&mut self, source : Point<T>) { self.x += source.x; self.y += source.y; } } fn main() { let mut point : Point<i32> = Point::new(10, 10); println!("{:?}", point); point.add(Point{ x : 20, y : 30 }); println!("{:?}", point); } |
■ 배열의 iter 메소드를 사용해 소유권 이동 없이 반복자를 구하는 방법을 보여준다. ▶ 예제 코드 (RS)
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
fn main() { let array : [String; 4] = [ "Apple".to_string(), "Banana".to_string(), "Mango".to_string(), "Tomato".to_string() ]; for item in array.iter() { println!("{}", item); } println!("Length : {}", array.len()); } |
■ 제네릭 구조체를 만드는 방법을 보여준다. ▶ 예제 코드 (RS)
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
#[derive(Debug)] struct Point<T> { x : T, y : T } fn main() { let point1 : Point<i32> = Point { x : 20 , y : 50 }; let point2 : Point<f64> = Point { x : 20.5, y : 15.3 }; println!("{:?}", point1); println!("{:?}", point2); } |
■ where 키워드를 사용해 트레잇 바운드를 설정한 제네릭 함수를 만드는 방법을 보여준다. ▶ 예제 코드 (RS)
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
fn add<T>(a : T, b : T) -> T where T : std::ops::Add<Output = T> { return a + b; } fn main() { println!("{}", add(10, 25)); println!("{}", add(10.0, 25.0)); } /* 35 35 */ |
■ Add/Copy 트레잇을 사용해 제네릭 함수를 만드는 방법을 보여준다. ▶ 예제 코드 (RS)
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
fn get_twice_value <T: std::ops::Add<Output = T> + Copy>(value : T) -> T { return value + value; } fn main() { println!("{}", get_twice_value(3)); println!("{}", get_twice_value(3.0f64)); println!("{}", get_twice_value::<u64>(3)); // 타입을 명시하는 경우 } /* 6 6 6 */ |
■ trait 키워드에서 트레잇의 기본 메소드를 만드는 방법을 보여준다. ▶ 예제 코드 (RS)
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 |
trait TreasureBox { fn open(&self, key_number : i32) -> bool { self.get_key_number() == key_number } fn check(&self); fn get_key_number(&self) -> i32; } struct JewelryBox { price : i32, key_number : i32 } impl TreasureBox for JewelryBox { fn check(&self) { println!("보석 상자 : {} 골드", self.price); } fn get_key_number(&self) -> i32 { return self.key_number; } } struct EmptyBox { key_number : i32 } impl TreasureBox for EmptyBox { fn check(&self) { println!("빈 상자"); } fn get_key_number(&self) -> i32 { self.key_number } } fn open_box(treasure_box : &impl TreasureBox, key_number : i32) { if !treasure_box.open(key_number) { println!("적절한 열쇠가 아니라 상자가 열리지 않는다."); return; } treasure_box.check(); } fn main() { let jewelry_box1 : JewelryBox = JewelryBox { price : 30, key_number : 1 }; let empty_box1 : EmptyBox = EmptyBox { key_number : 1 }; let jewelry_box2 : JewelryBox = JewelryBox { price : 50, key_number : 2 }; open_box(&jewelry_box1, 1); open_box(&empty_box1 , 1); open_box(&jewelry_box2, 1); } /* 보석 상자 : 30 골드 빈 상자 적절한 열쇠가 아니라 상자가 열리지 않는다. */ |