Lista de exercícios de Ponteiros

ṕrof. Raimundo C S Vasconcelos

GIOVANNI LUCAS OLIVEIRA DA
SILVA

1) O código abaixo contém a declaração de algumas variáveis e ponteiros. Quando você executa esse
código quais serão os valores de x, y e p ao final do trecho de código abaixo?

void main() {
int x, y, *p; y =0;
p = &y;
x =*p;
x = 4;
(*p)+;
--x;
(*p) += x;
}
Resposta x = 3, y = 4 e p = &y.

2. Uma das atividades mais desafiadoras aos programadores é entender o código feito por outras
pessoas. Isso fica ainda pior quando existem erros ou “bugs” nos códigos. Então, para você praticar
um pouco isso os trexos de código abaixo possuem alguns erros. Identifique-os e reescreva
indicando como deveriam ser.

a) Resposta:
void main() {
int x, *p;
x = 100;
*p = x;
printf(“Valor de p: %d.\n”, *p);
}

b) Resposta:
void troca (int *i, int *j)
{ int temp;
temp = *i;
*i = *j;
*j =
temp;
}

c) R:
main(){
char *a, *b;
a = "abacate";
b = "uva”;
if (a < b) {
printf ("%s vem antes de %s no dicionário.\n", a, b);
} }
else{ }
printf
("%s
vem
depois
de %s
no
dicion
ário.\
n", a,
b);
3) Crie uma função que receba por parâmetro um vetor de números inteiros e os endereços de duas
variáveis inteiras (que podemos chamar de min e max). Ao passar essas variáveis para a função, seu
programa deverá analisar qual é o maior e o menor elemento do vetor e depositar esses elementos
nas variáveis do parâmetro. É claro que para testar tudo isso você vai precisar criar uma função main
que consuma a função que você definiu.

Use o seguinte protótipo para sua função:

void maiorMenor(int vetor[], int* maximo, int* minimo);

#include <stdio.h>

void maiorMenor(int vetor[], int* maximo, int* minimo, int tamanhoDoVetor);

int main() {
int maximo = 0, minimo = 0;
int vetor[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
maiorMenor(vetor,&maximo, &minimo, 10);
printf("%d %d\n", maximo, minimo);
}

void maiorMenor(int vetor[], int *maximo, int *minimo, int tamanhoDoVetor) {

*maximo = vetor[0];
*minimo = vetor[0];

for(int i = 1; i<tamanhoDoVetor; i++) {

if (vetor[i] > *maximo) {
*maximo = vetor[i];
} else {
*minimo = vetor[i];
}
}
}

4) Nesse exercício abandone seu computador por alguns minutos e analise o conteúdo do vetor “a”
depois dos seguintes comandos.

main(){
int i, a[99];

for (i = 0; i < 99; ++i)

a[i] = 98 - i;

for (i = 0; i < 99; ++i)

a[i] = a[a[i]];
}
Analisado, o vetor a fica
um vetor espelhado do 0
ao 49 e do 48 ao 0.

5) Agora vamos manipular um vetor inteiro dentro de uma função. Para isso, você precisa definir a
assinatura da função :
void troca(float *a, float *b);
Agora você precisa escrever a função que troca o valor que está em “a” pelo valor que está em “b”.

Veja o exemplo da função main: void

main(){
float a,b;
a = 1.2;
b = 2.4;
troca (&a, &b);
// por fim imprimindo:
printf("%f,%f", a, b);
}
O resultado esperado é:

//output
2.4,1.2

#includ
e
<stdio.h
>

void
troca(fl
oat *a,
float
*b);

int
main()
{

void
troca(fl
oat *a,
float
*b) {
float
aux =
*a;
*a =
*b;
*b =
aux;
}

6) Agora vamos criar uma função que copia um vetor de caracteres para outro vetor (cria uma
cópia). A assinatura da função deve ser:

char *strcopy(char *str, int tamanho);

char *strcopy(char *str, int tamanho){

char *copy;

copy = malloc(sizeof(char) * tamanho);

for(int i = 0; i < tamanho; ++i){

copy[i] = str[i];
}

return copy
}
7) Você sabia que é possível criar um ponteiro que aponta para um ponteiro? Como explicamos
anteriormente um ponteiro é um tipo de dados que aponta para um endereço de memória de uma
variável (que possui um tipo), ou seja, quando você cria um int *a; você cria um ponteiro para um
inteiro. No entanto, os ponteiros podem apontar para outros ponteiros. Para isso você deverá colocar
dois sinais de asteriscos, seria algo assim:

int **p
Agora analise o código abaixo e explique cada uma das linhas usando comentários.

main (){
int x = 100, *p, **pp; //criando variaveis e ponteiros e ponteiros de prts.
p = &x; //atribuindo valor de memoria de x para o ponteiro p.
pp = &p; //atribuindo valor de memoria do ponteiro p para o pp.
printf("Valor de pp: %dn", **pp); //desreferenciando o ponteiro pp 2x para printar.
}

8) Vamos criar uma função agora que localiza uma letra em um vetor e retorna um outro vetor
com suas posições onde a letra foi encontrada. Por exemplo:

0 1 2 3 4
[v][a][n][i][a]

// output procurando a letra "a" [1][4]

int *find(char *str, int size, char target)

{
int *index_target;
int size_target = 0;

index_target =
malloc(sizeof(char) * size);
for(int i = 0; i < tamanho; ++i){
if (str[i] == target){
index_target[size_target] =
str[i]
size_target++;
}
}
return index_target
}

9) Vamos treinar um pouco a identificar o que significa os operadores asterisco. Para

relembrar eles podem assumir duas funções:

quando você quer definir um ponteiro

quando você quer desreferenciar um ponteiro (acessar o valor da variável que o ponteiro aponta)
O que significa o operador asterisco em cada um dos seguintes casos:

a) int *p;
cria um ponteiro de int.
b) printf("%d",*p);
 Desreferencia o ponteiro p.
c) *p = x*5;
desreferenciando e multiplicando
d) printf("%d",*(p+1));
desreferenciando uma matematica de ponteiros.

10) Os ponteiros são excelentes exercícios de lógica, a seguir temos uma função main com alguns
ponteiros e variáveis. Identifique o que será impresso na tela.

void main(){
int i=5,
*p; p =
&i;
printf("%d, %d, %d ,%d, %d", p,(*p+2),**&p, (3**p),(**&p+4);
}

&i, 7, 5, 15, 9