[C] Funções

[Gurzi]

Pessoal decidi criar este tutorial sem grandes conhecimentos aprofundados em C mas depois de estudar funções achei que poderia ser útil a alguém , é o meu 2º tutorial que faço e pode não estar totalmente bom nem de grande utilidade mas foi feito com a tentativa de ser útil a alguém.

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 depois de uma noite em que a mulher não lhe deu o que ele queria diz, olha meu amigo não gosto de ver ali os 20 asteriscos, acho que 21 seria mais atractivo, e prontos 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 é a função

void asteriscos(void)
{
puts(“***********************”);
}

Isto é o corpo do programa

#include <stdio.h>

main();
 asteriscos();
 puts(“12345”);
 asteriscos();
 asteriscos();
}

Nota: Se algum dia o vosso chefe depois de mais uma noite mal passada 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 chamamos a função se não tiver nenhum tipo de retorno como é o caso do exemplo acima atribuímos 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á construído 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 e quando a função termina volta ao mesmo ponto ou seja a instrução imediata à chamada da função.

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 em uma 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 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 (parametros) 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.

Exemplo :

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

Neste caso será elaborado um output a dizer será ? 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.

---------------------------------------------------------------------------------------------------------------------------------------------------------------

espero que tenha sido útil : Tiago Palhota 'Gurzi'

[Artigo no Wiki]

[vbmaster]

Mas que grande tut Gurzi.... 😛

Estou a gostar da maneira divertida com que estás a expor as coisas....temos aqui um tuter... 🙂

[deathseeker25]

Grande iniciativa do gurzi...pode ser um futuro contributo para a revista...😛

Cumps

[Knitter]

Antes de mais tenho de dizer que para início está muito bom. Não quero tirar o crédito ao que foi colocado, venho apenas sugerir umas pequenas correcções...

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

e possibilitar a que o programa se torne modular o que torna a detecção de erros, resolução de problemas e actualização do software uma tarefa bem mais fácil.

---------------------------Isto é a função-----------------

Void asteriscos(void)

{

    Puts(“***********************”);

}

Atenção à maiúsculas, o C é “case sensitive”.

----------------------Isto é o corpo do programa ---------------------------

#include <stdio.h>

main();

asteriscos();

puts(“12345”),

asteriscos();

asteriscos();

}

Como a função foi colocada no fim da função “main” é necessário colocar o protótipo da função antes da função “main”, caso contrário ao chamar-mos a função “asteriscos” dentro da função “main” iríamos obter um erro de compilação.

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 atribuímos 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.

Neste caso a função não devolve, através da chamada à instrução “return”, um valor, no entanto é necessário reparar que “void” é um tipo de dados, e é esse o tipo de dados que a função devolve.

Em C o conceito de procedimentos não se aplica. Como disse antes “void” é um tipo de dados, logo todas as funções devolvem qualquer coisa, nem que seja “void”. Esta noção é importante quando se fala em ponteiros, especialmente em ponteiros para funções. Em relação aos procedimentos, ninguém se vai chatear se chamarem procedimentos. Mas pela correcção da linguagem C tem funções, Java tem métodos, Pascal tem procedimentos e funções, etc…

Parametros recebidos – Os parametros recebidos são a iniciação de variáveis locais ou seja a partir do momento que a função acaba essas variaveis morrem.

Neste caso não quero sugerir correcção, quero louvar pelo uso da palavra iniciação, que está correcta, em detrimento da muito badalada “inicialização”, que não existem em português.

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

Hum… não consegui perceber bem o que queres dizer com “uma única tarefa”.

Um parametro não é mais do que uma variável local à função a que pertence. Um parametro é automaticamente inicializado com o valor enviado pelo programa invocador.

Os argumentos enviados pelo programa são guardados nas variaveis locais(parametros) da função por ordem ou seja

Menos um ponto pelo uso de “inicializado” 😁. Creio ser necessário fazer aqui uma pequena destinção.

Parâmetros é são os valores que são passados à função e que são definidos no seu protótipo, variáveis locais, são as variáveis que definimos no corpo da função. Embora os parâmetros passados à função sejam copiados para o espaço de memória da função e por isso sejam locais, quando nos referimos a variáveis locais referimo-nos a variáveis que tenham sido definidas dentro do corpo da função e que não façam parte do protótipo.

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.

É possível passar a uma função um número indeterminados de parâmetros, isto é, é possível definir no protótipo de uma função que o número de parâmetros de entrada varia conforme a chamada. É desta forma que está definida a função “printf”, no protótipo está definido que a função recebe uma string e depois dessa string um número variável de parâmetros.

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

A instrução “return” permite mais que terminar uma função, e nem sempre quando aplicada dentro da função provoca o término da mesma.

A instrução permite também terminar ciclos.

Creio que o trabalho está bom para quem está a começar e desculpa pelas correcções, e já agora fico à espera de tópicos mais avançados, funções genéricas, funções que recebam outras funções como parâmetro de entrada e  ponteiros para funções. 👍

Até lá…

[VrX]

Foi bem Gurzi, arranjei um livro de ensino linguagem C e acontece que sou muito novato no assunto.

Foste-me uma grande ajuda para o meu progresso nesta área, agradeço o esforço. Espero que continues com os teus tut  🙂

Bom trabalho

[fukumiwarai]

Hey !

Podias ter referido a ideia de recursividade e a sua importância na programação funcional.

Mas há que louvar estas iniciativas 🙂 .

[Triton]

Foi bem Gurzi, arranjei um livro de ensino linguagem C e acontece que sou muito novato no assunto.

Foste-me uma grande ajuda para o meu progresso nesta área, agradeço o esforço. Espero que continues com os teus tut  🙂

Bom trabalho

Espero que te safes, senão já sabes o que te acontece... 😁

Gurzi, aproveita e reformata o artigo (e se tiveres tempo passa para o wiki).

[MacgyverPT]

Boas pessoal,

Este artigo já se encontra na wiki.. ora vejam: [C]-Funções