PONTEIROS – Parte 2
Programação II
Engenharia Elétrica
Prof. Nivaldo T. Schiefler Jr. - DSc
Ponteiros
Vetor e Matriz com ponteiros
Quando se declara um vetor ou uma matriz, na realidade, está
se declarando um ponteiro como vetor ou matriz.
Ex: char frase[10] = “Boa noite”;
int vetor[5] = {0,1,2,3,4};
int matriz[2][2] = { { 2,3} ,{4,5}};
2
Ponteiros
Vetores com ponteiros
Ponteiros
Vetores com ponteiros – Exemplo → Lendo uma string
char palavra[11] = "Boa noite";
char *PX;
int main()
{
PX = palavra;
while(*PX != '\0')
{
printf("%c",*PX);
PX++;
}
return 0;
}
Ponteiros
Vetores com ponteiros – Exemplo → Lendo uma string
char palavra[11] = "Boa noite"; char palavra[11] = "Boa noite";
char *PX; char *PX;
int main() int main()
{ { while(*PX)
PX = palavra; OU PX = palavra; até encontrar o ‘\0’
while(*PX != '\0') while(*PX)
{ {
printf("%c",*PX); printf("%c",*PX);
PX++; PX++;
} }
return 0;
} return 0;
}
Ponteiros
Vetores com ponteiros – Exemplo → Lendo uma string
simplificado
char palavra[11] = "Boa noite";
char *PX;
int main()
{
PX = palavra;
while(*PX)
printf("%c",*PX++);
return 0;
}
Ponteiros
Exemplo:
char frase[50]; char frase[50];
char *str; char *str;
int main() int main()
{ {
str = frase; str = frase;
printf("\n\tDigite uma frase: "); printf("\n\tDigite uma frase: ");
gets(str); gets(str);
printf("\n\tFoi digitado: "); printf("\n\tFoi digitado: ");
while(*str) while(*str)
printf("%c",*str++); printf("%c",(*str)++);
return 0; return 0;
} }
O que acontece ser for
(*str)++ ???
7
Ponteiros
char frase[50]; char frase[50];
char *str; char *str;
int main() int main()
{ {
str = frase; str = frase;
printf("\n\tDigite uma frase: "); printf("\n\tDigite uma frase: ");
gets(str); gets(str);
printf("\n\tFoi digitado: "); printf("\n\tFoi digitado: ");
while(*str) while(*str)
printf("%c",*str++); printf("%c",(*str)++);
return 0; return 0;
} }
c
Incrementa do valor do ponteiro
Não lê o conteúdo original
8
Ponteiros
EXERCÍCIO – Criar um programa que leia uma frase, via teclado pelo comando GETS().
Após a leitura da frase, deve ser escolhida uma letra qualquer. Esta letra será a base de
comparação para a contagem de letras desta frase.
O resultado final será a quantidade de letras existente neste vetor. Desenvolva a rotina
para ir lendo as posições da STRING digitada e comparando, utilizando os ponteiros para
esta STRING. Retorne pela função a quantidade de letras encontradas.
Use ponteiro em todo o código.
Ponteiros
EXERCÍCIO – Criar uma função que compara duas strings e retorne
ZERO se forem iguais e UM se forem diferentes.
Utilize os ponteiros para ler as STRINGS e comparar.
Ponteiros
Vetor com números:
#include <stdio.h>
#include <stdlib.h>
int vetor[ ] = {1,2,3,4,5,6,7,8,9,10};
int vetor[20] = {1,2,3,4,5,6,7,8,9,10};
int *ptr;
int main()
{
printf("\n\tVetor Ponteiro");
ptr = vetor;
printf("\n\n\t");
while(*ptr)
printf("%d ", *ptr++);
return 0;
}
Ponteiros
Vetor com números:
int vetor[ ] = {1,2,3,4,5,6,7,8,9,10};
Crie uma função que passe o vetor como ponteiro e retorne dois ponteiros
com somente os valores pares e impares. Retorne um ponteiro de vetor
par e outro impar.
Ponteiros
Matrizes
A declaração de uma matriz é feita normalmente:
Ex: int matriz[3][2];
Neste caso 3 linhas e 2 colunas
Sempre indicando o tipo e o tamanho das linhas e colunas
Ou ainda
#define linhas 3
#define colunas 2
int matriz[linhas ][colunas ];
13
Ponteiros
Exemplo: //***************************************
Em PRGI, foi visto // Mostra matriz
#define linhas 3
desta maneira. //**************************************
#define colunas 2
for(i = 0; i < linhas; i++)
int matriz[linhas][colunas]; {
int i, j, cont; for(j = 0; j < colunas; j++)
printf("\t%d",matriz[i][j]);
int main() printf("\n");
{ }
cont = 0; //**************************************
//***********************************
// Cria matriz de dados return 0;
//*********************************** }
for(i = 0; i < linhas; i++)
for(j = 0; j < colunas; j++)
matriz[i][j] = cont++;
14
Ponteiros
Matriz com ponteiros
#define linhas 3 //***************************************
#define colunas 2 // Mostra matriz
//***************************************
int matriz[linhas][colunas]; printf("\n\n");
int *p1,cont,i,j; cont = 0;
for(i = 0; i < linhas; i++)
int main() {
{ for(j = 0; j < colunas; j++)
p1 = matriz; printf("\t%d", p1[cont++]);
for(cont = 0; cont < linhas*colunas; cont++) printf("\n");
{ }
*p1 = cont; //***************************************
printf("\t%d", *p1);
p1++; return 0;
} } Deu certo?
// a impressão será um do lado do outro
// para colocar no formato anterior, use os
// 2 comandos de FOR
15
Ponteiros
Matriz com ponteiros
#define linhas 3 //***************************************
#define colunas 2 // Mostra matriz
//***************************************
int matriz[linhas][colunas]; printf("\n\n");
Neste caso o ponteiro P1 não está
int *p1,cont,i,j; na posição correta cont = 0;
for(i = 0; i < linhas; i++)
int main() {
{ for(j = 0; j < colunas; j++)
p1 = matriz; printf("\t%d", p1[cont++]);
for(cont = 0; cont < linhas*colunas; cont++) printf("\n");
{ }
*p1 = cont; //***************************************
printf("\t%d", *p1);
p1++; return 0;
} }
// a impressão será um do lado do outro
// para colocar no formato anterior, use os
// 2 comandos de FOR
16
Ponteiros
Matriz com ponteiros
Neste caso tem que colocar o ponteiro na posição correta.
Foi feito um apontamento para a matriz e o ponteiro foi sendo incrementado para colocar
os valores.
Tem que determinar onde está o primeiro elemento da matriz.
Matriz[0][0]
printf("\n\n");
printf("\n\t%p\n\n",&matriz[0][0]); // achar endereço
17
Ponteiros
Matriz com ponteiros
End 0
Colocando o endereço inicial no ponteiro – opção 1
//************************************ printf("\n\n");
// Mostra matriz printf("\n\t%p\n\n", &matriz[0][0]);
//************************************ // achar endereço pelo printf
printf("\n\n"); p1 = 0x0040505C; // end encontrado
cont = 0; cont = 0;
for(i = 0; i < linhas; i++) for(i = 0; i < linhas; i++)
{ {
for(j = 0; j < colunas; j++) for(j = 0; j < colunas; j++)
printf("\t%d", p1[cont++]); printf("\t%d", p1[cont++]);
printf("\n"); printf("\n");
} }
//************************************ return 0;
}
Nesta opção, se deve encontrar o endereço
e colocar no ponteiro.
18
Ponteiros
Matriz com ponteiros
Colocando automaticamente – opção 2
O & retorna o end.
//**************************************
p1 = &matriz[0][0];
// Mostra matriz
cont = 0;
//**************************************
for(i = 0; i < linhas; i++)
printf("\n\n");
{
Cont = 0;
for(j = 0; j < colunas; j++)
for(i = 0; i < linhas; i++)
printf("\t%d", p1[cont++]);
{
printf("\n");
for(j = 0; j < colunas; j++)
}
printf("\t%d", p1[cont++]);
return 0;
printf("\n");
}
}
//**************************************
printf("\n\n");
19
Ponteiros
Matriz com ponteiros
Colocando automaticamente – opção 3
//***************************************
p1 = p1 – linhas* colunas;
// Mostra matriz
cont = 0;
//***************************************
for(i = 0; i < linhas; i++)
printf("\n\n");
{
cont = 0;
for(j = 0; j < colunas; j++)
for(i = 0; i < linhas; i++)
printf("\t%d", p1[cont++]);
{
printf("\n");
for(j = 0; j < colunas; j++)
}
printf("\t%d", p1[cont++]);
return 0;
printf("\n");
}
}
//**************************************
printf("\n\n");
20
Ponteiros
Matriz com ponteiros
Colocando automaticamente – opção 3
//***************************************
p1 = p1 – linhas* colunas;
// Mostra matriz Ponteiro
cont = 0;
//***************************************
for(i = 0; i < linhas; i++) incrementando
printf("\n\n");
{
cont = 0;
for(j = 0; j < colunas; j++)
for(i = 0; i < linhas; i++)
printf("\t%d", p1[cont++]);
{
printf("\n");
for(j = 0; j < colunas; j++)
}
printf("\t%d", p1[cont++]);
return 0;
printf("\n");
}
}
//**************************************
printf("\n\n");
21
Ponteiros
Matriz com ponteiros
Colocando automaticamente – opção 3
//***************************************
p1 = p1 – linhas* colunas;
// Mostra matriz
cont = 0;
//***************************************
for(i = 0; i < linhas; i++)
printf("\n\n");
{
cont = 0;
for(j = 0; j < colunas; j++)
for(i = 0; i < linhas; i++)
{
{
printf("\t%d", *p1);
for(j = 0; j < colunas; j++)
p1++;
printf("\t%d", p1[cont++]);
}
printf("\n"); Ponteiro printf("\n");
} incrementando }
//**************************************
return 0;
}
printf("\n\n");
22
Ponteiros
Matriz com ponteiros
Colocando automaticamente – opção 3
//***************************************
p1 = p1 – linhas* colunas;
// Mostra matriz
cont = 0;
//***************************************
for(i = 0; i < linhas; i++)
printf("\n\n");
{
cont = 0; Ponteiro for(j = 0; j < colunas; j++)
for(i = 0; i < linhas; i++) incrementando printf("\t%d", *p1++);
{
printf("\n");
for(j = 0; j < colunas; j++)
}
printf("\t%d", p1[cont++]);
return 0;
printf("\n");
}
}
//**************************************
printf("\n\n"); Neste caso pela, precedência, o * tem
preferência do ++
23
Ponteiros
Operadores Associatividade
Matriz com ponteiros
() [] -> . esquerda para a direita
! - ++ -- * & (cast) sizeof direita para a esquerda
Colocando automaticamente – opção 3
*/% esquerda para a direita
+- esquerda para a direita
//***************************************
<< //
>> Mostra matriz esquerda para a direita p1 = p1 – linhas* colunas;
cont = 0;
//***************************************
< <= > >= esquerda para a direita
for(i = 0; i < linhas; i++)
== !=printf("\n\n"); esquerda para a direita {
cont = 0;
& esquerda para a direita for(j = 0; j < colunas; j++)
for(i = 0; i < linhas; i++)
^ esquerda para a direita
Ponteiro printf("\t%d", *p1++);
{
printf("\n");
| for(j = 0; j < colunas; j++)incrementando
esquerda para a direita
}
&& printf("\t%d", p1[cont++]);
esquerda para a direita return 0;
printf("\n");
|| esquerda para a direita }
}
?: direita para a esquerda
//**************************************
= += -= *= /= %= &= ^= |=
<<=printf("\n\n");
>>= Neste caso pela,
direita precedência,
para a esquerda o * tem
, preferência
esquerda para ado ++
direita
24
