MC 102 – Algoritmos e programação de computadores Profa ... · memória será necessário para o armazenamento das informações, podendo ser determinadas em tempo de execução

MC 102 – Algoritmos e programação de computadoresProfa. Wanessa Machado do Amaral

Aula 24 – Ponteiros

MC102 – Profa.Wanessa Machado do Amaral - 1s2010

Ponteiro

Variável que guarda um endereço de memória.

Variável que guarda endereço de outra variável.

É útil para acessar regiões específicas na memória.

Declaração:int *pnum;

pnum é o nome do ponteiro e "int *" diz ao compilador que pnum guardará um endereço de memória onde será armazenado um inteiro


Atribuir valor ao ponteiro

Existem dois operadores unitários que são utilizados com ponteiros:

(*) - retorna o valor da variável que está localizada no ponteiro

(&) - retorna o endereço de memória em que está localizada a variavel do ponteiro.

É preciso decorar: & de endereço! * para valor!


Atribuir valor ao ponteiro

Quando fazemos

printf("%d",*p);

estamos imprimindo o valor do dado que está na região de memória apontada por p.

Já se fizermos:

printf("%d",p);

Estaremos imprimindo o endereço de memória para onde p aponta.

Exemplo

int num = 2; // variável inteira de nome numint *pontNum; // ponteiro para um inteiroint *pont2; // ponteiro para um inteiro

pontNum = &num; // atribui endereço da variável num em pontNumprintf("%d \n",*pontNum); // imprime 2*pontNum = 8;printf("%d \n",*pontNum); // imprime 8num = 10;printf("%d \n",*pontNum); // imprime 10pont2 = pontNum;*pont2 = *pont2 + 3;printf("%d \n",*pontNum); // imprime 13printf("%d \n",*pont2); // imprime 13


Importante

Não confunda! Se fizermos:*p2 = *p1;

estamos copiando o conteúdo da região de memória apontada por p1 para a região de memória apontada por p2.

Já se fizermos:p2 = p1;

estaremos fazendo p2 apontar para a mesma região de memória apontada por p1.


Exercício

Suponha que os endereços das variáveis a, b e c são 1000, 1004 e 1008 respectivamente. float a, b; float c, *pa, *pb; a = 0.001; b = 0.003; pa = &a; *pa = 2 * a; pb = &b; c = 3 * (*pa + *pb);Quais os valores de:(a) pa (b) *pa (c) pb (d) c


Resposta

Valores de:(a) pa = 1000(b) *pa = 0.002(c) pb = 1004(d) c = 0.015


MC 102 – Algoritmos e programação de computadoresProfa. Wanessa Machado do Amaral

Aula 24 – Alocação dinâmica


Alocação dinâmica

Imagine o seguinte problema. Você precisa de um vetor de médias de alunos, mas não sabe previamente quantos alunos terá, ou seja, quantos elementos tem o seu vetor.

Uma solução seria declarar um vetor grande o suficiente:

float medias[999];

Mas isso poderia significar um desperdício muito grande de memória, além de correr o risco de alocar espaço insuficiente.Com alocação dinâmica:

float *medias = (float*)malloc(n * sizeof(float));



A alocação dinâmica é o processo que aloca memória em tempo de execução.

É utilizada quando não se sabe ao certo quanto de memória será necessário para o armazenamento das informações, podendo ser determinadas em tempo de execução conforme a necessidade do programa.

Evita-se desperdício de memória.

Existem 4 funções para alocações dinâmica pertencentes a biblioteca stdlib.h : malloc(), calloc(), realloc() e free().


Para alocar memória para uma variável qualquer, utiliza-se o comando sizeof:

double *n; n = (double *)malloc(sizeof(double));

Para alocar memória para um vetor de double, com n posições:

double *v; // vetor de notasv = (double *)malloc(n * sizeof(double));

Onde n é um inteiro que representa quantas posições terá o vetor v.


Alocação dinâmica de um vetor float

Exemplo:

#include<stdio.h>main (){ float *medias; // vetor de medias

int n; // número de elementos do vetor printf("Qual o número de alunos? "); scanf("%d",&n);

medias = (float*)malloc(n*sizeof(float)); medias[0]=9.5; printf("%f", medias[0]); system("PAUSE");}


Comando Calloc

Quero alocar espaço para 5 inteiros. Com calloc eu faço:int *p; p = (int *)calloc(5,sizeof(int));

Com malloc eu faço:int *p; p = (int *)malloc(5 * sizeof(int));

Nos dois casos o espaço reservado é o mesmo "em tamanho", não necessariamente alocam o mesmo endereço. A diferença nesse caso seria o conteúdo que com calloc seria zerado. Zerar o conteúdo serve para descobrir se algum elemento não foi preenchido, por exemplo.


Alocação dinâmica de matriz

float **v; // ponteiro para a matriz int i; // variavel auxiliar

// aloca as linhas da matriz v = (float **) calloc (m, sizeof(float *));

// aloca as colunas da matriz for ( i = 0; i < m; i++ ) {

v[i] = (float*) calloc (n, sizeof(float));}


Comando realloc

A função realloc faz um bloco já alocado crescer ou diminuir, preservando o conteúdo já existente:

vetor = (int*) realloc (vetor, n * sizeof(int));

Comando free


A função free libera o espaço alocado:

float *medias; // vetor de mediasmedias = (float*)malloc(n*sizeof(float));

free(medias);

Nunca esqueça de usar free no término do uso da variável, para liberar a memória alocada.

Retornando um ponteiro em uma função


float *alocarVetorReal(int n){ float *v; v = (float *) calloc (n, sizeof(float)); if (v == NULL) { printf ("Erro ao alocar"); return (NULL); } return (v); // retorna ponteiro para o v}

float *p;int a = 10;p = alocarVetorReal (a);

Alocar dinamicamente um vetor de struct


Dada a seguinte struct:

struct Contato{ char nome[100]; int telefone; };

Declarar um ponteiro para a struct:

struct Contato *agenda;

Alocar espaço na memória para o vetor:

agenda = (struct Contato *)malloc(sizeof(struct Contato)*n);

Alocar dinamicamente um vetor de caracteres


Sabemos que uma string é um vetor de caracteres.

Para alocar uma string de forma dinâmica, usa-se a seguinte sintaxe:

char *letras; letras = (char *)malloc(sizeof(char)*10); letras[0]='a'; printf("%c ", letras[0]);

Com a sintaxe acima alocamos espaço na memória para armazenar uma palavra de 10 caracteres.


Alocar dinamicamente uma matriz de caracteresPor outro lado, para armazenar um vetor de strings, temos que armazenar na verdade uma matriz de letras, onde cada linha representa uma palavra ou frase.A sintaxe para alocação dinâmica de matriz de caracteres é a seguinte: char **palavras;

// aloca as linhas da matriz (vetor de palavras) palavras = (char **) malloc (10 * sizeof(char *));

// aloca as colunas da matriz (letras de cada palavra) for ( i = 0; i < 10; i++ ) {

palavras[i] = (char*) malloc (20 * sizeof(char)); } strcpy(palavras[0],"Ana Maria"); printf("%s ", palavras[0]);

Documents

MC 102 – Algoritmos e programação de computadores Profa ... · memória será necessário para o armazenamento das informações, podendo ser determinadas em tempo de execução