Ponteiros

Já vimos anteriormente que temos vários tipos de variáveis, quando

digitamos int num estamos declarando uma variável do tipo inteiro chamada
num onde vamos armazenar um valor inteiro. Os ponteiros funcionam da mesma
forma só que o tipo de dados que eles guardam são endereços de memória.
Neste momento você deve estar se perguntando “para que armazenar um
endereço de memória? ”. Vamos fazer uma analogia com a vida real, vamos
supor que você foi convidado para uma festa, além de saber a data e o horário
uma informação fundamental é o endereço do local onde será realizada esta
festa, pois sem ele você não tem como chegar a ela. O ponteiro trabalha
exatamente este tipo de informação, você pode guardar, por exemplo, o
endereço de memória onde temos armazenado uma variável do tipo inteiro e
acessar este valor através do ponteiro. Trabalhar com ponteiros em C é
exatamente assim você anota o endereço de algo em uma variável do tipo
ponteiro para depois utilizar.
Os ponteiros também têm tipos, ou seja, indicamos para qual tipo de
conteúdo de memória ele vai apontar (int, float, char e etc). A forma geral para
se declarar um ponteiro é:

Tipo-do-ponteiro *nome;

Quando o compilador encontra o asterisco (*) ele interpreta que não vai
ser guardada uma variável e sim um endereço para aquele tipo de variável.

Exemplo:
int *Pnum;
float *Pmedia;

É importante ressaltar que nestes exemplos os ponteiros só foram

declarados e não estão inicializados, ou seja, apontam para um local qualquer
da memória, se tentar utilizá-lo neste momento vai provocar um erro. Todo
ponteiro para ser utilizado deve ser inicializado, que consiste em apontar para
um local de memória conhecido pelo compilador.

Exemplo:
int num = 5;
int *Pnum;
Pnum = #

Neste exemplo inicialmente declaramos uma variável do tipo inteiro

chamada num e atribuímos o valor 5 a este inteiro, depois declaramos um
ponteiro do tipo inteiro chamado Pnum. Na terceira linha apontamos o ponteiro
Pnum para o endereço de memória da variável num, onde está armazenado o
valor 5. Observe que para sabermos o endereço de memória de uma variável
basta utilizar o operador &. Uma vez inicializado o ponteiro ele está pronto para
ser utilizado, é possível até alterar o valor da variável através do ponteiro, para
isso basta utilizar o operador *, como podemos ver no exemplo a seguir.

int num = 5;
int *Pnum;
Pnum = #
*Pnum = 8;

Na prática podemos dizer que o operador & faz referência ao endereço

da memória e o operador * ao conteúdo que está armazenado neste endereço.

Exemplo:

#include <stdio.h>
int main ()
{
int num = 5;
int *Pnum;
Pnum=&num;
printf ("\nNeste momento num vale: %d\n\n", num);
printf ("Este e' o endereco da variavel num: %p\n\n",Pnum);
*Pnum = 8;
printf ("O valor de num agora e': %d\n\n",*Pnum);
return(0);
}

Executando temos:

Da mesma forma que trabalhamos com vetores e matrizes dos mais

diversos tipos, também podemos declarar um vetor ou uma matriz de ponteiros.
Neste caso o ponteiro aponta para o endereço de memória do início do array.
Exemplo:
int array[5];
int *Parray;
Parray = array;

Repare que não foi necessário utilizar o operador & na atribuição, pois um
array na verdade consiste num endereço lógico.

Passagem de parâmetro para uma função por referência

Quando trabalhamos com o C puro a única forma que temos de passar

um parâmetro para uma função é através da passagem por valor. O problema
que encontramos aqui é neste caso é criada uma cópia do valor contido da
variável passada, não sendo possível alterar seu valor através da função.

Exemplo:

#include <stdio.h>

int dobra(int numero){

numero = 2*numero;
}

int main(){
int numero;
printf("Digite um numero: ");
scanf("%d", &numero);
printf("\nNumero digitado: %d", numero);
dobra(numero);
printf("\nNumero apos executar a funcao: %d", numero);
return(0);
}
Executando temos:
Como podemos observar o valor da variável numero não foi alterado após a
função ser executada. Uma forma de contornar este problema é definindo a
variável como sendo global, como vemos a seguir.

#include <stdio.h>

int numero;

int dobra(){
numero = 2*numero;
}

int main(){
printf("Digite um numero: ");
scanf("%d", &numero);
printf("\nNumero digitado: %d", numero);
dobra();
printf("\nNumero apos executar a funcao: %d", numero);
return(0);
}

Este é o tipo de recurso que nem sempre pode ser utilizado, pois depende muito
do tipo de função e da forma de programar. Quando estamos utilizando ou
construindo uma biblioteca, fica difícil trabalhar desta forma.

Uma técnica utilizada em C é passarmos através de um ponteiro o endereço de

onde está armazenada a nossa variável, desta forma podemos alterar
diretamente o seu valor.

#include <stdio.h>

int dobra(int *num){

*num = *num * 2;
}

int main(){
int numero;
 int *ponteiro;
printf("Digite um numero: ");
scanf("%d", &numero);
printf("\nNumero digitado: %d", numero);
ponteiro = &numero;
dobra(ponteiro);
printf("\nNumero apos executar a funcao: %d", numero);
return(0);
}

Na execução do int main() inicialmente duas variáveis inteiras são declaradas,

porém uma de forma diferente int *ponteiro;, essa variável receberá uma
referência de endereço da memória. Em seguida é pedido ao usuário que digite
um valor printf("Digite um numero: ");que quando for digitado será
armazenado na variável numero. Após o valor ser recebido a variável ponteiro
recebe a referência da variável numero, ou seja, o endereço de memória em
que o valor foi armazenado.
A função dobra(ponteiro); é chamada e o conteúdo da variável ponteiro é
passado. Dessa forma a função int dobra(int *num) começa a ser executada e
alterando o conteúdo da memória vinculado a variável numero.

No C++ temos uma forma mais simples de realizar este tipo de operação, na
função basta definir o parâmetro como sendo uma referência, para isto utilizamos
o caractere & antes do nome da variável.

#include <stdio.h>

int numero;

int dobra(int &num){

num = num * 2;
}

int main(){
int numero;
printf("Digite um numero: ");
scanf("%d", &numero);
 printf("\nNumero digitado: %d", numero);
dobra(numero);
printf("\nNumero apos executar a funcao: %d", numero);
}

Quando declaramos um vetor ou uma matriz, na verdade estamos reservando o

espaço na memória e armazenando o endereço do primeiro elemento. Desta
forma sua passagem para uma função é sempre feita por referência. Como a
função não tem como saber qual o tamanho do vetor, este deverá ser passado
também como parâmetro.

#include<stdio.h>

float media(int tam, float *vetor) {

float soma = 0, media;
for(int i = 0; i < tam; i++){
soma = soma + vetor[i];
}
media = soma/tam;
return media;
}

int main(){
float array[5] = {6.5,5,8,4.5,7};
printf("Media = %.2f",media(5,array));
}