FUNÇÕES

A maioria dos programas apresentados até agora usa somente a função main. À medida que seus programas vão se tornando maiores e mais complexos, você pode simplificar seu trabalho e melhorar a clareza do programa dividindo o programa em partes menores chamadas funções. Por exemplo, assuma que você esteja criando um programa de contabilidade. Você poderia ter uma função que efetuasse as operações normais de um contador, uma função diferente para as contas a pagar, uma terceira para as contas a receber e uma quarta para gerar um balanço. Se você colocasse todos os comandos do programa dentro de main, seu programa ficaria muito grande, e seria difícil de entender. À medida que o tamanho e a complexidade do programa aumentam, aumenta também a possibilidade de erros. Se você dividir o programa em blocos menores e mais facilmente gerenciáveis, poderá evitar os erros. Uma função é uma coleção nomeada de comandos que efetuam uma tarefa específica. Por exemplo, a função a seguir , usa printf para exibir uma mensagem:

          
#include <stdio.h>
void oi_pessoal (void)
{
     printf (“Oi pessoal!\n”);
}

A palavra chave void diz a C que a função não retorna um valor. Em muitos casos, suas funções usarão return para retornar o resultado de um cálculo para a função chamadora. Se a função não usa return para retornar um resultado, você deve preceder o nome da função como void. O void que aparece nos parênteses diz a C que a função não usa parâmetros. Um parâmetro é a informação que o programa passa para a função. Por exemplo, quando seus programas chamam printf,as informações que você especifica dentro dos parênteses são parâmetros. Quando uma função não usa parâmetros, você deve colocar a palavra void dentro dos parênteses. Para usar uma função, você simplesmente especifica o nome da função seguido por parênteses exatamente como usa printf. Os programadores referenciam o uso de uma função como uma chamada da função. O programa a seguir, usa a função oi_pessoal.

          
#include <stdio.h>
void oi_pessoal (void)
{
   printf (“Oi pessoal!\n”);
	 
}
					 
void main(void)
{
    oi_pessoal();
}

Ao executar esse programa, a função main é executada primeiro. Como você pode ver, o único comando em main é a chamada da função oi_pessoal. Quando C encontra a chamada da função, imediatamente transfere a execução do programa para a função, iniciando a execução do programa para a função, iniciando a execução do programa com o primeiro comando na função. Depois que o último comando na função termina, C transfere a execução para o comando que segue imediatamente a chamada da função. Para compreender melhor esse processo, mude a função main como mostrado aqui:

void main (void)
{
    printf(“Prestes a chamar a função\n”);
    oi_pessoal();
    printf(“Voltei da chamada da função\n”);
}

Quando você compilar e executar o programa, sua tela exibirá o seguinte:

Prestes a chamar a função
Oi pessoal!
Voltei da chamada da função

Usando Variáveis Dentro das Funções

Á medida que você cria funções úteis, verá que muitas funções requerem que as variáveis gerem resultados valiosos. Para usar uma variável dentro de uma função, você precisa primeiro declarar a variável, exatamente como faz em main. Por exemplo, o programa a seguir, chama a função tres_olas que usa a variável contador em um laço for para exibir uma mensagem três vezes:

#include <stdio.h>
void tres_olas (void)
{
    int contador;        
    for (contador = 1; contador <= 3; contador++)
        printf("Olá pessoal!\n");
}
		 
void main(void)
{
     tres_olas();
}
		 

Quando você declara variáveis dentro de uma função, os nomes usados para essas variáveis são exclusivos para a função. Portanto se seu programa usa 10 funções diferentes e cada função usa uma variável chamada contador, C considera a variável de cada função como distinta. Se sua função requer muitas variáveis, você deverá declarar as variáveis no início da função, exatamente como faria dentro de main

Compreendendo main como uma função

Quando você cria um programa , usa o nome da função main para determinar o primeiro comando que o programa executar. Na verdade, main é uma função, de modo que, caso tenha perguntas sobre os tipos de operações que você pode executar dentro de suas funções, a regra é bem simples: tudo que você pode fazer em main você pode fazer dentro de uma função. Exatamente como você pode declarar variáveis em main, também pode declarar variáveis nas suas funções. Também é possível usar construções tais como if, while e for em suas funções. Finalmente, uma função pode chamar (usar) outra. Por exemplo, o programa a seguir usa duas funções. Quando o programa inicia, main chama a função tres_olas, que, por sua vez, chama a função oi_pessoal três vezes para exibir mensagens na sua tela, como mostrado aqui:

#include <stdio.h>
void ola_pessoal (void)
{
    printf("Ola pessoal!\n");
}

void tres_olas(void)
{

    int contador;
    for (contador = 1; contador <=3;contador++)
         ola_pessoal();
}

void main (void)
{
    tres_olas();
}

Introdução aos parâmetros

Um parâmetro é um valor passado a uma função. Á medida que você for usando funções regularmente, poderá passar parâmetros para uma função para melhorar a utilidade da função. Por exemplo, considere a seguinte construção da função tres_olas, que chama a função oi_pessoal três vezes:

void tres_olas (void)
{
   int contador;

   for(contador = 1; contador <=3; contador++)
       oi_pessoal();
}

Uma função mais útil lhe permite especificar, com um parâmetro, o número de vezes que você quer que o programa exiba a mensagem. Para usar um parâmetro, sua função precisa especificar o nome e o tipo do parâmetro, como mostrado aqui:

void ola_conta (int msg_conta)

Neste caso, função ola_conta suporta um parâmetro do tipo int chamado msg_conta. Quando outra função, tal como main, quiser usar ola_conta, a função precisa especificar o nome e o tipo do parâmetro, como mostrado aqui:

ola_conta(2);           //Exibir a mensagem duas vezes
ola_conta(100);         //Exibir a mensagem cem vezes
ola_conta(1);           //Exibir a mensagem uma vez

O programa a seguir, ilustra como você poderia usar uma função com um parâmetro:

#include <stdio.h>
void oi_pessoal (void)
{
   printf("Ola pessoal!\n");
}

void ola_conta (int msg_conta)
{
   int contador;
   for (contador = 1; contador <=msg_conta;contador ++)
        oi_pessoal();
}

void main (void)
{
   printf("Exibe a msg duas vezes\n");
   ola_conta(2);
   printf("Exibe a msg cinco vezes\n");
   ola_conta(5);
}

Como você pode ver, ver em main a chamada da função para ola_conta inclui o valor que C atribuirá ao parâmetro msg_conta.

Nota: Ao passar um parâmetro para uma função, o tipo de valor que você passará para o parâmetro (tal como int, float, char etc...) precisa corresponder ao tipo do parâmetro. Dependendo do seu compilador, ele poderá detectar incompatibilidade nos tipos. Se seu compilador não detectar as incompatibilidades nos tipos dos parâmetros, poderão aparecer erros que serão muito difíceis de detectar e de corrigir.

Usando parâmetros múltiplos

Como você aprendeu, um parâmetro é um valor que você passa para a função. Em geral, você pode passar um número irrestrito de parâmetros para uma função. No entanto, as pesquisas mostram que, quando o número de parâmetro excede a sete, a função torna-se mais difícil para compreender e usar corretamente, ficando, portanto, mais susceptível a erros. Quando sua função usa mais de um parâmetro, você precisa especificar o tipo e o nome de cada parâmetro e separar os parâmetros por vírgulas, como mostrado aqui:

void uma_função(int idade, float sal, int num_cargo)
{
   // Comandos da função
}

Quando seu programa quiser chamar a função, você precisará especificar valores para cada parâmetro, como mostrado aqui:

uma_função(33,40000.00, 534);

C, por sua vez, atribuirá os parâmetros, como mostrado na figura abaixo:

Compreendendo as declarações de parâmetros em programas C mais antigos

Quando você cria uma função que usa parâmetros, normalmente especifica o tipo e o nome de cada parâmetro, separados por vírgulas, dentro do cabeçalho da função, como mostrado aqui:

void uma_função (int idade, float sal,int num_cargo)
{
   //  Comandos da Função
}

Se você trabalha com programas C mais antigos, verá que os programadores declaravam os parâmetros assim:

void uma_função (idade, sal, num_cargo)
int idade;
float sal;
int num_cargo;

{
   //Comandos da função
	 
}

Se você encontrar essas declarações de parâmetros, deverá compreender que, embora o formato da declaração seja ligeiramente diferente, o propósito permanece o mesmo - especifica o tipo e o nome do parâmetro. Caso você se sinta tentado a atualizar o formato da função, certifique-se de que seu compilador aceita totalmente o novo formato. Além disso, lembre-se que, quanto mais modificações você fizer no seu programa, maiores serão suas chances de introduzir um erro. Como regra geral, "Se está funcionando, não conserte!"

return (resultado);

int uma_função (int valor)
{
   // Comandos da função
}

int i_cubo (int valor)

{
   return(valor*valor*valor);
}

result = i_cubo(5);
printf(("O cubo de 5 é %d\n",i_cubo(5));

#include <stdio.h>

int i_cubo(int valor)

{
    return(valor*valor*valor);
}
void main(void)

{
    printf("O cubo de 3 é %d\n",i_cubo(3));
    printf("O cubo de 5 é %d\n",i_cubo(5));
    printf("O cubo de 7 é %d\n",i_cubo(7));
}

float f_cubo (float valor)
{
   return (valor*valor*valor);

}

int compara_valores (int primeiro, int segundo)
{
   if (primeiro == segundo)
       return(0);
   else if (primeiro > segundo)
       return(1);
   else if (primeiro < segundo)
       return(2);
}

int compara_vallores( int primeiro, int segundo)

}
   int result;
   if (primeiro == segundo)
       result = 0;
   else if(primeiro > segundo)
       result = 1;
   else if (primeiro < segundo)
	     result = 2;
			 
   return(result);
}

#include <stdio.h>

int I_cubo(int);
float f_cubo(float);

void  main(void)
{
   printf("O cubo de 3 é %d\n, I_cubo(3));
   printf("O cubo de 3.7 é %f\n, f_cubo(3.7));
}

int i_cubo(int valor)
{
   return(valor*valor*valor);
}

float f_cubo(float valor)
{
   return(valor*valor*valor);
}