Ex.: 01
main(){
int x,y;
int *px;
px=&y;
y=4;x=9;
printf ("%p\n", px);
*px=3;
px--;
*px=11;
printf ("%p\n", px);
printf ("x=%d, y=%d\n", x,y);
system ("pause");
}
Ex.: 02
main (){
int x; // variavel
int *px; // armazena no ponteiro
px=&x; // variavel é armazenada no ponteiro
printf ("digite: ");
scanf ("%d",px); // nao usar mais o "&" por conta q agora nao é uma variavel e sim um ponteiro
*px=2**px; // multiplica o valor do ponteiro e armazena no mesmo.
printf("O doblo do numero: %d\n", *px);// apresenta o multiplo do numero apresentado.
system ("pause");
}
---- pausa do rata para uma breve orientação quando ao futuro. -----
PONTEIROS E VETORES
main (){
int aaa [5] // ponteiro estatico, nao consigo mudar para outra posição.
aaa [0]=9;
aaa [2]=7;
------------------------------------------------------------------------
main (){
int aaa [5];
*(aaa+0)=9; // armazena na posição do ponteiro
*(aaa+2)=7; // o 2 é o descolamento do ponteiro
}
quinta-feira, 22 de outubro de 2009
terça-feira, 20 de outubro de 2009
Ponteiros
Objetivos
Neste artigo estudaremos o que são ponteiros, qual a sua importância e como utiliza-los.
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”.
Ponteiros
O ponteiro nada mais é do que uma variável que guarda o endereço de uma outra variável. A declaração de ponteiros é feita da seguinte forma:
A instrução acima indica que pa é um ponteiro do tipo int. Agora veremos como atribuir valor ao ponteiro declarado. Para isto é necessário saber que existem dois operadores unitários que são utilizados com os ponteiros. O primeiro é o operador (*) através dele é possível retornar o valor da variável que está localizada no ponteiro. E o segundo é o operador (&) que retorna o endereço de memória que está localizado o valor da variavel contida no ponteiro. Portanto para atribuirmos um valor para o ponteiro é necessário referencia o valor da variável que se encontra no ponteiro utilizando o operador (*), como será demonstrado a seguir.
Desta forma estamos atribuindo o valor 24 para a variável que está contida no ponteiro. Para entender melhor quando e como utilizar os operadores (*) e (&), veja o programa mostrado abaixo.
Saída do programa:
Quando os ponteiros são declarados, eles são inicializados com um endereço não valido, portanto antes de usa-los é necessário atribuir um endereço e isso é feito através do operador (&) como demonstra a instrução pa=&a e pb=&b que atribui aos ponteiros pa e pb o endereço das varieis a e b.
Uma outra novidade do programa anterior é quando queremos imprimir o endereço do próprio ponteiro isto é feito referenciando pa normalmente. Porém para imprimir o endereço contido no ponteiro é usado &pa e por ultimo para imprimir o valor do endereço contido no ponteiro usamos *pa.
Através do programa abaixo é possível verificar que se pode fazer comparações entre ponteiros.
Saída do programa:
A comparação entre ponteiros em uma expressão relacional (>=,<=,> e <) é possível quando os dois ponteiros são do mesmo tipo. Isso é feito no programa mostrado através da linha “if (px1>px2)”, Caso a instrução seja verdadeira será feita a diferença entre os dois ponteiros “px1-px2”. E caso seja falso será feito ao contrario “px2-px1”. É importante dizer que os dados de saída deste programa não são iguais em todos os computadores, depende muito da memória disponível. Mas como pode-se observar em nosso exemplo, se px1=1245064 e px2=1245060 então px1-px2 será igual a um. Isso ocorre, pois a diferença depende da unidade tipo apontado. Para entender melhor, veja alguns casos de operações com ponteiros. Se um ponteiro do tipo inteiro px1 fosse igual a 150 e que os inteiros possuem dois bytes. As operações que se podem fazer são as seguintes: Incrementar o ponteiro através da expressão:
Isso fará com que o ponteiro aponte para a posição do próximo elemento. Como estamos a considerar que o tipo inteiro é do tamanho de 2 bytes, o ponteiro está sendo incrementado de 2, ou seja, o número de incrementos depende do tamanho do tipo de dados. O mesmo acontece com o decremento, porém aponta para a posição anterior. Isso é feito pela instrução:
Isso fará com que o ponteiro aponte para a posição do próximo elemento. Como estamos a considerar que o tipo inteiro é do tamanho de 2 bytes, o ponteiro está sendo incrementado de 2, ou seja, o número de incrementos depende do tamanho do tipo de dados. O mesmo acontece com o decremento, porém aponta para a posição anterior. Isso é feito pela instrução:
Uma outra opção é somar ou diminuir inteiros ao ponteiro:
Dessa forma o ponteiro irá apontar para o quinto elemento do tipo px1 adiante do elemento que o ponteiro estava a apontar. É importante saber que não se pode nem multiplicar e nem dividir ponteiros.
Do mesmo modo que se tem um ponteiro (que é o endereço de uma variável) pode-se ter ponteiro para ponteiro, ou seja, um ponteiro aponta para um outro ponteiro que finalmente aponta para a variável com o valor a ser utilizado. O que chamamos de indireção múltipla e pode ser vista no próximo programa.
Dados de saída:
Como visto no código fonte anterior, uma variável que é ponteiro para ponteiro deve ser declarada da seguinte forma:
Da mesma forma para acessar o valor final é utilizado o operador “*” duas vezes, conforme visto no neste exemplo.
Conclusão
Neste artigo vimos que um ponteiro é uma variável que guarda um endereço de uma outra variável. Estudamos como declara-las e que antes de utiliza-las é necessário atribuir um endereço válido. Foi visto também que podemos utilizar ponteiros para ponteiros. Tudo isto foi mostrado com exemplos simples e didáticos. Conclui-se, no entanto que o uso de ponteiro é importante em muitos casos e que se deve tomar muito cuidado ao usa-los. Nos próximos artigos serão estudadas algumas situações em que ponteiros são muito úteis. Como por exemplo: o uso de ponteiros para mudar os argumentos das funções e as alocações dinâmicas.
Creditos: http://www.juliobattisti.com.br
Assinar:
Postagens (Atom)