Funções em C

Por: Eduardo Casavella

Definição de Função

Uma função nada mais é do que uma subrotina usada em um programa.

Na linguagem C, Denominamos função a um conjunto de comandos que realiza uma tarefa específica em um módulo dependente de código.

A função é referenciada pelo programa principal através do nome atribuído a ela.

A utilização de funções visa modularizar um programa, o que é muito comum em programação estruturada.

Desta forma podemos dividir um programa em várias partes, onde cada função realiza uma tarefa bem definida.

Esqueleto de uma função
tipo_de_retorno nome_da_função (listagem de parâmetros)

{
   instruções;
   retorno_da_função;
}

Parâmetros de uma função

Os parâmetros são as variáveis declaradas diretamente no cabeçalho da função.

A finalidade dos parâmetros é fazer a comunicação entre as funções e a função principal.

Chamamos de passagem de parâmetros a passagem de valores entre as funções.

Exemplo de programa usando função em C


#include<stdio.h>
#include<conio.h>
/*

   Nome da função: multiplica
   recebe como parâmetos dois valores inteiros (N1,N2)
   objetivo:  multiplicar os valores recebidos nos parâmetros.
   retorno:  um parâmetro inteiro (res) contendo o resultado
*/
int multiplica(int N1, int N2) //multiplica recebe N1,N2 e retorna um int
{
  int resultado;
  resultado = N1 * N2;
  return(resultado); //retornando o valor para main
}

/******************* função principal (main) *********************/

int main(void)
{
  int V1, V2, resultado;
  printf("Digite o primeiro valor:");
  scanf("%d", &V1);
  printf("Digite o segundo valor:");
  scanf("%d", &V2);

  //chama a função e recebe o retorno
  resultado = multiplica(V1,V2);
  printf("Resultado = %d\n", resultado);
  getch();
  return 0;
}

TELA DE EXECUÇÃO

Exemplo de programa usando funçao em c

Tela de execução do programa usando função em C

Explicação do código do programa:

Observe que o corpo da função multiplica foi declarado e a implementação do código foi feita antes da função main.

Na função main os valores de V1 e V2 foram recebidos.

Foi feita a chamada da função multiplica e a passagem de parâmetros.

O valor retornado pela função foi armazenado em resultado.

O valor armazenado em resultado foi apresentado.
Protótipo de função em C

O protótipo de uma função é basicamente, uma declaração da interface da função, ou seja, deve especificar:

  • Tipo da função;
  • Nome da função;
  • Lista de parâmetros que a função necessita;

Exemplo:
int multiplica(int N1, int N2)
Programa em C reescrito usando protótipo


#include<stdio.h>
#include<conio.h>
/*   Protótipo da função  */
int multiplica(int N1, int N2);

int main(void)
{
  int V1, V2, resultado;
  printf("Digite o primeiro valor:");
  scanf("%d", &V1);
  printf("Digite o segundo valor:");
  scanf("%d", &V2);

  //chama a função e recebe o retorno
  resultado = multiplica(V1,V2);
  printf("Resultado = %d\n", resultado);
  getch();
  return 0;
}

int multiplica(int N1, int N2) //multiplica recebe N1,N2 e retorna um int
{
  int resultado;
  resultado = N1 * N2;
  return(resultado); //retornando o valor para main
}

TELA DE EXECUÇÃO

exemplo programa em c reescrito usando protótipo

Tela de execução do programa em C reescrito usando protótipo

Função sem retorno

Em C, é possível criar funções que não retornam nenhum valor.

Normalmente, isto é feito quando queremos executar um bloco de comandos, mas estes comandos não precisam retornar nada.

Neste caso, devemos usar void no tipo de retorno do cabeçalho da função.

Se a função não recebe nenhum parâmetro, também colocamos void no local da listagem dos parâmetros.
exemplo:

void imprime_cabec(void)
{
  printf("******************************\n");   
  printf("*       LINGUAGEM C          *\n");
  printf("******************************\n");   

  return; /* retorno de uma função void  */
}

Para funções do tipo void, (ou seja sem retorno) devemos usar o comando return;

Note bem que este return não contém nenhum parâmetro.

Já que não é preciso retornar nenhum parâmetro e se eu não escrever o comando return?

Se a instrução return for omitida, alguns compiladores vão gerar mensagens de advertência (warning), pois o padrão ANSI C recomenda a utilização da instrução.
Exemplo de programa usando funções com e sem retorno.


#include<stdio.h>
#include<conio.h>

/******* Área dos protótipos ******/
void imprime_cabec(void);
int multiplica(int N1, int N2);
/******* fim dos protótipos *******/

/* ******* FUNÇÃO PRINCIPAL *******/
int main(void)
{
  int V1=0, V2=0, resultado=0;
  //Chamada da função imprime_cabec
  imprime_cabec();

  printf("Digite o primeiro valor:");
  scanf("%d", &V1);
  printf("Digite o segundo valor:");
  scanf("%d", &V2);

  //chama a função e recebe o retorno
  resultado = multiplica(V1,V2);
  printf("Resultado = %d\n", resultado);

  getch();
  return 0;
}
/* ******** FIM DA FUNÇÃO PRINCIPAL *******/

/* --------- Corpo das funções --------- */
/*
***** Função imprime_cabec *****
Parâmetros de entrada: não tem (void)
Objetivo: imprimir cabeçalho na tela
Tipo de retorno: não tem (void)
*/
void imprime_cabec(void)
{
  printf("******************************\n");
  printf("*       LINGUAGEM C          *\n");
  printf("******************************\n\n");

  return;/* retorno de uma função void  */
}

/*
***** Função multiplica *****
Parâmetros de entrada: N1, N2 ambos int
Objetivo: multiplicar valores
Tipo de retorno: int (resultado);
*/
//multiplica recebe N1,N2 e retorna um int
int multiplica(int N1, int N2)
{
  int resultado;
  resultado = N1 * N2;

  //retornando o valor para main
  return(resultado);
}

TELA DE EXECUÇÃO

exemplo usando funções com e sem retorno

Tela de execução do programa usando funções com e sem retorno

Neste programa utilizamos duas funções, uma delas com retorno de valor multiplica() e outra delas sem retorno imprime_cabec().

Primeiramente, declaramos todos os protótipos das funções antes da main.

Na função main() são feitas as chamadas para as outras funções.

Após a finalização do código da main(), são implementados os corpos das outras funções.

Quando a função main() chama (invoca) outra função, o programa “salta” para o trecho de código da função que foi chamada, executa esta função e depois retorna novamente para a função principal main().

Até a próxima!