Funções em C

[Dark_Side]

Introdução
===============================

Hi,

Todo programa em C é iniciado por uma função principal chamada "main()".
É nesta função que temos as instruções iniciais do nosso programa.
Quando temos um código muito extenso por exemplo, escrevê-lo totalmente
na função principal pode gerar confusão. Para essa e outras situações,
podemos dividir o programa em funções, facilitando o entendimento e a organização
do código.

Neste breve tutorial, abordarei o uso de funções na linguagem C.


A função Main()
===============================

Como já se sabe, a função MAIN() é o ponto de entrada em um programa.
Quando esta é finalizada, o programa encerra.
Vejamos abaixo um exemplo:


#include
int main()
{
printf("Lolz!");
return 0;
}

Temos acima um simples exemplo de um programa que mostra uma string na tela
e encerra.

Note o tipo de dado o qual a função main() pertence: int (inteiro).
Vamos rever quais são os tipos básicos de dados em C?

INT => inteiro;
CHAR => caractere;
FLOAT => ponto flutuante com precisão simples;
DOUBLE => ponto flutuante com precisão dupla;
VOID => tipo vazio.

Agora vejamos a última instrução da função:

return 0;

O que isto quer dizer?

Simplesmente, estamos encerrando a função. Quando utilizamos a instrução
"return", estamos dizendo ao compilador que a função termina ali.
Observe que a função retorna o valor "0". Este valor é o código de retorno
da função, como o tipo utilizado na função foi INT, o valor retornado
deve ser necessarimente um inteiro.

Outro exemplo:

#include
void main()
{
printf("Lolz!");
}


Por que não utilizamos a instrução return? Simplesmente porque o tipo de dado
VOID é vazio, isto é, não possui um valor determinado. Nessas condições, não
é necessário retornar um valor.


Funções
===============================

Mas afinal, o que é uma função?
Pode-se dizer que uma função é um bloco de código dentro de um
programa que é identificado por um nome e às vezes por parâmetros, e que
pode ser utilizado diversas vezes.

Para ilustrar isso, vejamos:


#include
void minha_funcao()
{
printf("Lolz!");
}

#include
int main()
{
minha_funcao();
return 0;
}

Vimos que no exemplo inicial, o programa mostrava uma string na tela.
O que este faz? a mesma coisa .

Observamos, porém, que temos uma função chamada "minha_funcao()" e que o seu tipo é VOID, isto é, vazio.

Ao executar o programa, a função main() chamaria pela função minha_funcao(),
que por vez, mostaria a string na tela. Para chamar uma função em C,
basta apenas introduzir seu nome e parâmetros, caso possua.

Observe agora um exemplo um pouco mais complexo:

#include
void minha_funcao(int numero)
{
printf("Numero: %d",numero);
}

int main()
{
minha_funcao(100);
return 0;
}


Resultado:

"Numero: 100"

Temos inicialmente a mesma estrutura, porém existe agora, um argumento
para a função: "numero". Este argumento é um inteiro.
Quando chamamos pela função com o valor 100 entre parênteses "()", estamos
passando valores. A função "minha_funcao()" recebe esse valor e o armazena
na variável "numero".

Outro exemplo:

#include
void minha_funcao(int numero,char caractere)
{
printf("Numero: %d\nCaractere",numero,caractere);
}

int main()
{
int x,y;
printf("Digite um numero: ");
scanf("%d",&x);
printf("Digite um caractere: ");
scanf("%c",&y);

minha_funcao(x,y);
return 0;
}

Temos um exemplo de função com dois argumentos: um inteiro e um caractere.

É importante visar que devemos sempre passar o número de argumentos que a função exige. Por exemplo:

 
/* Incorreto *\

#include
void minha_funcao(int numero,char caractere)
{
printf("Numero: %d\nCaractere",numero,caractere);
}

int main()
{
minha_funcao(100);
return 0;
}

O segundo parâmetro está faltando e o compilador acusaria um erro.

Um detalhe importante é que devemos ficar atentos quanto ao tipo de dado do argumento, se temos um argumento do tipo INT, devemos passar um valor inteiro,
se o argumento for um FLOAT, um valor FLOAT deve ser passado e assim por diante.

Outra observação é que no exemplo, o valor das variáveis "x" e "y" são copiados para as variáveis "numero" e "caractere" da função, respectivamente. As variáveis iniciais (x e y) permanecem inalteradas.

Quando temos uma função com mais de um argumento, devemos separá-los por vírgulas e especificar o seu tipo.

Vamos analisar o seguinte exemplo:

/* Incorreto !*/

#include

int main()
{
funcao();
return 0;
}

void funcao()
{
printf("OK!");
}

O que ocorreria? Lolz... um erro. Por quê?
Quando nós chamamos por uma função que esteja localizada abaixo da função
que a chamou, é necessário definí-la previamente, veja:


/* Correto !*/

#include

void funcao(); /* Definimos a função *\

int main()
{
funcao();
return 0;
}

void funcao()
{
printf("OK!");
}



Retornando valores
===============================

Pode-se estabelecer uma relação entre o título acima e a instrução return.
É exatamente isso que iremos ver a seguir.

Quando declaramos o tipo de dado de uma função, devemos retornar um valor
correspondente (com exeção do tipo VOID) certo? Mas o que podemos fazer
com este valor? Muito bem, vejamos:

#include

int soma(int num1,int num2)
{
return num1+num2;
}

int main()
{
int soma;
soma = funcao(100,50);
printf("%d",soma);
return 0;
}

Temos agora um exemplo de uma função que deve retornar um inteiro: "soma".
A função possui dois argumentos do tipo INT e retorna a soma dos seus valores,
que é dada por num1+num2.

Na função main(), declaramos uma variável do tipo INT - mesmo tipo da função
soma(). Quando fazemos soma = funcao(100,50), estamos atribuindo à variável "soma" o valor de retorno da função em questão, que no caso seria 150.

Outro exemplo:

#include

int verifica(int num)
{
return num % 2;
}

int main()
{
int n;
printf("Digite um numero:");
scanf("%d",&n);

if(verifica(n) == 0)
printf("O numero %d e par");
else
printf("O numero %d e impar");

return 0;
}


No exemplo acima, o programa pede a entrada de um número e passa o seu valor
como argumento para a função verifica(). Esta, por sua vez, retorna o resto da
divisão do numero por 2 - o operador % é utilizado para retornar o resto de uma divisão. Na função main(), é verificado se o valor retornado é 0 ou não.
Se for 0 o número é dado como par, se não é ímpar.


Finalizando
===============================

Como sempre eu com minhas considerações finais lolz.
O uso de funções não é algo exclusivo da linguagem C, a maioria das linguagens de programação (senão todas), possui uma maneira própria de trabalhar com funções.


Bye.
Dark Side

[vuln]

Sei que a parte que você relacionou o 'main' ao void foi puro exemplo. Mas é bom lembrar aos iniciantes que a função MAIN é padronizada como inteira. Pois como é a primeira e última a ser aberta, é necessário que ela retorne um número inteiro para o Sistema Operacional indicando se foi encerrada tudo bem ou com algum erro.

Quando você começou a falar sobre chamadas de funções, no primeiro exemplo, repetiu duas vezes a inclusão da biblioteca stdio.h (standard input-output), o correto é que apenas uma vez ela seja chamada, afinal não tem necessidade de incluir duas vezes em um mesmo código uma mesma biblioteca. E por fatores de organização e coesão, as inclusões de bibliotecas (#include) sempre deverão ser feitas no início do código.

Também não achei que você passou bem o verdadeiro significado de variáveis do tipo FLOAT. Na verdade, são variáveis com ponto flutuante, ou mais conhecida como número decimal (1,5 por exemplo).

Acho que só vi isso mesmo, mas você está de parabéns. Gostei do jeito que você ensinava grande parte das coisas. Falou bem e o material estava muito bom também. Exemplos simples para a galera jovem aprender com tudo. Parabéns DarkSide.

Até mais.

[insanity]

Funções são bem simples de entender, Parabens aí dark_sinte


ate mais