Ir para o conteúdo

Funções

O que são e para que servem?

As funções foram elaboradas com a finalidade de poupar espaço, tempo e paciência aos programadores. Por exemplo :

***********************
 12345
***********************
***********************

O código que vocês iriam elaborar era o seguinte:

#include <stdio.h>

main()
{
   puts("**********************");
   puts("12345”);
   puts("***********************");
   puts("***********************");
}

Agora reparem, estão a elaborar a mesma linha de código puts("****************") 3 vezes. Agora imaginem que tem essa linha umas 100 vezes no programa e o vosso chefe vos diz que não gosta de ver ali os 20 asteriscos, e que 21 seria mais atractivo, e pronto, lá iam vocês alterar as 100 linhas.

Até que um dia alguém se lembrou de inventar estas funções que originando um simples código e uma maneira de chamar essa função em qualquer lugar iria poupar espaço e tempo ora vejam...

Isto é uma função:

void asteriscos(void) 
{
    puts("***********************");
}

Corpo do programa:

#include <stdio.h>

main();
{
    asteriscos();
    puts("12345"),
    asteriscos();
    asteriscos();
}

Nota: Se algum dia o vosso chefe vos disser que já não gostava dos 21 asteriscos, mas sim 23 ou qualquer número, bastava mudar na definição da função quantos asteriscos queriam e escusavam de mudar 100 linhas como no caso anterior...

Como elaborar uma função?

Tipo_de_retorno Nome_da_Funçao(parametros recebidos(variaveis locais))
{
  Corpo da funçao
}

Tipo de retorno: Ao elaborar uma função quando a chamamos a função se não tiver nenhum tipo de retorno como é o caso do exemplo acima atribuimos o tipo void (ou seja não retorna nada, a isto se dá o nome de procedimentos), caso contrário tem de retornar um valor inteiro, flutuante, etc.

Nome da Função: O nome da função tem de ser único e não pode ser nem uma palavra reservada do C, nem igual a nenhuma variável, e de preferência de fácil compreensão, ou seja, não muito extensa.

Parâmetros recebidos: Os parâmetros recebidos são a iniciação de variáveis locais, ou seja, a partir do momento que a função acaba essas variáveis morrem. Ao definir as variáveis que a função irá receber do corpo do programa tem que ser definir o seu tipo e não pode ser como a definição das variáveis (ex: int x,y,z: ERRADO), terá de ser int x, int y, float h, float z.

Nota: O código de uma função deve ser o mais independente possível do resto do programa e deve ser realizada para uma única tarefa.

Como funciona uma função?

O código de uma função só é executada quando é chamada pelo programa, ou seja, podem criar milhares de funções, mas se não as chamarem elas nunca são utilizadas, exemplo, pensem no elevador do vosso prédio, ele está lá construido, mas imaginem vocês que moram no primeiro andar e não vale a pena estar a chamar o elevador logo ele não trabalha enquanto não o chamarem, mas não deixa de existir.

Sempre que chamam a função o programa interrompe no local de call function depois é retomado quando a execução acabar. As variáveis criadas dentro de uma função são só visíveis dentro dessa própria função visto que quando uma função e executada, é criado um ambiente para a execução dessa mesma função, no final toda a memória e libertada.

Os Parâmetros

A comunicação do programa com a função realiza-se através de argumentos que lhe são enviados e dos parâmetros presentes na função que os recebem. O número de parâmetros numa função não tem limite máximo, ou seja, são estabelecidas consoante as necessidades do programador.

Como já referi antes os parâmetros têm que ser divididos por vírgulas e o tipo tem que ser sempre referenciado int funcao(int x, float y, double i). Um parâmetro não é mais do que uma variável local à função a que pertence. Um parâmetro é automaticamente inicializado com o valor enviado pelo programa invocador.

Os argumentos enviados pelo programa são guardados nas variáveis locais (parâmetros) da função por ordem, ou seja:

função (char ch, int n, float x)

main()
{
 função ('A', 69, 30.4);
}

Neste caso verificamos o porquê da ordem: na variável ch vai ficar o valor A, na variável n vai ficar o valor 69, e por fim na variável x vai ficar o valor 30.4.

Nota: O número de parâmetros enviados para uma função deve ser igual ao número de parâmetros existente no cabeçalho da função. O tipo dos parâmetros deve igualmente corresponder, parâmetro a parâmetro.

Nota II: Qualquer instrução é admissível dentro de uma função (ex: atribuições, if, for, switch, invocar outras funções, etc.).

Return

A instrução return permite acabar a função, retornando algo ou não.

void funcao(void)
{
   puts("sera?");
   return;
   puts("apareco eu?");
}

Neste caso será elaborado um output a dizer sera? e o return faz com que a função acabe e a próxima instrução não será realizada, ou seja, o texto apareco eu nunca será exibido.

Outro Exemplo:

int soma(int x,int y)
{
  return x+y;
}

Supondo que dentro do programa havia algo que enviasse 2 valores para esta função e vamos supor que esses 2 valores eram 3 e 5, o x iria ser igual a 3 e o y a 5. O return iria devolver o valor 3+5, ou seja, iria devolver 8.

Passagem de Paramentos por Valor

Em C só existe passagem de parâmetros por valor, isto é não podemos enviamos a própria variável como parâmetro como acontece em muitas outras linguguagem, mandamos sim uma cópia dessa, assim podemos fazer todo o tipo de alterações dessa variável na execução da função, sem que a variável original seja alterada.

#include<stdio.h>

void tal(int i)
{
   i=i+100;
   printf("i é igual a: %d",i);
}

int main(void)
{
    int i=10;
    tal(i);
    printf("i sempre foi %d",i);
    return 0;
} 

Passagem de Paramentos por Referencia

Ao contrário do que acontece quando passamos um parâmetro por valor, ao passarmos por referência estamos a passar a variável verdadeira que a função pode alterar à vontade, mas em C só existe passagem de parâmentos por Vvlor. No entanto, temos uma solução viável utilizando ponteiros.

#include<stdio.h>

int tal(int *p)
{
    *p=100;
}

int main(void)
{
    int i=10;

    printf("I tem o valor de %d\n",i);
    tal(&i);
    printf("I agora tem o valor de %d\n",i);
    return 0;
}

Parâmetros a partir da linha de Comandos

Podemos obter parâmentos que necesitamos através da linha de comandos utilizando o argc e o argv.

 int main(int argc, char *argv[])

Onde:

  • int argc: Indica quantos argumentos foram passados (nome do programa incluído)
  • char *argv[]: Array de strings onde são guardados os parâmetros passados
#include<stdio.h>

int main(int argc,char *argv[])
{
    int i;
    printf("Foram passados %d paramentos!",argc-1); /* Tiramos 1 pois o nome do programa tambem conta */

    for(i=0;i<argc;i++)
        printf("%s\n",argv[i]);
    return 0;
}