Desmistificando Ponteiros - Parte 1

[Felipe Pedroso]

Uma das partes de C/C++ que fazem os iniciantes desistirem da linguagem é o estudo dos ponteiros. Muitos professores (mesmo os que têm boa intenção) não são muito didáticos na hora de ensinar essa matéria e acabam por criar um 'preconceito' besta em relação à linguagem. Eu mesmo tive certa dificuldade em relação à matéria (eximo os professores da culpa) e resolvi estudar um pouco mais a fundo a matéria. Boa parte de minhas conclusões foram retiradas do livro "Osborne - C++ --Complete Reference (3rd Ed.)" (Hebert Schildt), uma ótima referência para estudantes de C e C++. Preferi modularizar os textos para facilitar a absorção e espero que outros participantes do fórum colaborem com materiais, correções e textos complementares. Pretendo ao final dos artigos fazer exemplos para facilitar mais ainda o estudo.

Introdução

Ponteiros são variáveis que armazenam um endereço de memória de um objeto/variável na memória. Trocando em miúdos: eles armazenam a localização de uma variável da memória. Esse endereço, apesar de ser possível visualizar, é relativamente transparente.

Declaração

<tipo> [b]*[/b]nomeVariável;
<tipo>[b]*[/b] nomeVariável;

Ex.: 
int* p;
int *p;

Note que há o operador asterisco para identificar que a variável é um ponteiro. O “tipo” da variável determina qual o tipo que o ponteiro pode apontar. Tecnicamente os ponteiros (independentemente do tipo) podem apontar para qualquer endereço de memória, mas as operações “aritméticas” de ponteiro são baseadas no tipo do ponteiro. Sendo assim é importante declarar o ponteiro corretamente. Operadores • &: Operador unário que retorna o endereço do operando. Ex.: Supondo que var esteja alocada no endereço 300 e seu valor seja 350, considere a seguinte atribuição:

p = &var; //p irá receber o endereço de var: 300.

• *: Operador unário que retorna o valor do endereço de memória apontado pelo operando

Ex.: Utilizando o exemplo anterior, considere a seguinte atribuição:

i = *p; // i irá assumir o valor do endereço de memória apontado por p: 350.

Vou parar por aqui hoje. No próximo irei falar sobre Expressões de ponteiros.

Editado Maio 9, 2007 por Felipe Pedroso

[Felipe Pedroso]

Comecemos o estudo das Expressões de ponteiros...

Expressões

Atribuições:

Assim como qualquer variável é possível atribuir o valor de um ponteiro para outro ponteiro. Considere o exemplo:

int x;
int *p1,*p2;

p1 = x; // p1 recebe o endereço de x
p2 = p1; //p2 também recebe o endereço de x

ATENÇÃO: os dois ponteiros irão apontar para o endereço de x. Caso seja necessário fazer atribuições do valor que o endereço armazena podemos fazer:

int x;
int *p1;

p1 = x; // p1 recebe o endereço de x

*p1 = 4; //x agora vale 4

Note que para acessar o 'conteúdo' de x foi utilizado o operador *. Aritmética de ponteiros: Para entender o funcionamento dessas expressões aritmética vamos assumir que p é um ponteiro para inteiro (2 bytes) e aponta para o endereço 2000. Incremento: Toda vez que um ponteiro sofre um incremento ele irá apontar para o próximo elemento da memória.

p++; // o ponteiro irá apontar para o endereço 2002
p = p+3; // o ponteiro irá apontar para o endereço 2006

Decremento: Toda vez que um ponteiro sofre um incremento ele irá apontar para o elemento anterior da memória.

p--; // o ponteiro irá apontar para o endereço 1998
p = p-3; // o ponteiro irá apontar para o endereço 1994

Essas operações são mais úteis quando se trabalha com vetores e arrays (um dos próximos assuntos que necessitam de uma atenção especial), onde há alocação sequancial de memória. Nota importante do autor: quando se trata desse tipo de expressões (aritméticas) sugiro duas coisas: 1-) Não se preocupe com o endereço de memória que seu ponteiro está, apenas entenda o funcionamento. 2-) Seja cuidadoso com essas expressões afinal qualquer acesso à espaços indevidos na memória pode afetar sua máquina. Comparações: Comparações: Podemos comparar ponteiros numa expressão relacional, como segue o exemplo:

int p1,p2;

if(p1>p2)
    printf(“p2 aponta para um endereço de memória menor que o de p1”);

Isso também vale para o ==,>,<,>=,<=.

Correções, dúvidas e complementos são bem aceitos. Próxima parte: "O mistério dos ponteiros e arrays" (ps.: um segredo que professores não contam para seus alunos será revelado)

[Denis Bittencourt Muniz]

Até aqui, um ótimo tutorial. Vou trancar o tópico, até o Felipe decidir continuar o tutorial.

Falows!