Ferramentas de Usuário

Ferramentas de Site


dev_geral:c:funcoes

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 numero 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 chama-mos 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) → CORRECTO

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 memoria 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 numero 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 tem que ser divididos por virgulas 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 porque 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 apareço 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 propria varivel como parâmetro como acontece em muitas outras linguguagem, mandamos sim uma copia dessa, assim podemos fazer todo o tipo de alteraçoes dessa varivel na execuçao da funçao sem que a variavel 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 contrario do que acontece quando passamos um paramento por valor, ao passarmos por referencia estamos a passar a variável verdadeira que a função pode alterar a vontade, mas em C só existe passagem de paramentos por Valor.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 %dn",i);
    tal(&i);
    printf("I agora tem o valor de %dn",i);
    return 0;
}

Parâmetros a partir da linha de Comandos

Podemos obter paramentos que necesitamos atraves 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 : String onde é guardado as strings passadas

#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("%sn",argv[i]);
     return 0;
}
Autoria

Este artigo foi originalmente escrito por Gurzi a 21 de Dezembro de 2005

dev_geral/c/funcoes.txt · Última modificação em: 2018/05/14 21:37 (edição externa)