function

• 재사용 가능한 코드블록

1. fn main()

• 보통 main에서 프로그램 실행

2. define function

• fn keyword로 정의

3. syntax

4. call a function

• 함수는 호출 될 때 사용됨
• 필요한 경우 parameter를 괄호 사이에 추가 할 수 있음

5. example

fn display_massage() {
	println!("Hello, Rust!");
}

fn main() {
	display_massage();
    println!("Function ended");
}

function with parameters

1. parameter 란?

• parameters : 함수정의()에 들어가는 변수 or 값
  

2. argument 란?

• arguments : 함수 호출 자리에 들어가는 변수 or 값
  

example

//function definition
fn my_func(param_1:i32, param_2:i32) {
  println!("The first value passed inside function : {}", param_1);
  println!("The second value passed inside function : {}", param_2);
}
fn main() {
  let value_1 = 1;
  let value_2 = 2;
  //calling the function
  my_func( value_1, value_2 );
  println!("Function ended");
}

type of arguments

1. pass by value(값으로 전달)

• 호출 함수의 값은 함수가 호출될 때 호출된 함수의 매개변수에 복사

• 호출된 함수는 원하는 모든 매개변수 변수의 값을 변경할 수 있음

• 이 변경 사항은 호출 함수에서 인수로 전달되는 변수에 반영되지 않음

• 요약 : 본문의 변수를 변경시키지 않음

syntax

example

fn square(mut n:i32){
  n = n * n;
  println!("The value of n inside function : {}", n);
}

fn main() {
  let n = 4;
  println!("The value of n before function call : {}", n);
  println!("Invoke Function");
  square(n);
  println!("\nThe value of n after function call : {}", n);
}

note

• n 값은 바뀌지 않음

2. pass by reference(참조로 전달)

• 호출된 함수가 매개변수를 변경 시키고, 호출이 반환되었을 때 호출한 함수에서 변경 사항이 반영되길 원할 때
• 이러한 매커니즘을 참조에 의한 인수 전달이라고 함

-요약 : 본문의 변수를 변화시킴

syntax

example

fn square(n:&mut i32){
  *n = *n * *n;
  println!("The value of n inside function : {}", n);
}  
fn main() {
  let  mut n = 4;
  println!("The value of n before function call : {}", n);
  println!("Invoke Function");
  square(&mut n);
  println!("The value of n after function call : {}", n);
}
----------------------------------------------------------
*console
The value of n before function call : 4
Invoke Function
The value of n inside function : 16
The value of n after function call : 16

note

• n값은 함수내에서 변경 됨
• 값이 참조로 전달될 때 인수와 매개변수는 변경 가능한 참조로 설정됨 + 값을 업데이트해야 하는 경우 먼저 역참조된 다음 업데이트 작업이 수행 됨

returning a value from a function

• return keyword를 사용함으로서 함수는 value를 반환시킬 수 있음.
• return statement가 실행된 후, control이 호출자에게 돌아감.
• 함수호출은 호출이 반환하는 값으로 대체 됨 + value는 변수에 저장될 수 있음
  

1.syntax

• returnkeyword를 사용해서 함수에서 값을 반환하는 일반적인 구문 :
  

1.1 example

fn square(n:i32)->i32{
  println!("The value of n inside function : {}", n);
  let m = n * n;
  m // return the square of the number n
}  
fn main() {
  let  n = 4;
  println!("The value of n before function call : {}", n);
  println!("Invoke Function");
  println!("\nOutput : {}",square(n));
}

2.syntax

• returnkeyword를 사용하지 않고 값을 반환하는 구문 :
  

note

• Just write the return value, the compiler will interpret it because of the -> sign in the function definition.
  반환 값을 작성하면 함수 정의의 부호 때문에 컴파일러가 이를 해석

2.1 example

fn square(n:i32)->i32{
  println!("The value of n inside function : {}", n);
  return n * n;
}  
fn main() {
  let  n = 4;
  println!("The value of n before function call : {}", n);
  println!("Invoke Function");
  println!("\nOutput : {}", square(n));
}

returning multiple values

• C,C++등의 시스템 프로그래밍 언어의 함수에서는 단일 value 또는 배열에 대한 pointer만 반환할 수 있음 .
• 하지만 러스트에서는 tuple을 사용해 여러개의 value를 반환 할 수있음.

syntax

example

// driver function
fn main() {
    let length = 4;
    let width = 3;
    println!("Rectangle lenth:{}", length);
    println!("Rectangle width:{}", width);
    let (area, perimeter) = calculate_area_perimeter(length, width);
    println!("Area: {}, Perimeter: {}", area, perimeter);
}
// calculate area and perimeter
fn calculate_area_perimeter(x: i32, y: i32) -> (i32, i32) {
    // calculate the area and perimeter of rectangle
    let area = x * y;
    let perimeter = 2 * (x + y);
    // return the area and perimeter of rectangle
    (area, perimeter)
}

function with arrays as arguments

• 배열을 인수로 사용하는 함수

1. pass by value

• 배열은 함수의 값으로 전달될 수 있음
• 호출하는 함수로부터 배열의 복사본이 호출된 함수로 전달된다는 것을 의미 함

syntax

fn function_name( mut array_name : [datatype;size])

example 1

fn main() {
   let arr = [1, 2, 3, 4, 5];
   modify_my_array(arr);
   println!("Array in Driver Function : {:?}", arr);
}
fn modify_my_array(mut arr:[i32;5]){
   arr[2] = 8;
   arr[3] = 9;
   println!("Array in my Function : {:?}", arr);
}

note

• 배열을 값으로 전달할 때 mutkeyword는 optional임
• 로컬 변경을 하려는 경우 배열 이름과 함께 작성됨, 그렇지 않은 경우 생략할 수 있음

example 2

fn main() {
   let arr = [1, 2, 3, 4, 5];
   println!("Array in Driver Function : {:?}", arr);
   calculate_mean(arr);
}

fn calculate_mean(arr:[i32;5]){
   let mut sum = 0;
   for i in 0..5 {
       sum += arr[i];
   }
   println!("Mean of array values: {}", sum/5);
}

2. pass by reference

return an array

• 배열은 함수의 매개변수로 참조를 통해 전달될 수 있음
• 참조로 전달될 때 원래 배열에서 변경이 이루어지며, 복사본은 생성되지 않음

syntax

fn function_name(array_name : &mut [datatype;size])

example

fn main() {
   let mut arr = [1, 2, 3, 4, 5];
   modify_my_array(&mut arr);
   println!("Array in Driver Function : {:?}", arr);
}
fn modify_my_array(arr:&mut [i32;5]){
   arr[2] = 8;
   arr[3] = 9;
   println!("Array in my Function : {:?}", arr);
}

3. return an array

• 함수에서 배열을 반환할 수 있음

syntax

fn function_name() -> [datatype;size]

note

• 여기서 parameter를 전달할 수도 있음

example

fn main() {
   let arr = [1, 2, 3, 4, 5];
   modify_my_array(arr);
   println!("Array in Driver Function : {:?}", arr);
   println!("Array after Function Call : {:?}", modify_my_array(arr));
}

fn modify_my_array(mut arr:[i32;5])->[i32;5]{
   arr[2] = 8;
   arr[3] = 9;
   arr
}