|
Windows Vista - Curso Completo
1476 páginas
 De |
Windows Server 2003 - Curso Completo
1568 páginas
De |
Windows XP - Home & Professional - 2ª Edição
1080 páginas
De |
|
Windows Vista - Curso Completo
1476 páginas
De |
Windows Server 2003 - Curso Completo
1568 páginas
De |
Windows XP - Home & Professional - 2ª Edição
1080 páginas
De |
 |
 |
 |
 |
 |
 |
 |
 |
 |
 |
 |
 |
| Autor: | Kátia Duarte |
| Data: | 18-11-2005 |
| Categoria: | Programação |
| Assunto: | C - BÁSICO |
| Visitas: | 12466 |
Objetivos
Neste artigo veremos como fazer chamadas por referencia e aprender como declarar, inicializar ponteiros para matrizes.
Pré-requisitos
É necessário que o leitor tenha acompanhado o artigo anterior, pois os artigos obedecem a uma seqüência.
Nota: Este artigo faz parte do curso de “Linguagem C – Básico”.
No artigo sobre funções foi visto o conceito de chamada por valor, ou seja, a função chamada não pode alterar nenhuma variável da função chamadora. Porém existe uma forma de fazer isto utilizando os ponteiros dito como chamada por referencia. Dessa forma os parâmetros a serem passados a função devem ser os endereços das variáveis e não os valores. Veja o programa abaixo.
#include<stdio.h>
#include<conio.h> /*Para utilizar getch();*/
AlteraValores(int *pnum1,int *pnum2);
void main()
{
int num1,num2;
num1=11;
num2=22;
/*Imprime os dados da variaveis num1 e num2 antes da função AleraValores() ser
chamada:*/
printf("Na funcao principal temos:\n");
printf("num1=%d e num2=%d\n\n", num1,num2);
/* Chama a função AlteraValores():*/
AlteraValores(&num1,&num2); /*chamada por referencia, para isso passamos os
os endereços das variaveis e não os valores.
Possibilitando assim que a função AlteraValores()
modifique os valores armazenados nessas duas
variaveis (num1 e num2) do programa principal.*/
/*Imprime os dados da variaveis num1 e num2 depois da função AleraValores() ser
executada, comprovando que os valores das duas variaveis foram modificados:*/
printf("Apos chamar a funcao AlteraValores()temos:\n");
printf("num1=%d e num2=%d\n",num1,num2);
getch();
}/*Fim do programa principal*/
AlteraValores(int *pnum1,int *pnum2)
{
/*Incrementando os valores das variaveis num1 e num2 cujos os endereços foram
armazenados nos ponteiros pnum1 e pnum2 respectivamente:*/
*pnum1=*pnum1+1;
*pnum2=*pnum2+1;
}/* Fim da função AlteraValores()*/
No programa acima pode-se observar claramente que ao passarmos o endereço das variáveis num1 e num2 para a função AlteraValores(), dado pela instrução:
AlteraValores(&num1,&num2);
pode-se modificar o valor dessas duas variáveis através da função chamada, ou seja, AlteraValores(); Essas modificações nos valores são feitos pela instrução:
*pnum1=*pnum1+1; /*Altera o valor da variavel num1 */
*pnum2=*pnum2+1; /*Altera o valor da variavel num2 */
Agora veremos um outro conceito que pode ser utilizado na linguagem c que o uso de ponteiros para chamar uma função. Embora a função não seja uma variável, ela é gravada em uma posição da memória que pode ser referenciada por um ponteiro. Dessa forma o ponteiro aponta para o inicio da função, podendo ser usado para chama-lá.
#include<stdio.h>
#include<conio.h> /*Para utilizar getch();*/
void CalculaArea();/*declara a função como sendo do tipo void */
void main()
{
void (*pfuncao)(); /*declara um ponteiro do tipo void para função.*/
pfuncao=CalculaArea; /*Diz que o ponteiro pfuncao aponta para função
CalculaArea().Nesta instrução não deve ser utilizado os
parenteses depois do nome da funcao. */
(*pfuncao)(); /*chama a função através do ponteiro pfuncao.*/
getch();
}
void CalculaArea()
{
int b,h;
float Area;
/* A entrada de dados poderia ser feito no programa principal, ela foi feita
dentro dessa função para facilitar a visualização de como é feita a chamada
do programa principal para esta função através de ponteiros.*/
/*Colhe as informações necessarias para o calculo da area do triangulo:*/
printf("Esta funcao foi chamada atraves do ponteiro pfuncao:\n\n");
printf("Aqui nesta funcao sao colhidos os dados para o calculo da area\n");
printf("Digite o valor da base do triangulo:\n");
scanf("%d",&b);
printf("Digite o valor da altura do triangulo:\n");
scanf("%d",&h);
/* Calcula a área do triangulo:*/
Area=(b*h)/2;
/*Imprime a area do triangulo:*/
printf("\nArea do triangulo:%f",Area);
}
Observe no exemplo acima que a declaração de um ponteiro para função é feita da seguinte forma:
void (*pfuncao)();
Nessa instrução temos um ponteiro para uma função do tipo void, é importante lembrar que pode-se utilizar qualquer tipo de dados definido no começo deste tutorial. Os primeiros parênteses são importantíssimos, pois caso não os coloque haverá erro ao rodar o programa. Já a instrução:
pfuncao=CalculaArea;
Atribui ao ponteiro pfuncao o endereço da função CalculaArea. Observe que não utiliza-se nenhum parênteses, pois isso significaria a atribuição do valor retornado pela função ocasionando erro na hora da compilação.
E por ultimo a instrução:
(*pfuncao)();
É responsável por chamar a função CalculaArea(), responsável por calcular a área de um triangulo.
Esse método de programação é muito usado em algumas situações como, por exemplo, quando se deseja substituir um grande comando de switch com muitas funções listadas. Um programa desse tipo pode ser simplificado utilizando matrizes de funções.
Para entender melhor o que é matriz de ponteiros para funções analise o programa a seguir.
#include<stdio.h>
#include<conio.h> /*para usar getch();*/
void funcao1(), funcao2();
void main()
{
int opcao;
void (*MatrizFuncao[2])(); /* Declarando matriz de ponteiros para função */
/*Inicializando a matrizFuncao:*/
MatrizFuncao[0]=funcao1;
MatrizFuncao[1]=funcao2;
printf("Digite 1 para primeira funcao e 2 para segunda:\n");
scanf("%d",&opcao);
if (opcao==1)
(*MatrizFuncao[0])();/*chama função*/
else
{
if (opcao==2)
(*MatrizFuncao[1])();/*chama função*/
else
printf("\nOpcao Invalida!!!");
}
getch();
}
void funcao1()
{
printf("\nVc acessou a funcao 1!!!");
}
void funcao2()
{
printf("\nVc acessou a funcao 2!!!");
}
No programa apresentado o usuário escolhe entre a opção 1 ou 2. Conforme a sua escolha uma das funções será acessada.
Para isto uma matriz de ponteiro teve que ser definida através da instrução:
void (*MatrizFuncao[2])();
O que indica que a MatrizFuncao irá conter dois elementos que são ponteiros para funções. Essa matriz de função pode ser inicializadas da seguinte forma:
MatrizFuncao[0]=funcao1;
MatrizFuncao[1]=funcao2;
Indicando que a o primeiro e o segundo elemento da matriz irá conter a funcão1 e 2 respectivamente. A função a ser chamada é determinada pelo índice em que a função se encontra. Isto é feita através das instruções:
(*MatrizFuncao[0])(); /*chama função 1*/
(*MatrizFuncao[0])(); /*chama função 2*/
Neste artigo vimos como modificar as variáveis da função principal pela função chamada. Isto foi feito usando ponteiros (chamada por referencia). E por ultimo como utilizamos matrizes de ponteiros e como elas podem nos ser úteis.
LISTA DE TODOS OS TUTORIAIS DISPONÍVEIS
Access