Modularização em C – funções

Em C não existe uma distinção entre funções e subrotinas. Ou seja, todas as subrotinas, do ponto de vista de algoritmos, podem ser tratadas como funções que não retornam nenhum valor.

Formato de declaração de funções :

Tipo de retorno identificador_da_função (tipo1 param1, tipo2 param2,..., tipoN paramN)
{

//corpo da função
return valor de retorno;

} //fim da função

Tipo de retorno especifica o tipo do valor que será retornado para quem chamou a função. Quando o tipo de retorno for void isto significa que se trata de uma função que se comporta como uma subrotina; ou seja, a função não necessita retornar nenhum valor, apenas ser chamada.

Exemplos de tipos de retorno nos cabeçalhos das funções:

int func1(...) //retorna um valor inteiro

void func2(...) //não retorna nenhum valor. Comporta-se como subrotina

O comando return é utilizado para realizar o retorno da função; este pode ser utilizado em qualquer ponto da função que se deseje finalizar a sua execução e retornar o valor (se a função retornar algum valor) para quem a chamou. Valor de retorno é o valor a ser efetivamente retornado e pode ser tanto uma variável como uma constante; nos casos em que a função não retorna nenhum valor o comando return deve ser utilizado sozinho ou pode-se simplesmente omití-lo, o que fará com que a função retorne automaticamente ao seu final.

Exemplos de uso de return:

return 0; //retorna o valor constante 0

return var; //retorna o valor da variável ‘var’

return; //não retorna valor. É usado para funções com retorno do tipo void

Os parâmetros param1 a paramN identificam os parâmetros que se deseja passar para a função. Cada um destes parâmetros passa a ser uma variável local da função de tipo tipo1 a tipoN e é inicializado com o valor que foi passado para si no momento da chamada da função. Funções que não recebem nenhum valor como parâmetro devem ser declaradas com a palavra void entre os parênteses.

Exemplos de declarações de parâmetros no cabeçalho das funções:

... Func1(int var, char var2) //dois parâmetros, um int e um char
{

}

... Func2 (void) //não recebe nenhum parâmetro
{

}

Exemplo de função e programa em C que a chama:

 

int func1 (char carac, int inteiro, float flutuante) //declaracão da função
{

int outra; //pode-se declarar outras variáveis aqui dentro, como em um trecho
//normal de programa
//estas variáveis são locais da função

printf(“%c”, carac); //uso das variáveis recebidas como parâmetro
printf(“%f”, flutuante);
scanf(“%d”, &outra);
printf(“%d”, inteiro + outra);

return outra; //retorna o valor da variável ‘outra’

} //fim da função

void main (void) //programa principal
{

char c1;
float f;
int resultado;
int inteiro;
//esta variável ‘inteiro’ existe no escopo da função
//‘main’, logo não tem nada a ver
//com a variável ‘inteiro’ que é criada na função
//‘func1’ no momento da passagem
//dos parâmetros

scanf(“%d, %c, %f”, &inteiro, &c1, &f); //lê um número
// inteiro, um caracter e um float

resultado = func1(c1, inteiro, f); //chama a função ‘func1’ com os
//parâmetros na ordem correta

printf(“%d”, resultado); //imprime resultado da função

}

 

Observações:

- main () também é uma função, porém especial já que ela representa o ponto de partida para qualquer programa em C;

- O resultado da função ‘func1’, no exemplo acima, não precisa necessariamente ser atribuído a uma variável (no caso, ‘resultado’); se isto não acontecer o valor de retorno da função simplesmente será perdido. Porém, como a função foi feita para retornar um valor inteiro isto deve ser evitado, porque constitui-se em uma má estruturação e uso da função;

- Todas as variáveis declaradas dentro do corpo de uma função são locais a ela, ou seja, só existem enquanto a função está sendo executada.

- Todas as funções devem ser “conhecidas” no local onde forem utilizadas, ou seja, a sua declaração deve vir antes do uso. Caso não se deseje implementar a função antes do local onde ela vai ser utilizada pode-se escrever um protótipo da seguinte forma:

Tipo de retorno identificador_da_função (tipo1 param1, tipo2 param2,..., tipoN paramN);

O protótipo deve ser colocado antes da chamada da função, sinalizando então ao compilador que aquela função existe e vai ser implementada adiante. No nosso exemplo, se quiséssemos escrever a função ‘func1’ depois da função ‘main’ deveríamos incluir um protótipo de ‘func1’ antes dela.

CUIDADO!! O protótipo não é exatamente igual ao cabeçalho da função, ele possui um ponto-e-vírgula a mais no final!

Variáveis globais:

Em C considera-se como variável global todas aquelas variáveis declaradas fora do escopo de qualquer função (inclusive da função ‘main’). Qualquer variável só é conhecida após a sua declaração, logo costuma-se declarar todas as variáveis globais no início do programa, antes da implementação das funções que a utilizam.

Exemplo de declaração e uso de variáveis globais:

int c;
char t;

int func1 (void) //função que retorna um valor inteiro e não recebe
// parâmetro
{

int t; //existe uma variável t que é global, porém esta
//funciona como uma variável local

if (c!=0) //c é global, logo pode ser utilizada dentro da função
//‘func1’
{

c++;
t = c*2;
return t; //neste caso o valor de t retornado é o da
//variável local, já que definições locais
//sobrepõem-se a definições globais nos escopos onde existem

}
else return 0;

}

void main(void)
{

int retorno;
printf(“Entre com um caracter:”);
scanf(“%c”, &t);
printf(“Entre com um inteiro:”);
scanf(“%d”, &c); //as variáveis t e c podem ser usadas aqui
//porque são globais

retorno = func1(); //chama a função func1 e retorna o valor na
//variável ‘retorno’

printf(“\nResultado: %d”, retorno);

}