(cap8) - Programação em C - Ponteiros

(cap8) - Programação em C - Ponteiros

int *m, cont=100, q; m = &cont;

main () { float x, y; int *p; p = &x; // p aponta para um float y = *p; // o valor atribuído para y não é o esperado } main() { int x; int *p1, *p2; p1 = &x; p2 = p1; // agora p1 e p2 apontam para x printf(“%p”, p2); // escreve o endereço de x e não o seu valor }

Geralmente, comparações de ponteiros são usadas quando dois ou mais ponteiros apontam para um objeto comum. Como exemplo, um par de rotinas de pilha são desenvolvidas de forma a guardar valores inteiros. Uma pilha é uma lista em que o primeiro acesso a entrar é o último a sair. É freqüentemente comparada a uma pilha de pratos em uma mesa – o primeiro prato colocado é o último a ser usado. Pilhas são muito usadas em compiladores, interpretadores, planilhas e outros software relacionados com o sistema. Para criar uma pilha são necessárias duas funções: push() e pop(). A primeira coloca os valores na pilha e a segunda retira-os. Essas rotinas são mostradas no próximo exemplo com uma função main() bem simples para utilizá-las. Se for digitado 0, um valor será retirado da pilha, e se for digitado –1 o programa é encerrado. #include <stdio.h>

#include <stdlib.h>

#define SIZE 50 void push(int i); int pop(void); int *tos, *p1, stack[SIZE]; /* stack fornece memória para a pilha */

printf("Entre com o valor: ");
scanf("%d", &value);
if(value!=0) push(value);
else printf("valor do topo ‚ %d\n", pop());

main() { int value; tos = stack; /* faz tos conter o topo da pilha, evitando que se retirem elementos da pilha vazia */ p1 = stack; /* inicializa p1 – aponta para o primeiro byte em stack */ do { } while(value!=-1);

printf("estouro da pilha");
exit(1);

void push(int i) { p1++; if(p1==(tos+SIZE)) { } *p1 = i; }

printf("pilha vazia");
exit(1);

pop(void) { if(p1==tos) { } p1--; return *(p1+1); /* retorna o conteúdo da posição p1+1 */ }

int *p = NULL; // Macro que define um ponteiro nulo char *p = “alo mundo”; int x = 10; int *p = &x; char str[80], *p1; p1 = str;

// Indexa s como uma matriz void puts (char *s) { register int t; for (t=0; s[t]; ++t) putchar(s[t]); }

// Acessa s como um ponteiro void putstr (char *s) { while (*s) putchar(*s++); // “ *s++; ” é equivalente a “ *s; s++; ” }

void display_array (int *q[]) { int t; for (t=0; t<10; t++) printf (“%d ”, *q[t]); }

void syntax_error (int num) { static char *err[] = {

“Arquivo não pode ser aberto \n”, “Erro de leitura \n”, “Erro de escrita \n”, “Falha da mídia \n” }; printf(“%s”, err[num]); }

char *p1; int *p2; : if ( !(p1=malloc(1000)) ) { // Se a alocação dos 1000 bytes retornar nulo printf(“Sem memória disponível. \n”); exit(1);// Aborta a execução do programa; Poderia ter um tratamento de erro. } : p2 = malloc(50*sizeof(int));// usando a função “sizeof” há uma garantia de portabilidade : free(p1); free(p2);

// Aloca espaço para uma string dinamicamente, solicita a entrada do usuário e, em seguida, // imprime a string de trás para frente. #include <stdlib.h>

#include <stdio.h>

printf("Falha na solicitação de memória \n");
exit(1);

#include <string.h> void main(void) { char *s; register int t; s = malloc(80); if(!s) { } gets(s); for(t=strlen(s)-1; t>=0; t--) putchar(s[t]); free(s); }

/* Apresenta as potências dos números de 1 a 10. Nota: muito embora esse programa esteja correto, alguns compiladores C apresentarão uma mensagem de advertência, ou até erro, com relação aos argumentos para as funções table() e show(). Se forem apenas advertências, ignore. */

#include <stdio.h> #include <stdlib.h>

printf("Falha na solicitação de memória. \n");
exit(1);
for(i=1; i<5; i++) p[i-1][j-1] = pwr(j, i);
for(i=1; i<5; i++) printf("%10d ", p[i-1][j-1]);
printf("\n");

void main(void) { int *p; p = (int *) malloc(40*sizeof(int)); if(!p) { } // aqui, p ‚ é simplesmente um ponteiro table(p); show(p); } // Constrói a tabela de potências void table(int p[4][10]) { // agora o compilador tem uma matriz para trabalhar register int i, j; for(j=1; j<1; j++) } // Exibe a tabela de potências inteiras void show(int p[4][10]) { // agora o compilador tem uma matriz para trabalhar register int i, j; printf("%10s %10s %10s %10s\n", "N", "N2", "N3", "N4"); for(j=1; j<1; j++) { }

} // Eleva um inteiro a uma potência especificada pwr(int a, int b) { register int t=1; for(; b; b--) t = t*a; return t; }

Comentários