Вы находитесь на странице: 1из 5

Centro de Tecnologia Microgenios - Todos os direitos reservados

Clique aqui para Imprimir o doc umento

Técnicas avançadas da linguagem C


 1.0 Protótipos de funções
 1.1 Ponteiros

Introdução
Agora que já estudamos muitos tópicos de grande importância em nosso curso, vamos explorar mais dois
itens da linguagem C, tais como:

 Protótipos de funções
 Ponteiros

Protótipos de funções:
Para melhor entendermos o conceito de protótipos de funções da linguagem C, vamos estudar um simples
exemplo de programa em C, acompanhe:

/*********************************************************************
*********
Centro de Tecnologia Microgenios
Proprama exemplo
Objetivo: apresentar o conceito: protótipo de função
**********************************************************************
*********/

//************************** subrotina aciona led


******************************
void aciona_led(){
portb = 1;
}
//************************** subrotina delay
***********************************
void gera_delay() {
delay_ms(1000);
}

//********************** função main()


*****************************************
void main() {
trisb = 0;
aciona_led();
gera_delay();
while(1);
}

Repare que a função principal do programa, ou seja, a função main() encontra-se no final do nosso
programa enquanto as demais funções encontra-se no início. Com certeza você estará se perguntando:
porque o programa é construido dessa maneira? porque não colocamos a função main() no início do
programa e as demais subrotinas (funções) no final do programa?.

Em um programa em C, não devemos chamar uma função antes do compilador saber que esta função
existe. Por esse motivo, no momento da compilação, faz necessário que as funções (subrotinas) do
programa sejam colocadas no início do programa, para que o compilador a reconheça.

Vejamos um erro classico em C:

O programa abaixo é o mesmo comentado anteriormente, sua única diferença esta no


fato de invertermos a posição da função main() para o início do programa.

/*********************************************************************
*********
Centro de Tecnologia Microgenios
Proprama exemplo
Objetivo: apresentar o conceito: protótipo de função
**********************************************************************
*********/
//********************** função main()
*****************************************
void main() {
trisb = 0;
aciona_led();
gera_delay();
while(1);
}
//************************** subrotina aciona led
******************************
void aciona_led(){
portb = 1;
}

//************************** subrotina delay


***********************************
void gera_delay() {
delay_ms(1000);
}
Ao tentarmos compilar o programa acima no mikroC, será apresentado o seguinte erro de compilação:

Este erro se deve ao fato de do pré-compilador do mikroC, no momento da compilação, encontrar o


comando de chamada de função aciona_led();
e gera_delay(); antes de encontar a subrotina void aciona_led()e void
gera_delay().

Para corrigirmos este problema, podemos utilizar os protótipos de funções no topo do nosso programa,
cujo objetivo é informar ao pré-compilador do mikroC quais são as funções de subrotinas do nosso
programa, dessa maneira podemos colocar essas funções antes ou depois da função main(), ou então
espalhada em módulos ou outros arquivos linkados com nosso programa.

Para exemplificarmos os protótipos de funções, vamos corrigir nosso programa utilizando esse recurso:

/*********************************************************************
*********
Centro de Tecnologia Microgenios
Proprama exemplo
Objetivo: apresentar o conceito: protótipo de função
**********************************************************************
*********/

//************************ protótipos de funções


*******************************
void aciona_led(); //protótipo de função
void gera_delay(); //protótipo de função

//********************** função main()


*****************************************
void main() {
trisb = 0;
aciona_led();
gera_delay();
while(1);
}
//************************** subrotina aciona led
******************************
void aciona_led(){
portb = 1;
}

//************************** subrotina delay


***********************************
void gera_delay() {
delay_ms(1000);
}
Repare que o protótipo de função se constitui na declaração da própria função que vamos utilizar no
programa, sem o bloco de comandos que esta função irão executar.

Os protótipos de funções são de grande utilidade, uma vez que eles ajudam, evitando cometermos erros
na codificação dos programas, escrevendo códigos com parâmetros inadequados para uma função.

voltar para o topo da pagina

Ponteiro
Os ponteiros são tipos de dados muito utilizado na linguagem C, podemos utilizar seus recursos em
aplicações complexas e de alta flexibilidade. Resumidamente podemos dizer que um ponteiro nada mais é
do que uma variável utilizada para guardar o endereço de outra variável, dizemos que um ponteiro é um
apontador de outra variável.

Para definirmos uma variável do tipo ponteiro, utilizamos o simbolo ' * ' (asterisco). Acompanhe o
exemplo abaixo:

int *teste
char *soma

O primeiro declara uma variável teste do tipo int como ponteiro, e o segundo declara
uma variável soma do tipo char como ponteiro.
Em C os ponteiros também tem tipos, pois ao declararmos como ponteiros, devemos
informar seu tipo de variável que irá apontar.
Repare que os dois ponteiros criados acima não foram inicializados, isso significa que
eles podem estar apontando para qualquer endereço da memória. Para não cometermos
nenhum erro na utilização de ponteiros, sempre é recomendado no momento da criação
de um ponteiro inicializa-los.

A linguagem C nos oferece o apontador (&), que é responsável por indicar a posição
específica de uma variável na memória.

variavel_soma = &teste;

No comando acima, o endereço da memória da variável teste é armazendado na variável


variável_soma.
Para exemplificar a utilização de ponteiro, acampanhe o programa abaixo:

int *endereco_soma;
int contador;
contador = 120;
endereco_soma = &contador;
*endereco_soma = 50;

Definimos uma variável ponteiro do tipo int chamada endereço_soma e uma variável do
tipo int chamada contador. Na linha de programa seguinte, é atribuido a variável
contador o valor 120. Em seguida na variável ponteiro endereco_soma é atribuido o
ENDEREÇO de memória da variável contador. Dizemos agora que a a variável
endereco_soma aponta para a variável contador. Em seguida, atribui-se o valor 50 ao
endereço apontado pela variável endereco_soma. Como resultado, a variável contador
passará a armazenar o valor 50.

Exemplos de aplicação com ponteiros:

Acompanhe o exemplo:

int soma = 100;


int *apontador;
apontador = &soma;

No código acima declaramos uma variável do tipo int chamada soma e a inicializamos
com o valor 100; declaramos também um ponteiro do tipo int chamado apontador. A
expressão, &soma, atribui ao ponteiro o endereço da variável soma. O ponteiro
apontador, passa a apontar para a variável soma. Apartir de agora, podemos alterar o
valor da variável soma através do ponteiro apontador. Quando atribuimos ao ponteiro
apontador o endereço da variável soma, significa dizer que a variável apontador é a
própria variável soma. Podemos então alterar o valor da variável soma através do
ponteiro apontador. Para isso, fariamos da seguinte maneira:

*apontador = 20;

voltar para o topo da pagina

Centro de Tecnologia Microgenios - Curso de Microcontroladores PIC - Programação


em C
Microgenios © 1998 - 2007. Todos os direitos reservados. É proibido cópia parcial ou
integral desse material sem prévio aviso. Maiores informações:
suporte@microgenios.com.br

Вам также может понравиться