AULA 13 - Microcontroladores - Técnico
FUNÇÕES
Uma função é uma unidade de código de programa autônoma projetada para cumprir uma tarefa particular.
Funções permitem que grandes tarefas de computação sejam quebradas 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 ideia 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 como 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, 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.
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); //protótipo da função mult()
//corpo da função main():
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));
}
//corpo da função mult():
mult(int x, int y)
{ int resultado;
resultado = x * y;
return resultado;
}
Normalmente, C utiliza passagem de parâmetros "por valor" para funções.
Isto é, os parâmetros recebem cópias dos valores dos argumentos 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
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 sempre 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; ® O x da func1() e o x da func2() são duas variáveis diferentes, armaze-
x = 10; } nadas em posições de memória diferentes, com conteúdos diferentes,
void func2(void) apesar do mesmo nome.
{ 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 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 Arquivo 2
int x, y; extern int x, y;
char ch; extern char ch;
void main(void) func23()
{ ... } { x = y/10;
func1() }
{ x = 123; 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 int i; // variável não-register
unsigned int delay;
void main(void)
{ register unsigned int j;
long t;
t = time('\0');
for(delay = 0;delay < 50000; delay++)
for(i = 0; i< 64000; i++) ;
printf("tempo de loop não register: %d \n", time('\0')-t);
getch( );
t = time('\0');
for(delay = 0; delay < 50000; delay++)
for(j=0; j< 64000; j++) ;
printf("tempo do loop register: %d \n", time('\0')-t);
}
| << Aula 12 - Instruções DO-WHILE, FOR e SWITCH | AULA 13 - Microcontroladores | Aula 14 - Matrizes >> |
|---|