Ferrugem - Funções

As funções são os blocos de construção de código legível, sustentável e reutilizável. Uma função é um conjunto de instruções para realizar uma tarefa específica. As funções organizam o programa em blocos lógicos de código. Uma vez definidas, as funções podem ser chamadas para acessar o código. Isso torna o código reutilizável. Além disso, as funções facilitam a leitura e a manutenção do código do programa.

Uma declaração de função informa ao compilador sobre o nome de uma função, tipo de retorno e parâmetros. Uma definição de função fornece o corpo real da função.

Sr. Não	Descrição da função
1	Defining a function A definição da função TA especifica o que e como uma tarefa específica seria realizada.
2	Calling or invoking a Function Uma função deve ser chamada para executá-la.
3	Returning Functions As funções também podem retornar valor junto com o controle, de volta para o chamador.
4	Parameterized Function Os parâmetros são um mecanismo para passar valores para funções.

Definindo uma função

Uma definição de função especifica o que e como uma tarefa específica seria realizada. Antes de usar uma função, ela deve ser definida. O corpo da função contém código que deve ser executado pela função. As regras para nomear uma função são semelhantes às de uma variável. As funções são definidas usando ofnpalavra-chave. A sintaxe para definir uma função padrão é fornecida abaixo

Sintaxe

fn function_name(param1,param2..paramN) {
   // function body
}

Uma declaração de função pode conter opcionalmente parâmetros / argumentos. Os parâmetros são usados ​​para passar valores para funções.

Exemplo - definição de função simples

//Defining a function
fn fn_hello(){
   println!("hello from function fn_hello ");
}

Invocando uma função

Uma função deve ser chamada para executá-la. Este processo é denominado comofunction invocation. Os valores dos parâmetros devem ser passados ​​quando uma função é chamada. A função que invoca outra função é chamada decaller function.

Sintaxe

function_name(val1,val2,valN)

Exemplo: invocando uma função

fn main(){
   //calling a function
   fn_hello();
}

Aqui, o main () é a função do chamador.

Ilustração

O exemplo a seguir define uma função fn_hello(). A função imprime uma mensagem no console. omain()função invoca a função fn_hello () .

fn main(){
   //calling a function
   fn_hello();
}
//Defining a function
fn fn_hello(){
   println!("hello from function fn_hello ");
}

Resultado

hello from function fn_hello

Retornando valor de uma função

As funções também podem retornar um valor junto com o controle, de volta para o chamador. Essas funções são chamadas de funções de retorno.

Sintaxe

Qualquer uma das sintaxes a seguir pode ser usada para definir uma função com tipo de retorno.

Com declaração de retorno

// Syntax1
fn function_name() -> return_type {
   //statements
   return value;
}

Sintaxe abreviada sem instrução de retorno

//Syntax2
fn function_name() -> return_type {
   value //no semicolon means this value is returned
}

ilustração

fn main(){
   println!("pi value is {}",get_pi());
}
fn get_pi()->f64 {
   22.0/7.0
}

Resultado

pi value is 3.142857142857143

Função com Parâmetros

Os parâmetros são um mecanismo para passar valores para funções. Os parâmetros fazem parte da assinatura da função. Os valores dos parâmetros são passados ​​para a função durante sua invocação. A menos que especificado explicitamente, o número de valores transmitidos a uma função deve corresponder ao número de parâmetros definidos.

Os parâmetros podem ser passados ​​para uma função usando uma das seguintes técnicas -

Passe por valor

Quando um método é chamado, um novo local de armazenamento é criado para cada parâmetro de valor. Os valores dos parâmetros reais são copiados para eles. Portanto, as alterações feitas no parâmetro dentro do método invocado não têm efeito sobre o argumento.

O exemplo a seguir declara uma variável não, que é inicialmente 5. A variável é passada como parâmetro (por valor) para o mutate_no_to_zero()functionnction, que altera o valor para zero. Após a chamada da função, quando o controle retorna ao método principal, o valor será o mesmo.

fn main(){
   let no:i32 = 5;
   mutate_no_to_zero(no);
   println!("The value of no is:{}",no);
}

fn mutate_no_to_zero(mut param_no: i32) {
   param_no = param_no*0;
   println!("param_no value is :{}",param_no);
}

Resultado

param_no value is :0
The value of no is:5

Passe por referência

Quando você passa parâmetros por referência, ao contrário dos parâmetros de valor, um novo local de armazenamento não é criado para esses parâmetros. Os parâmetros de referência representam o mesmo local da memória que os parâmetros reais fornecidos ao método. Os valores dos parâmetros podem ser passados ​​por referência, prefixando o nome da variável com um& .

No exemplo a seguir, temos uma variável no , que é inicialmente 5. Uma referência à variável no é passada para omutate_no_to_zero()função. A função opera na variável original. Após a chamada da função, quando o controle retornar ao método principal, o valor da variável original será zero.

fn main() {
   let mut no:i32 = 5;
   mutate_no_to_zero(&mut no);
   println!("The value of no is:{}",no);
}
fn mutate_no_to_zero(param_no:&mut i32){
   *param_no = 0; //de reference
}

O operador * é usado para acessar o valor armazenado na localização da memória que a variável param_noaponta para. Isso também é conhecido como desreferenciamento.

A saída será -

The value of no is 0.

Passando string para uma função

A função main () passa um objeto string para a função display () .

fn main(){
   let name:String = String::from("TutorialsPoint");
   display(name); 
   //cannot access name after display
}
fn display(param_name:String){
   println!("param_name value is :{}",param_name);
}

Resultado

param_name value is :TutorialsPoint