M6 - Ponteiros ou Apontadores

Módulo 6 - Estruturas de Dados Dinâmicas

Conceito de Apontador   - pode ser o mais difícil de ser compreendido

 

 

DECLARAÇÃO DE APONTADORES

tipo   *nomeponteiro;         // o asterisco pode estar ou não estar colado ao nome

tipo – é o tipo da variável para a qual apontará.               *  indica que a variável do tipo apontador

Exemplo:  int *pt;                   char  *p;  

INICIALIZAÇÃO DE APONTADORES

1)     int  X=15 ,   *Y =&X;                        //igual a         int  X=15 ,   *Y;        Y=&X;       

2)    int   *pt=NULL;               // inicialização a NULL significa *ptr não aponta para nenhuma variável

3)   float    pi=3.14,    *pt =π           // igual a        float pi=3.14,   *pt   ;            pt= π

                                                                                                                      

Formatação de saída de endereços  

 %p     sai endereço em hexadecimal

 %i     endereço sai com valor inteiro

Resumo

·       Um ponteiro ou apontador é armazena o endereço de outra variável   -“não é uma variável normal”   

• Se p for um ponteiro, *p é o valor que é apontado por p. 

• Uma variável normal tem sempre 2 coisas: um endereço e um valor.
• Se a é uma variável, &a é o endereço de a. 

Para que servem os ponteiros

§  Uma delas é a modificação dos valores dos argumentos durante a execução de uma função.

§  Outra utilidade dos apontadores é o permitir a alocação dinâmica de memória.

A alocação dinâmica de memória permite entre outras coisas criar arrays de dimensão variável sem ter de especificar previamente o tamanho máximo do array.

http://pt.wikibooks.org/wiki/Programar_em_C/Ponteiros

Apontadores e Tipos de Dados

Os tipos de dados em C ( char, int, float e double) ocupam diferente número de Bytes em memória

SIZEOF

sizeof é um operador em C que devolve o número de Bytes que uma variável ocupa em memória

Exemplo:                  sizeof( char)     - determina nº bytes de um caracter

-------------------------------------------------------------------------------------------------------------------------

Esta instrução determina o nº de bytes que um CHAR ocupa em memória

 

---------------------------------------------------------------------------------------------------------------

Dependendo do compilador utilizado podemos ter

char a=’Z’;                 //ocupa   1 byte

int n= 1234;                //ocupa   2 bytes  ou 4 bytes

float pi =3.1415;         //ocupa   4 bytes 

UTILIZAÇÃO de parâmetros por referência

O uso de ponteiros para passar parâmetros que devem ser alterados dentro de uma função é útil em certas situações como:

·  -->    Funções que precisam retornar mais do que um valor.

 Suponha que queremos criar uma função que recebe um vetor como parâmetro e precisa retornar o maior e o menor elemento do vetor.

Mas uma função só retorna um único valor!

Solução: Podemos passar ponteiros para variáveis que “receberão”o maior e menor elemento.

 

PERCORRER ELEMENTOS DO VECTOR

*v = 10;  é o mesmo que v[0] = 10;  //  v==&v[0]

*(v+2) = 30; é o mesmo que v[2] = 30;

v[n]   = =   *(v+n)

Se v for um vector ou um apontador para o primeiro elemento de um vector, então para obter o elemento índice n desse vector pode-se fazer     v[n]   ou (*v+n)

memória dinâmica 

Funções da alocação de memória dinânima:  malloc e calloc

Função usada para libertar memória alocada:    free (nome_ponteiro)

Funções da alocação de memória dinânima encontram-se acessíveis através do

#include <stdlib.h>

A função malloc (n) aloca dinamicamente n bytes na memória e devolve um ponteiro (endereço de memória).

void *malloc (unsigned int  n_Bytes)  

unsigned int   nº positivo de posições de memória

  pt = (tipo *) malloc    (  n  * sizeof(tipo)  ) ;