AULA 13 - Introdução à Linguagem C - FIC

FUNÇÕES

Uma função é uma unidade de código de programa autônoma projetada para cumprir uma tarefa particular.

Funções permitem grandes tarela, fas de computação em tarefas menores e permitem às pessoas trabalharem sobre o que outras já fizeram, ao invés de partir do nada.

A linguagem C em si, não possui funções pré-definidas. Todas as funções utilizadas em C foram projetadas pelos próprios usuários e algumas mais usadas já foram incorporadas às bibliotecas de alguns compiladores.

Um exemplo de função em C é printf(), que realiza saídas dos programas sem que o usuário precise preocupar-se como isto é feito, pois alguém já fez isto e vendeu sua idéia aos outros usuários.

A principal razão da existência de funções é impedir que o programador tenha de escrever o mesmo código repetidas vezes.

As funções em C são utilizadas como funções (retornam valores; podem ser chamadas de dentro de uma expressão e não recebem parâmetros) e subrotinas ( não retornam valores; são chamadas por um comando CALL e recebem parâmetros) das outras linguagens.

No entanto, não pode haver aninhamento de uma função dentro de outras funções. Cada bloco de um programa em C é uma e somente uma função.

Sintaxe:

tipo nome_da_função(declaração de parâmetros formais)
{ declaração de variáveis
comandos
}

Onde:

• tipo - tipo do valor de retorno da função. Se uma função não retornar nenhum valor deve-se usar

o tipo "void", pois, por default, as funções em C/C++ retornam um inteiro. Ex: "void main(void)".

• nome_da_função - nome da função. Como qualquer identificador em C, o nome não pode ser uma

palavra reservada da linguagem (a não ser no caso da função main()), pode ser composto por letras, números e o caractere de sublinhado ( também chamado underscore: "_"), mas deve iniciar com uma letra ou com o underscore.

• declaração de parâmetros formais - neste campo são declarados os parâmetros que a função

recebe. Se a função não receber nenhum parâmetro, em alguns compiladores exige-se a utilização de "void", em outros, basta a omissão (quando então os parâmetros são assumidos como inteiros). Os nomes dos parâmetros devem ser separados por vírgulas. Ex: " int sqrt(x, y)".

Em alguns compiladores (como é o caso do Turbo C), a declaração das variáveis utilizadas na função deve, obrigatoriamente, preceder quaisquer comandos da função. Deve vir logo depois do caractere de abre-chaves ("{"). Existem outros compiladores que aceitam esta declaração em qualquer linha da função, desde que precedendo a utilização das mesmas.

• comandos - Além dos comandos do corpo da função, este bloco pode conter o comando return

que finaliza a execução da função e retorna o valor para a expressão que a chamou. Caso não haja "return", este será assumido quando o compilador encontrar o caractere de fecha-chaves ("}") e o valor retornado será indefinido.

Ex:

somaum ( int numentra)
{ int numsai;
numsai = numentra + 1;
return numsai;
}

Exercício:

Escreva a função que recebe, calcula e devolve a média de 4 valores.

Três possíveis soluções

CHAMADA DA FUNÇÃO

Vimos até agora, como é a sintaxe da execução do corpo de uma função chamada em um expressão. Mas qual é a sintaxe da chamada de uma função? Seja numa expressão, ou não, a sintaxe é:

nome_da_função(argumentos);

Na chamada de função em C não se utiliza CALL. Note que o que diferencia a chamada de uma função, da declaração da mesma é a utilização do ponto-e-vírgula (";").

Os argumentos são valores passados para a função. Quando não houver argumentos a serem passados, deixa-se este espaço em branco.

Ex:

somaum(5) → Retorna o valor 6
maior = acha_num_maior(4,7,2,5); → Retorna o valor 7 para a variável maior.

PARÂMETROS E ARGUMENTOS

Argumento é o valor passado para uma função. Parâmetro (Formal) é a variável que recebe valor do argumento.

Ex:

#include <stdio.h>
 mult(int,int);
 void main(void)
 { int a=4, b=5;
   printf(" O valor da multiplicação de %d por %d é %d\n", a, b, 
   mult(a,b));  //a e b são os argumentos
  }

mult(int x, int y)  //x e y são os parâmetros formais
{ int resultado;
resultado = x * y;
return resultado;
}

Normalmente, C utiliza passagem de parâmetros "por valor" para funções. Isto é, os argumentos recebem cópias dos valores das variáveis na expressão. Temos isto ilustrado no exemplo acima.

Quando a função mult(), recebe os argumentos a e b, na verdade apenas cópias dos valores de a e b são enviados para a função mult(). Em resumo, as variáveis a e b não tem seus valores modificados após terem sido utilizadas como argumentos de uma função.

Se deseja-se que a própria variável seja passada para a função que vai modificar seu valor utilizamos a passagem "por referência". Neste caso, o argumento recebe o endereço de memória da variável e a função chamada modifica o conteúdo deste endereço diretamente. Para passar valores por referência, utiliza-se os operadores "&" e "*":

• & - " o endereço de " - endereço da variável
• * - " no endereço de" - o que está contido no endereço da variável.

Ex:

int saida = 5;
...
incrementa(&saida);
...
incrementa(int *numentra) /* numentra contém o endereço e não o valor de saida */
/* conteúdo do endereço numentra é do tipo int */
{ (* numentra)++; /* incrementa o conteúdo de numentra */
return;
} → No final da função incrementa(), saida tem o valor 6

1. include <stdio.h>
2. include <stdlib.h>

int funcaoteste(int * x);

int main()
{ int variavel1=13;
   printf("\nValor original da variavel: %d\n", variavel1);
   printf("\nChamada da funcao: %d\n", funcaoteste(&variavel1));
   printf("\nValor da variavel depois da Chamada da funcao: %d\n\n\n", variavel1);

   return 0;
}

int funcaoteste(int * x)
{
   (*x)+=2;
   return *x;
}

VALORES DE RETORNO

Quando o tipo de valor de retorno da função não é especificado, por default a função vai retornar um valor inteiro.

Quando a função deve retornar um tipo que não o int, é necessário declarar-se o mesmo.

Quando a função não retorna nada, no caso de compiladores C ANSI, o tipo deve ser void.

ESCOPO DE VARIÁVEIS

Um programa em C é um conjunto de uma ou mais funções, sendo que uma destas funções é a principal (main()), que será a primeira a ser executada.

Como saber a que função pertence determinada variável, como seu valor muda de função para função e em qual(is) função(ões) ela existe?

Variáveis Locais ou Automáticas

São todas as variáveis declaradas dentro de uma função. Como só existem enquanto a função estiver sendo executada, são criadas quando tal função é chamada e destruídas quando termina a execução desta. Parâmetros formais são variáveis locais. Somente podem ser referenciadas pela função onde foram declaradas e seus valores se perdem entre chamadas da função.

Ex:

void func1(void)
{ int x; 
x = 10; } 

→ O x da func1() e o x da func2() são duas variáveis diferentes, armaze-nadas em posições de memória diferentes, com conteúdos diferentes,apesar do mesmo nome.

void func2(void) 
{ int x;
x = -199; }

Uma variável local deve ser declarada no início da função (antes de qualquer comando), por motivos de clareza e organização do código e porque alguns compiladores assim o exigem.

Existem parâmetros formais compiladores, no entanto, que permitem que a declaração seja feita em qualquer ponto do corpo da função, desde que antes da utilização da variável.

Variáveis Globais

São variáveis declaradas e/ou definidas fora de qualquer função do programa. Podem ser acessadas por qualquer função do arquivo e seus valores existem durante toda a execução do programa.

Também por motivos de clareza convenciona-se declará-las no início do programa, após os comandos do pré-processador e das declarações de protótipos de funções.

Ex:

...
int conta; /* conta é global */
void main(void)
{ conta = mul(10,123);
... }
func1()
{ int temp;
temp = conta;
... }
func2()
{ int conta;
conta = 10; /* esta conta é local */
... }

Variáveis externas

Um programa em C pode ser composto por um ou mais arquivos-fonte, compilados separadamente e posteriormente linkados, gerando um arquivo executável.

Como as várias funções do programa estarão distribuídas pelos arquivos-fonte, variáveis globais de um arquivo não serão reconhecidas por outro, a menos que estas variáveis sejam declaradas como externas.

A variável externa deve ser definida em somente um dos arquivos-fonte e em quaisquer outros arquivos deve ser referenciada mediante a declaração com a seguinte sintaxe:

extern tipo_var nome_var;

onde tipo_var é o tipo da variável e nome_var, o nome desta.

Ex:

Arquivo 1

int x, y; 
char ch; 
void main(void) 
{ ... } 

func1() 
{ x = 123; 
... } 

Arquivo 2

extern int x, y;
extern char ch;
 
func23()
{ x = y/10;
}

func24()
{ y = 10; 
}

Variáveis Estáticas

São variáveis reconhecidas e permanentes apenas dentro dos arquivos-fonte ou funções onde foram declaradas. Uma variável estática mantém seus valores entre chamadas da função o que é muito útil quando se quer escrever funções generalizadas (sem o uso de variáveis globais) e biblioteca de funções. A sintaxe é:

static tipo_var nome_var;

onde tipo_var é o tipo da variável e nome_var, o nome desta. Ex:

static int rand(void)
{ static int semente = 1;
semente = (semente * 25173+ 13849)%65536; /* formula magica */
return (semente);
}
...
void main(void)
{ int c;
for(c=1; c<=5; c++)
printf("Número randômico: %d \n", rand());
}

A saída deste programa será:

Número randômico: -26514
Número randômico: -4449
Número randômico: 20196
Número randômico: -20531
Número randômico: 3882

Variáveis Registradores

Uma variável declarada com o modificador register indica ao compilador para utilizar um registrador da CPU, ao invés de alocar memória para a variável.

Variáveis armazenadas em registradores são acessadas muito mais rápido que as armazenadas em memória, o que aumenta muito a velocidade de processamento. Se o número de variáveis designadas como register exceder o número disponível de registradores da máquina, então o excesso será tratado como variáveis automáticas.

Variáveis registradores não podem ser globais e geralmente aplicam-se aos tipos int e char.

Obs: Existem programadores que costumam colocar variáveis contadoras em registradores, para tornar o processamento o mais rápido possível.

Ex:

/*********************************************/
// Este programa mostra a diferença que uma variável register
// pode fazer na velocidade de execucao de um programa
/*********************************************/
#include <stdio.h>
#include <time.h>

unsigned long delay;

void main(void)
{ register unsigned int j;
  unsigned int i; // variável não-register
  long t;
  t = time('\0');
  for(delay = 0;delay < 50000; delay++)
    for(i = 0; i< 64000; i++) ;
       printf("\ntempo de loop nao register: %d \n", time('\0')-t);
  printf("\nDigite uma tecla para continuar:");
  getche( );
  t = time('\0');
  for(delay = 0; delay < 50000; delay++)
    for(j=0; j< 64000; j++) ;
       printf("\ntempo do loop register: %d \n", time('\0')-t);

}

EXERCÍCIO

Escreva o programa C que faz cálculo de área de polígonos diversos, em funções diferentes, por exemplo, área do quadrado, do retângulo, do paralelogramo e do círculo. A função main() só conterá menu de escolha de opções e imprimirá as respostas.

Exemplo de resolução