Linguagem de programação I A
Carlos Oberdan Rolim
Ciência da ComputaçãoSistemas de Informação
Versão: 220514_01
Ponteiros
O C é altamente dependente dos ponteiros. Para ser um bom programador em C é fundamental que se tenha um bom domínio deles
O Ministério da Saúde adverte: o uso descuidado de ponteiros pode levar a sérios bugs e a dores de cabeça terríveis :-).
Ponteiros em Linguagem C
O Que é uma variável?É uma área da memória do computador onde é armazenado um valor….
Exemplo 1:
int a = 1; Atribui ao endereço 1000 o valor 1
1000 1001 1002 1003
1
Variável Posição
a 1000
Ponteiros em Linguagem C
O Que É Um Ponteiro?Um ponteiro é uma variável que aponta para outra variável. Isto significa que um ponteiro mantém o endereço de memória de outra variável. Em outras palavras, o ponteiro não contém um valor no sentido tradicional, mas sim o endereço de outra variável. Um ponteiro "aponta para" esta outra variável mantendo uma cópia de seu endereço
Convém dizer que a expressão “apontar para...” significa “armazenar o endereço de memória de...”
Como um ponteiro contém um endereço, e não um valor, terá duas partes. O ponteiro contém um endereço e o endereço aponta para um valor. Há o ponteiro e o valor para o qual ele aponta. Este fato pode ser um tanto confuso, até você se familiarizar com ele. Superada a etapa da familiarização, ele se torna extremamente eficaz.
Ponteiros em Linguagem C
Operadores relacionados a Ponteiros:*(asterisco): informa que uma variável irá armazenar o endereço de outra variável; ou:
Informa ao computador que você deseja o conteúdo que está no endereço armazenado;- Pode ser lido como “o conteúdo no endereço”
q = *m; q recebe o valor armazenado no endereço m
& (e comercial): retorna o endereço de uma variável;- Pode ser lido como “o endereço de”
m = &count; m recebe o endereço de count
Ponteiros em Linguagem C
int main() { int i,j; int *p; p = &i; *p=5; j=i; printf(("%d %d %d\n", i, j, *p); return 0; } ==> 5 5 5
Operadores de ponteiros
* (asterisco) indica que a variável é um ponteiro
tipo_dado *nome_ponteiro;
Ex:int x;
int *pi; /* compilador sabe que pi é ponteiro */ /* pi é um ponteiro para inteiro */
Operadores de ponteiros
o operador “&” quando aplicado sobre uma variável retorna o seu endereçoEx:
int x = 10, *pi;
pi = &x;
printf(“&x: %p pi: %p”, &x, pi);
=> &x: 0x03062fd8 pi: 0x03062fd8
Operadores de ponteiros
o operador “*” quando aplicado sobre um ponteiro retorna o dado apontado
Ex:
void main () {
int *tmp_ptr;
int x, y;
x = 10;
tmp_ptr = &x;
y = *tmp_ptr; /* (*tmp_ptr) = 10 */
}
tmp_ptr
x
y
0xABA0
0xABA2
0xABA0
10
10
Outro exemplo ilustrado
int i; int *p;
p = &i;
*p=5;
Relembrando...
operador *Usado na declaração de um ponteiro
int *x
Usado para acessar o conteúdo de um endereço apontado
*x = 10; // atribui o valor 10 ao local apontado pelo ponteiro ‘x’printf(“%d”, *x); // imprime o valor armazenado no local apontado por ‘x’
operador &acessa o endereço de uma variável
Exemplo de uso
int a = 1; declara variavel inteiro com valor 1
int *pt_a; declara um ponteiro para um inteiro
pt_a = &a; ponteiro recebe o endereco da variavel a
printf(“%d”, *pt_a); imprime o valor apontado pelo ponteiro
Ponteirosponteiros são variáveis tipadas: (int *) ≠ (float *) ≠ (char *)As variaveis ponteiro devem sempre apontar para os tipos de dados corretos. Uma variavel ponteiro declarada como apontador de dados inteiros deve sempre apontar para dados deste tipo. Ex:main() {
int *ip, x; float *fp, z; ip = &x; /* OK */ fp = &z; /* OK */ ip = &z; /* erro */ fp = &x; /* erro */}
Ponteiros
espaço ocupado pelas variáveisPonteiro aponta para o tamanho segundo seu tipo
1 byte
(int *)
1 byte
(float *)
(char *)
Exemplo de uso
Exemplo:int a = 1;int *pt_a;pt_a = &a;
1000 1001 1002 1003
1 1000
Variável Posição
a 1000
pt_a 1001
Ponteiros em Linguagem C
Onde usar isto???Funções!Alocação Dinâmica
Não sei o tamanho que o vetor precisa ter….!
Não sei o tamanho que cada string precisa ter…
Não sei o tamanho que a matriz precisa ter…
Utilizando Ponteiros
void main() {int x = 10;int *pi;
pi = &x; /* *pi == 10 */(*pi)++; /* *pi == 11 */printf(“%d”, x);
}==> 11
ao alterar *pi estamos alterando o conteúdo de x
Utilizando Ponteiros
void main() {
int x = 10;
int *pi, *pj;
pi = &x; /* *pi == 10 */
pj = pi; /* *pj == 10 */
(*pi)++; /* (*pi, *pj, x) == 11 */
(*pj)++; /* (*pi, *pj, x) == 12 */
printf(“%d”, x); /* ==> 12 */ printf(“%x”, &pj); /* Endereco de x ==> 0x0c220c */
}
Arrays e ponteiros
Lembrando: arrays são agrupamentos de dados adjacentes na memória
declaração:
tipo nome_array[<tamanho>];
define um arranjo de <tamanho> elementos adjacentes na memória do tipo tipo_dado
Arrays e ponteiros’
Representação na memória: float m[10], *pf;
pf = m;
m pfNote que m é um ponteiro !!!!
Referenciando Arrays
em float m[10] m é uma constante que endereça o primeiro elemento do array
portanto, não é possível mudar o valor de m
Ex:float m[10], n[10];
float *pf;
m = n; /* erro: m é constante ! */
pf = m; /* ok */
Referenciando Elementos
pode-se referenciar os elementos do array através do seu nome e colchetes:
m[5] = 5.5;
if (m[5] == 5.5)
printf(“Exito”);
else
printf(“Falha”);
Referenciando Elementos
Pode-se referenciar os elementos de um array através de ponteiros:
float m[ ] = { 1.0, 3.0, 5.75, 2.345 };
float *pf;
pf = &m[2];
printf(“%f”, *pf); /* ==> 5.75 */
Referenciando Elementos
Pode-se utilizar ponteiros e colchetes:
float m[] = { 1.0, 3.0, 5.75, 2.345 };
float *pf;
pf = &m[2];
printf(“%f”, pf[0]); /* ==> 5.75 */
Note que o valor entre colchetes é o deslocamento a ser considerado a partir do endereço de referência
pf[n] => indica enésimo elemento a partir de pf
Exemplo
void main (){ int arint[ ] = { 1,2,3,4,5,6,7 }; int size = 7; /* tamanho do array */ int i, *pi;
for (pi=arint, i=0; i < size; i++, pi++)printf(“ %d “, *pi);
}
==> 1 2 3 4 5 6 7
Exemplo - variação
void main (){ int arint[] = { 1,2,3,4,5,6,7 }; int size = 7; /* tamanho do array */ int i, *pi;
for (pi=arint, i=0; i < size; i++)printf(“ %d “, *pi++);
}
==> 1 2 3 4 5 6 7
Exemplo - variação
void main () { int arint[] = { 1,2,3,4,5,6,7 }; int size = 7; /* tamanho do array */ int i, *pi;
pi = arint;printf(“ %d “, *pi); pi += 2;printf(“ %d “, *pi); pi += 2;printf(“ %d “, *pi); pi += 2;printf(“ %d “, *pi);
}==> 1 3 5 7
Isso causa a maior confusão....int main() {
int vetor[] = {1, 3, 5, 7, 9};
int *p = vetor;
printf("%d \n", *p ); /* imprime 1 (posicao 0)*/
printf("%d \n", *p++ ); /* imprime 1 e incrementa o p para proxima posicao (posicao 1) */
printf("%d \n", (*p)++ ); /* imprime 3 e incrementa valor que esta posicao 1 (onde p aponta) */
printf("%d \n", *p ); /* p estah apontando para posicao 1, imprime 4 */
p++; /* p agora aponta para a proxima posicao, isto eh posicao 2, valor 5 */
printf("%d - %p\n", *p , p); /* imprime posicao 2, valor 5 */
==> 1 1 3 4 5
Resumindo:p++ incrementa o ponteiro para próxima posição
*p++ retorna o valor para onde p aponta e depois incrementa o p para próxima posição
(*p)++ retorna o valor para onde p aponta e depois incrementa o valor que está ali armazenado (não muda a posição de p)
Aritmética de PonteirosÉ possível fazer operações aritméticas e relacionais entre ponteiros e inteiros
Aritmética de Ponteiros
Atribuição: Da mesma maneira que ocorre com uma variável comum, o conteúdo de um ponteiro pode ser passado para outro ponteiro do mesmo tipo. Observar que em C é possível atribuir qualquer endereço a uma variável ponteiro. Deste modo é possível atribuir o endereço de uma variável do tipo float a um ponteiro do tipo int. No entanto, o programa não irá funcionar da maneira correta.
....int vetor [] = { 10, 20, 30, 40, 50 };int *p1 , *p2;int i = 100;p1 = & vetor [2];p2 = &i;p2 = p1; ...
Aritmética de Ponteiros
Soma e subtração:Quando soma-se 1 a uma variável seu valor é incrementado em 1. No caso de ponteiros quando adiciona-se 1 o valor é incrementado de um valor que corresponde a quantidade de bytes do tipo para o qual apontaAssim, ao somar 1 a um ponteiro de int o seu valor será incrementado em 4 (devido a int = 4 bytes)Ao somar-se um inteiro n a um ponteiro, endereçamos n elementos a mais (n positivo) ou a menos (n negativo)
pf[2] equivale a *(pf+2)*(pf + n) endereça n elementos a frente*(pf - n) endereça n elementos atráspf++ endereça próximo elemento arraypf-- endereça elemento anterior array
Aritmética de Ponteiros
Exemplos
p = p + 3; p aponte para o terceiro elemento após o atual*(p+1)=10; armazena o valor 10 na posição seguinte
A diferença entre ponteiros fornece quantos elementos do tipo do ponteiro existem entre os dois ponteiros
int main (void) { float vetor [] = { 1.0, 2.0, 3.0, 4.0, 5.0 }; float *p1 , *p2; p1 = & vetor [2]; /* endereco do terceiro elemento */ p2 = vetor; /* endereco do primeiro elemento */ printf(" Diferenca entre ponteiros %d\n", p1 -p2 ); return 0;} ==> 2
Operações Válidas Sobre Ponteiros
É valido:somar ou subtrair um inteiro a um ponteiro (pi ± int)
incrementar ou decrementar ponteiros (pi++, pi--)
subtrair ponteiros (produz um inteiro) (pf - pi)
comparar ponteiros ( >, >=, <, <=, == )
Não é válido:somar ponteiros (pi + pf)
multiplicar ou dividir ponteiros (pi*pf, pi/pf)
operar ponteiros com double ou float (pi ± 2.0)
Cuidados...
C não controla os limites dos arrays, o programador deve fazê-lo
Ex:encontrar o erro:
void main () { int arint[] = { 1,2,3,4,5,6,7 }; int size = 7, i, *pi; for (pi=arint, i=0; i < size; i++, pi += 2) printf(“ %d “, *pi); }
Cuidados...
void main () { int arint[] = { 1,2,3,4,5,6,7 }; int size = 10; int i;
for (pi=arint, i=0; i < size; i++) printf(“ %d “, arint[i]);}
Cuidados...
Um ponteiro deve sempre apontar para um local válido antes de ser utilizado Ex:
void main ()
{
int i=10, *pi;
*pi = i; /*erro ! pi nao tem endereco valido*/
}
void main ()
{
int i=10, *pi = NULL;
*pi = i; /*erro ! pi nao tem endereco valido*/
}
Ponteiros e Strings
Quando imprimimos uma cadeia de caracteres constantes (string) com printf o que é passado é o ponteiro para a cadeia.
Printf(“Ola como vai?”);
Dessa forma é possível carregar o endereço da string em um ponteiro do tipo char
char * lista;
lista = "Ola como vai ?";
printf("%s", lista );
Ponteiros e Strings
Na verdade, strings são arrays de caracteres e podem ser acessados através de char *
void main () { char str[]=“abcdef”, *pc; for (pc = str; *pc != ‘\0’; pc++)
putchar(*pc); }
==> abcdefo incremento de pc o posiciona sobre o próximo caracter (byte a byte)
Ponteiros e Strings
Outra forma de mostrar uma string usando laço
char *origem = "testando";
do{
printf("%c ", *origem);
}while (*origem++); /* origem == \0 encerra o laco */
Primeiro retorna o conteúdo da posição apontada e depois
incrementa a posição (precedência de operadores)
Arrays Multidimensionais
Arrays podem ter diversas dimensões, cada uma identificada por um par de colchetes na declaraçãoEx:
char multi[5][10];declara um array de 5 linhas e 10 colunas:
na memória, entretanto, os caracteres são armazenados linearmente:
[0,0] [4,9][0,9] [1,9]
[0,0]
[4,9]
Percorrendo array com índices:
void main () {char multi[5][10];int lin, col;
for (lin=0; lin<5; lin++) for (col =0; col<10; col++)multi[lin][col] = ‘ ‘;
}as colunas (dimensões mais a direita) mudam mais rápido
Arrays Multidimensionais
Arrays Multidimensionais
Percorrendo array com ponteiro:
void main () {char multi[5][10];char *pc;int i;
for (i=0, pc=multi[0]; i < 50; i++, pc++) *pc = ‘ ‘;
}
pc aponta para primeira posição do array
Perceba a quantidade total de elementos
Arrays Multidimensionais
Outra forma de visualizar char multi[5][10]
O nome multi[5] é por si só um array indicando que existem 5 elementos, cada um deles sendo um array de 10 caracteres.
multi[0] = {'0','1','2','3','4','5','6','7','8','9'} multi[1] = {'a','b','c','d','e','f','g','h','i','j'} multi[2] = {'A','B','C','D','E','F','G','H','I','J'} multi[3] = {'9','8','7','6','5','4','3','2','1','0'} multi[4] = {'J','I','H','G','F','E','D','C','B','A‘Como os arrays são contíguos na memória, nosso bloco de memória para o array acima pode ser algo do tipo:
0123456789abcdefghijABCDEFGHIJ9876543210JIHGFEDCBA
inicio no endereço &multi[0][0]
Arrays Multidimensionais
multi[0] = {'0','1','2','3','4','5','6','7','8','9'} multi[1] = {'a','b','c','d','e','f','g','h','i','j'} multi[2] = {'A','B','C','D','E','F','G','H','I','J'} multi[3] = {'9','8','7','6','5','4','3','2','1','0'} multi[4] = {'J','I','H','G','F','E','D','C','B','A‘
O compilador sabe quantas colunas estão presentes no array de forma que ele pode interpretar multi + 1 como o endereço do 'a' na segunda linha. Ou seja, ele acrescenta 10, o número de colunas, para obter sua posição
Assim, o endereço de 9 na quarta linha acima seria &multi[3][0] ou (multi + 3) em notação de ponteiro
Para obter o conteúdo do segundo elemento na quarta linha nós acrescentaríamos 1 a seu endereço e dereferenciaríamos o resultado como em
*(*(multi + 3) + 1)
Com um pouco de raciocínio, podemos ver que:
*(*(multi + lin) + col) e multi[lin][col] dão o mesmo resultado.
Outra forma de implementar o programa anterior
int main( ){ char multi[5][10]; int lin, col;
for (lin=0; lin < 5; lin++) for (col=0; col < 10; col++)
*(*(multi + lin) + col) = 'A';
for (lin=0; lin < 5; lin++) for (col=0; col < 10; col++)
printf("%c", *(*(multi + lin) + col) );}
Arrays Multidimensionais
Array de Strings
Neste caso, cada elemento do array é um ponteiro para um caracterDeclaração: char *arstr[] = {“Joao”, “Maria”, “Antonio”,
“Zacarias”, “Carlos”};
arstr é um array de ponteiros para char, iniciado com os strings indicados
Array de Strings
Comparando array de string com array de char
char *as[] = {“Joao”,“Maria”,“Antonio”,“Zacarias”,“Carlos”};
char ma[5][10] = {“Joao”,“Maria”,“Antonio”,“Zacarias”,“Carlos”};
“Joao”“Maria”“Antonio”“Zacarias”“Carlos”
Ponteiros (as)
J o a oM a r i aA n t o n i oZ a c a r i a sC a r l o s
\0\0
\0\0
\0
Matriz (ma)
Cuidados com Strings
É comum esquecer de alocar uma área para armazenamento de caracteres
void main() {
char *pc; char str[] = “Um string”;
strcpy(pc, str); /* erro! pc indeterminado */...}
Ponteiros Genéricos
Um ponteiro genérico é um ponteiro que pode apontar para qualquer tipo de dadoDefine-se um ponteiro genérico utilizando-se o tipo void:
void *pv; int x=10; float f=3.5;pv = &x; /* aqui pv aponta para um inteiro */
pv = &f; /* aqui, para um float */
Ponteiros Genéricos
O tipo de dado apontado por um void pointer deve ser controlado pelo usuárioUsando um type cast (conversão de tipo) o programa pode tratar adequadamente o ponteiro
pv = &x;printf(“Inteiro: %d\n”, *(int *)pv); /*=> 10*/pv = &f;printf(“Real: %f\n”, *(float *)pv); /*=> 3.5*/
type cast
Ponteiros para Ponteiros
É possível definir ponteiros para ponteiros até um nível arbitrário de indireção
Ex: char *pc; /* ponteiro para char */ char **ppc;/* ponteiro para ponteiro para char */
pc = “teste”; ppc = &pc; putchar(**ppc); /* ==> ‘t’ */
Ponteiros para Ponteiros
Ponteiro para ponteiro para ponteiro...Ex:
char *pc, **ppc, ***pppc;
Um ponteiro permite modificar o objeto apontado ou apontar para outro objeto do mesmo tipo
Alocação dinâmica de memória
Pode-se alocar dinâmicamente (em tempo de execução) um espaço de memória para uso com arrays, structs, etc...
int main() { int *p;
p = (int *) malloc(sizeof(int)); if (p == 0) { printf("ERRO: Sem memória\n"); return 1; } *p = 5; printf("&d\n", *p); free(p); return 0; }
Aloca de forma dinâmica espaço para um inteiro
Alocação dinâmica de memória
mallocUtilizamos a função malloc() quando não conseguimos prever a quantidade de memória que nosso programa irá necessitar.
A função malloc() pode ser utilizada em run time para determinar o tamanho de um array.
Exemplochar * p; p = malloc(50);
p = (char *) malloc (sizeof (char));
freeLibera memória alocada previamente
Exemplo
free(p);
Realocação de memória
Função realloc()O realloc tenta realocar a quantidade de memória pedida na seqüência da já alocada, se não consegue, ele aloca uma nova área e retorna o ponteiro pra essa área, liberando a área previamente alocada.
Declaração: void *realloc(void *ptr, size_t size); Parâmetros:
Se ptr é nulo realloc() aloca o tamanaho em bytes na memória e retorna um ponteiro. Se size é zero, a memória apontada por ptr é liberada
Exemplo de realocação de memória
int main() { /* aloca um espaco para 10 caracteres – 10 bytes*/ char *pointer = (char *) malloc(10 *sizeof(char));
/* realocando espaco para 20 bytes) realloc(pointer, 20); /* errado */
/* realocando espaco para 20 bytes) pointer = (char *) realloc(pointer, 20); /* certo */
return 0;} Não esquecer do
casting
Alocação dinâmica de arrays
void main() { int numero = 10, i; int *ar; ar = (int *) malloc(numero * sizeof(int));
for (i=0; i < numero; i++) { arr[i] = i; printf("%d \n", arr[i]); } free(arranjo);}
Aloca de forma dinâmica espaço para um array de inteiros de 10 posições
int main() {
int linhas, colunas, lin, col, i; int *vetor, **matriz;
printf("\nDigite o numero de linhas: "); scanf("%d",&linhas); printf("\nDigite o numero de colunas: "); scanf("%d",&colunas);
/****** Primeira forma de fazer
vetor = (int *) malloc( linhas * colunas * sizeof(int) ); matriz = (int **) malloc( linhas * sizeof(int) ); for(i=0;i<linhas;i++) matriz[i]= &vetor[i];
*/
/****** Segunda forma de fazer */
matriz= (int **) malloc( linhas * sizeof( int ) ); for(i=0;i<linhas;i++) matriz[i]= (int *) malloc( colunas * sizeof( int ) );
/*a partir deste ponto pode ser usado matriz[a][b] sendo a o número da linha e b o número da coluna para qualquer parte do programa*/
( .... Continuacao ... )
/* Para demonstrar le um valor , coloca no array e depois mostra o valor da posicao */
for(col=0; col < colunas; col++) for(lin=0; lin < linhas; lin++){
printf("Informe um valor para [%d][%d]\n", lin, col);
scanf("%d", &matriz[lin][col]);
printf(" Valor lido-> %d\n\n“, matriz[lin][col]);
}
/*faz a liberação da memória alocada*/ free(vetor); free(matriz);
return 0;
}
Aloca de forma dinâmica espaço para um array bidimensional com tamanho fornecido pelo usuário
Top Related