Programao C

Ponteiros
Fernando S. Pacheco
INSTITUTO FEDERAL DE EDUCAO, CINCIA E TECNOLOGIA DE SANTA CATARINA
CAMPUS FLORIANPOLIS
DEPARTAMENTO ACADMICO DE ELETRNICA
ProgC - Ponteiros 2
Sumrio

Ponteiros

Recapitulando variveis

Aplicaes

Operadores e inicializao

Argumento de funes

Aritmtica de ponteiros

Relao com vetores (arrays)

Exemplos e cuidados

Ponteiros const
ProgC - Ponteiros 3
Ponteiros

Conceito importantssimo em C

Recapitulando variveis em C

Varivel um espao em memria com um nome

especfico e com valor que pode mudar

Tamanho do espao depende do tipo da varivel

Endereo (byte)
k Nome
Valor
0xA0 0xA1 0xA2 0xA3 0xA4 0xA5
Varivel
Memria hipottica organizada em bytes
ProgC - Ponteiros 4
Recapitulando variveis

Quando se declara
char k;

1 byte (8 bits) de memria reservado (para

guardar um valor inteiro)

Uma tabela de smbolos mapeia o endereo

reservado para o identificador k
ProgC - Ponteiros 5
Recapitulando variveis

Quando, no programa, define-se

k=2;

O valor 2 colocado na poro de memria

reservada para k
00000010
Endereo (byte)
k
Nome
Valor
0xA0 0xA1 0xA2 0xA3 0xA4 0xA5
Varivel
ProgC - Ponteiros 6
Recapitulando variveis

Observe que ao elemento k esto associadas

duas informaes

O prprio inteiro que est armazenado (2, p.ex.)

O valor da localizao de memria, ou seja, o

endereo de k

H situaes em que o que se deseja

armazenar um endereo

Ponteiro uma varivel que armazena um

endereo de memria, ou seja, aponta para um
endereo
ProgC - Ponteiros 7
Ponteiros

Na figura, a caixa representa um espao em

memria

var1 o nome de um desses espaos

2 o valor que est armazenado nesse espao

0xA0 o endereo desse espao na memria

00000010
Endereo (byte)
Nome
Valor
0xA0
Varivel
var1
0xA0
0xA7
ptr_var1
ProgC - Ponteiros 8
Ponteiros

ptr_var1 uma outra varivel

ptr_var1 armazena o valor (endereo) 0xA0

Neste exemplo, o endereo da varivel var1

00000010
Endereo (byte)
Nome
Valor
0xA0
Varivel
var1
0xA0
0xA7
ptr_var1
ProgC - Ponteiros 9
Ponteiros

Diz-se que ptr_var1 aponta para var1

Ponteiro tambm chamado de varivel de

endereo
00000010
Endereo (byte)
Nome
Valor
0xA0
Varivel
var1
0xA0
0xA7
ptr_var1
ProgC - Ponteiros 10
Aplicaes de Ponteiros

Fazendo uma analogia com endereos fsicos

O endereo praticamente de mesmo tamanho

As casas em cada endereo podem ter

tamanhos diferentes
R
.

d
a
s

L
e
t
r
a
s
,

4
5
R
.

d
a
s

L
e
t
r
a
s
,

9
7
R
.

d
a
s

L
e
t
r
a
s
,

1
0
3
R
.

d
a
s

L
e
t
r
a
s
,

2
5
ProgC - Ponteiros 11
Aplicaes de ponteiros

Observe o exemplo seguinte

Executando, verifica-se que tamanho dos

ponteiros sempre o mesmo

Para plataforma 32 bits, de 4 bytes

printf("tamanho de char: %d\n", sizeof(char));
printf("tamanho do ptr para char: %d\n", sizeof(char*));
printf("tamanho de int: %d\n", sizeof(int));
printf("tamanho do ptr para int : %d\n", sizeof(int*));
ProgC - Ponteiros 12
Aplicaes de Ponteiros

Voltando analogia da casa/endereo

Uma aplicao acessar estruturas de dados

(casa) atravs de ponteiros (endereo)

Mesmo para estruturas complexas, o acesso

ser rpido
ProgC - Ponteiros 13
Aplicaes de Ponteiros

Outra aplicao retornar mais de um valor de

uma funo atravs de ponteiros

Lembrar que no formato convencional

tipo_retorno nome_funcao(parametr1, parametr2)
float media(float nota1, float nota2)

S um valor pode ser retornado

ProgC - Ponteiros 14
Declarao de ponteiros

Colocar um asterisco na frente do nome da

varivel
int var1; // declara uma varivel do tipo int
int *ptr_num; //declara um ponteiro do tipo int

Cuidado com declarao de mais de um

ponteiro na mesma linha
int p, q, r; // trs variveis comuns
int *p, q, r; // cuidado! apenas p ser um
ponteiro!
int *p, *q, *r; // agora temos trs ponteiros
ProgC - Ponteiros 15
Operadores para Ponteiros
Operador Significado
*
&
Dereference (dado um ponteiro, obtm o elemento
referenciado)
Address_of (dado um elemento, aponta para o mesmo)
ProgC - Ponteiros 16
Operadores para Ponteiros
int var1; // declara varivel do tipo int com o nome var1
var1 = 4;
int *ptr_var1; //declara um ponteiro do tipo int
ptr_var1 = &var1; //ponteiro aponta para var1, ou seja,
armazena o endereo de var1
*ptr_var1 = 5; //altera o valor que est armazenado no
endereo apontado pelo ponteiro para 5
Cdigo C Descrio
var1 Varivel simples
&var1 Ponteiro para a varivel var1 (endereo de var1)
Um inteiro
ptr_var1
Ponteiro para um inteiro (neste exemplo, aponta para a
varivel var1)
*ptr_var1
ProgC - Ponteiros 17
Operaes com Ponteiros
ProgC - Ponteiros 18
Operaes com Ponteiros
#include <stdio.h>
int main() {
int i = 10;
int *ptr;
ptr = &i;
printf("Valor de i: %d\n", i);
printf("Valor apontado por ptr: %d\n", *ptr);
printf("Endereo de i: %p\n", &i);
printf("Endereo apontado por ptr: %p\n", ptr);
printf("Endereo de ptr: %p\n", &ptr);

*ptr = 5;
printf("Valor de i: %d\n", i);
printf("Valor apontado por ptr: %d\n", *ptr);
printf("Endereo apontado por ptr: %p\n", ptr);
return(0);
}
ProgC - Ponteiros 19
Mais ponteiros

Dois ou mais ponteiros podem apontar para o

mesmo endereo
int val;
int *primeiro_ptr; /* um ponteiro */
int *segundo_ptr; /* mais um ponteiro */
val = 1; /* atribui um valor para a varivel * /
primeiro_ptr = &val; //O que est sendo feito aqui? Comente
segundo_ptr = primeiro_ptr; // E aqui? vlido fazer isso?
ProgC - Ponteiros 20
Exerccio 1

Determine o que ocorre em cada linha do

programa

Qual o valor final de c e d?

int *a, *b, c = 3, d = 7;
a = &c;
b = &d;
*a = 5;
*b = 8;
*a = *b;
*a = 2;
b = a;
*b = 0;
ProgC - Ponteiros 21
Resposta do Exerccio 1
int *a, *b, c = 3, d = 7;
a = &c; // a apontar para c
b = &d; // b apontar para d
*a = 5; // o valor em c alterado (c=5)
*b = 8; // o valor na varivel d alterado (d=8)
*a = *b; // o valor de d (apontado por b)
// copiado para c (apontado por a) (c=8)
*a = 2; // o valor na varivel c alterado (c=2)
b = a; // b aponta para o mesmo lugar que a,
// ou seja, para c
*b = 0; // o valor de c alterado (c=0)
ProgC - Ponteiros 22
Exerccio 2

Determine o que ocorre em cada linha do

programa

Qual o valor final de a e d?

int a=5, *b, *c, d=8;
b = &a;
a = 7;
c = &a;
*c = 9;
b = &d;
*b = *c;
*c = *b + *b;
d = a;
*b = 1;
ProgC - Ponteiros 23
Inicializao de ponteiros

Ponteiros devem ser inicializados antes de

serem usados, ou seja, tm que apontar para
um endereo especfico antes do uso

Chamado wild pointer (ponteiro selvagem)

Fazer o seguinte levar a uma falha de

segmentao
int *p; /*ponteiro no inicializado*/
*p = 9; /*o endereo fsico para guardar o
nmero 9 pode no ser vlido*/
ProgC - Ponteiros 24
Inicializao de ponteiros

Compile e execute o programa seguinte

Observe o problema
ProgC - Ponteiros 25
Inicializao de ponteiros
#include <stdio.h>
int main()
{
int val = 7;
int *ptr;
printf("Valor de val: %d\n", val);
printf("Endereo apontado por ptr: %p\n", ptr);
printf("Valor apontado por ptr: %d\n", *ptr);
/*observe que aqui haver lixo, que poderia
ser usado e traria consequncias desastrosas*/

return(0);
}
ProgC - Ponteiros 26
Inicializao de ponteiros
#include <stdio.h>
int main()
{
int val = 7;
int *ptr=NULL; /*apontar para o endereo NULL
(0), ir evitar que lixo seja usado, como no
exemplo anterior*/
printf("Valor de val: %d\n", val);
printf("Endereo apontado por ptr: %p\n", ptr);
printf("Valor apontado por ptr: %d\n", *ptr);
/*ir gerar um SEG FAULT (falha de
segmentao)*/

return(0);
}
ProgC - Ponteiros 27
Inicializao de ponteiros
/*Mais um exemplo de problema*/
#include <stdio.h>
int main()
{
int val = 7;
int *ptr;
*ptr = 5; //aqui ocorrer uma falha de
segmentao (SEG FAULT)

printf("Valor de val: %d\n", val);
printf("Valor apontado por ptr: %d\n", *ptr);
printf("Endereo apontado por ptr: %p\n", ptr);
return(0);
}
ProgC - Ponteiros 28
Resumo at aqui

At aqui, vimos o que so ponteiros e como

oper-los

Vamos ver, agora, uma aplicao importante

Funes com mais de um retorno atravs do uso

de ponteiros
ProgC - Ponteiros 29
Ponteiros como argumentos de
funes

Em C, parmetros so passados para uma

funo atravs de uma chamada por valor

Valor do argumento copiado para dentro da

funo
ProgC - Ponteiros 30
Ponteiros como argumentos de
funes

Na chamada por valor o caminho s tem uma

direo
ProgC - Ponteiros 31
Ponteiros como argumentos de
funes

Mas usando ponteiros, possvel alterar o

prprio parmetro de entrada

Assim, funo poder emular a existncia de

mais de um retorno

Passagem por referncia

Vamos ver um exemplo prtico

ProgC - Ponteiros 32
Ponteiros como argumentos de
funes

Programa para trocar o valor de duas variveis

#include <stdio.h>
int main()
{
int a = 5;
int b = 10;
int temp;
printf ("%d %d\n", a, b);

temp = a;
a = b;
b = temp;

printf ("%d %d\n", a, b);
return 0;
}
ProgC - Ponteiros 33
Ponteiros como argumentos de
funes

E se essa operao tiver que ser repetida

vrias vezes? Como coloc-la em uma funo?

Verifique se o cdigo seguinte faria isso.

ProgC - Ponteiros 34
#include <stdio.h>
void swap(int i, int j)
{
int temp;
temp = i;
i = j;
j = temp;
}
int main()
{
int a, b;
a = 5;
b = 10;
printf ("%d %d\n", a, b);
swap (a, b);
printf ("%d %d\n", a, b);
return 0;
}
ProgC - Ponteiros 35
Ponteiros como argumentos de
funes

Como fazer usando ponteiros

#include <stdio.h>
void swap (int *i, int *j) {
int temp;
temp = *i;
*i = *j;
*j = temp;
}
int main () {
int a, b;
a = 5;
b = 10;
printf ("\n\nValem a=%d, b=%d\n", a, b);
swap (&a, &b);
printf ("\n\nAgora, valem a=%d, b=%d\n", a, b);
return 0;
}
ProgC - Ponteiros 36
Ponteiros como argumentos de
funes

Outro exemplo
//contador incrementado dentro da funo
#include <stdio.h>
void inc_contador(int *conta_ptr)
{
(*conta_ptr)++;
}
int main()
{
int conta = 0;
while (conta < 10)
inc_contador(&conta);
printf(conta = %d\n, conta);
return (0);
}
ProgC - Ponteiros 37
Ponteiros como argumentos de
funes
#include <stdio.h>
void inc_contador
(int *conta_ptr)
{
(*conta_ptr)++;
}
int main()
{
int conta = 0;
while (conta < 10)
inc_contador(&conta);
return (0);
}
ProgC - Ponteiros 38
Exerccio

Fazer uma funo que receba o raio de um

crculo e devolva o comprimento da
circunferncia e a rea

No use variveis globais

Use ponteiros

main() pergunta o raio para o usurio, chama a

funo e depois imprime o resultado
ProgC - Ponteiros 39
Ponteiros como argumentos de
funes

Alm de permitir que mais de um valor retorne,

a passagem por referncia tem outra vantagem

No h cpia dos valores para dentro da funo

Mais rpido e eficiente

Principalmente para manipulao de vetores e estruturas

Observe o exemplo seguinte

interessante monitorar a memria (no debugger)

ProgC - Ponteiros 40
Ponteiros como argumentos de
funes
#include <stdio.h>
void troca(char* string_ptr) {
//frase no copiada para dentro da funo.
passado um ponteiro (endereo do incio da string).
*string_ptr='0'; //altera a primeira letra
string_ptr++;
*string_ptr='1'; //altera a segunda letra
}
int main () {
char frase[150]="Esta uma string grande...";
printf ("\n\nfrase=%s\n", frase);
troca(frase);
printf ("\n\nAgora, frase=%s\n", frase);
return 0;
}
ProgC - Ponteiros 41
Aritmtica de Ponteiros

A definio do tipo em ponteiros serve para

que o compilador saiba quantos bytes copiar para

uma posio de memria
int *ptr, var1; //plataforma com int 32
ptr = &var1;
*ptr = 2;

Neste exemplo, indica que 32 bits representando o

nmero 2 sero copiados para a rea de memria
apontada

Alm disso, tambm serve para fazer operaes

aritmticas com ponteiros
ProgC - Ponteiros 42
Aritmtica de Ponteiros

Vamos imaginar que ptr do exemplo anterior

aponta para o endereo (em bytes) 100
(decimal)

Para qual endereo aponta (ptr+1)?

ProgC - Ponteiros 43
Aritmtica de Ponteiros

Se ptr do tipo int (4 bytes), o ponteiro ir

apontar para o prximo endereo com um
inteiro

Neste caso hipottico, para o endereo 104

ProgC - Ponteiros 44
Aritmtica de Ponteiros

Os operadores

++, --

comparao: >, <, >=, <=, ==, !=

So vlidos com ponteiros e operam sobre os

endereos

Veja exemplo seguinte

ProgC - Ponteiros 45
Aritmtica de Ponteiros
#include <stdio.h>
int main(void) {
int k=2010;
int *ptr=&k;
printf("0. tamanho do int: %d\n", sizeof(int));
printf("0. endereo de k: %p\n", &k);
printf("0. endereo apontado por ptr: %p\n", ptr);
ptr++; //para fins didticos.No deve ser acessado
printf("1. endereo apontado por ptr: %p\n", ptr);
ptr++;
printf("2. endereo apontado por ptr: %p\n", ptr);
if (ptr>&k) {
printf("endereo %p maior que %p\n", ptr, &k);
}
return 0;
}
ProgC - Ponteiros 46
Ponteiros e Vetores (Arrays)

Podemos continuar estudando a aritmtica de

ponteiros a partir de vetores

Em C, os elementos de um vetor so
guardados sequencialmente, a uma distncia
fixa um do outro

Seja o seguinte (pont_vet1.c)

char array[5] = {5, 10, 15, 20, 25};
char *array_ptr = &array[0];
ProgC - Ponteiros 47
Ponteiros e Vetores (Arrays)

Considerando a organizao hipottica de

memria da figura

Verifique o que obtido com

printf(%d %d, *array_ptr, *(array_ptr+1));

E com printf(%d,(*array_ptr)+1); ?
char array[5] = {5, 10, 15, 20, 25};
char *array_ptr = &array[0];
ProgC - Ponteiros 48
Ponteiros e Vetores (Arrays)

Programa Exemplo

Definir vetor

Usar ponteiro para acessar cada valor

(No prximo exemplo, ser vista a equivalncia

com vetor)
ProgC - Ponteiros 49
Ponteiros e Vetores (Arrays)

Verifique a sada do programa (pont_vetor2.c)

#include <stdio.h>
int main ()
{
int i;
int vetor[3] = {4, 7, 1};
int *ptr;
ptr = vetor;// Em C igual a ptr = &vetor[0]
printf("Tam. do int nessa plataf.: %d\n\n", sizeof(int));
printf("End. vetor: %p\n", vetor);
printf("End. apontado por ptr: %p\n", ptr);
printf("End. onde est ptr: %p\n", &ptr);
for (i = 0; i < 3; i++) {
printf("O endereo do ndice %d do vetor %p\n", i,
&ptr[i]);
printf("O valor do ndice %d do vetor %d\n", i,
ptr[i]);
}
return 0;
}
ProgC - Ponteiros 50
Ponteiros e Vetores (Arrays)

C trata ponteiros e vetores da mesma forma

Assim, so equivalentes (programa anterior)

Teste cada um deles e confira a equivalncia!

vetor[i]; //acesso padro vetor
ptr[i];
*(vetor + i); //acesso padro ponteiro
*(ptr + i);
printf("O valor do ndice %d do vetor %d\n", i, vetor[i]);
...
printf("O valor do ndice %d do vetor %d\n", i, *(ptr+i));
ProgC - Ponteiros 51
Ponteiros e Vetores (Arrays)

O programa seguinte verifica quantos elementos

esto no vetor antes que aparea um 0

No usa ponteiros de forma explcita

#include <stdio.h>
int array[] = {4, 5, 8, 9, 8, 1, 0, 1, 9, 3};
int indice;
int main()
{
indice = 0;
while (array[indice] != 0) {
++indice;
}
printf("Numero de elementos antes de zero %d\n", indice);
return (0);
}
ProgC - Ponteiros 52
Ponteiros e Vetores (Arrays)

E este o equivalente, usando ponteiros

Verifique como funciona

#include <stdio.h>
int array[] = {4, 5, 8, 9, 8, 1, 0, 1, 9, 3};
int *array_ptr;
int main()
{
array_ptr = array;
while ((*array_ptr) != 0) {
++array_ptr;
}
printf("Numero de elementos antes do zero %d\n", array_ptr -
array);
return (0);
}
ProgC - Ponteiros 53
Exemplo de Uso de Ponteiros

Suponha que um nome esteja na forma Silva/

Maria

Deseja-se separ-lo em duas partes

(sobrenome e nome)
ProgC - Ponteiros 54
Exemplo de Uso de Ponteiros

Como a barra o separador, temos que

procur-la dentro da string de entrada
while (*string_ptr != caracter_procurar) {

Dentro do lao, verificar se a string acabou e

no encontramos a barra,
if (*string_ptr == '\0')
return(NULL);
++string_ptr;
}
return(string_ptr); //aqui estar a posio do
caracter procurado
ProgC - Ponteiros 55
Exemplo de Uso de Ponteiros

Depois de descobrir a posio da barra, falta

separar as strings
ProgC - Ponteiros 56
Exemplo de Uso de Ponteiros

Funo est no arquivo split_nome.c

A funo strchr da biblioteca padro string.h

faz isso, mas aqui foi usada uma verso
prpria para fins didticos
ProgC - Ponteiros 57
Cuidados no Uso de Ponteiros

Em C, fcil escrever cdigo que seja difcil de

entender

Isso deve ser evitado

Nem sempre ter um cdigo compacto a

melhor soluo

Legibilidade deve ser prioritria

ProgC - Ponteiros 58
Cuidados no Uso de Ponteiros

No escreva programas assim (preced1.c)

#include <stdio.h>
int array[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int main() {
int *data_ptr;
int valor;
data_ptr = &array[0];
printf("0. data_ptr aponta = %p\n", data_ptr);
valor = *data_ptr++;
printf("1. valor = %d\n", valor);
printf("1. data_ptr aponta = %p\n", data_ptr);
valor = *++data_ptr;
printf("2. valor = %d\n", valor);
printf("2. data_ptr aponta = %p\n", data_ptr);
valor = ++*data_ptr;
printf("3. valor = %d\n", valor);
printf("3. data_ptr aponta = %p\n", data_ptr);
return(0);
}
ProgC - Ponteiros 59
Cuidados no Uso de Ponteiros
ProgC - Ponteiros 60
Cuidados no Uso de Ponteiros

O resultado depende da precedncia dos

operadores

Para ficar mais claro, usar parnteses

Parnteses tm precedncia maior

Mas verificar os programas

preced1-ponteiros.c

preced2-ponteiros.c
ProgC - Ponteiros 61
Cuidados com ponteiros

Wild pointer: ponteiro no inicializado

aponta para endereo possivelmente invlido

j vimos exemplos

Dangling pointer: aponta para memria

desalocada

Um dos bugs mais complicados de encontrar

Porque, em um primeiro momento, o comportamento

pode ser ok

Mais em
http://en.wikipedia.org/wiki/Dangling_pointer
ProgC - Ponteiros 62
Cuidados com ponteiros
#include <stdio.h>
int* funcao(void) {
int num = 1234;
printf("O endereo de num: %p\n", &num);
printf("O valor de num: %d\n", num);
return &num;
}
int main(void) {
int *ptr;
ptr=funcao();
printf("O endereo apontado por ptr: %p\n", ptr);
printf("O valor apontado por ptr: %d\n", *ptr); //
aqui j virou lixo, porque num est fora de escopo
return(0);
}
ProgC - Ponteiros 63
Cuidados com ponteiros
#include <stdio.h>
int main(void) {
int *ptr;
{
int num=21; //escopo de num dentro deste bloco
ptr=&num;
printf("O endereo apontado por ptr: %p\n", ptr);
printf("O valor apontado por ptr: %d\n", *ptr);
}
//num saiu de escopo
printf("O endereo apontado por ptr: %p\n", ptr);
printf("O valor apontado por ptr: %d\n", *ptr); //
embora possa mostrar um num. ainda vlido, um
problema em potencial
return(0);
}
ProgC - Ponteiros 64
Cuidados com ponteiros
#include <stdio.h>
int main(void) {
char frase[6]="12345";
char *ptr=frase;
printf("caractere[0]=%c\n", *ptr);
ptr++;
printf("caractere[1]=%c\n", *ptr);
ptr+=3;
*ptr='A';
printf("caractere[4]=%c\n", *ptr);
ptr++;
printf("caractere[5]=%x\n", *ptr);//final da string (\0)
ptr++;//saiu da "frase"
*ptr='F';//est acessando endereo fora da string
printf("caractere fora=%c\n", *ptr);
printf("frase=%s\n", frase);
return 0;
}
ProgC - Ponteiros 65
SADA DO DEBUGGER (gdb)
Breakpoint 1, main () at ponteiro-fora-escopo3.c:3
3 char frase[6]="12345";
4 char *ptr=frase;
6 printf("caractere[0]=%c\n", *ptr);
(gdb) print &frase
$1 = (char (*)[6]) 0xbf99964a
(gdb) x/8cb 0xbf99964a
0xbf99964a: 49 '1' 50 '2' 51 '3' 52 '4' 53
'5' 0 '\0' 74 'J' -106 '\226'
7 ptr++;
8 printf("caractere[1]=%c\n", *ptr);
9 ptr+=3;
10 *ptr='A';
11 printf("caractere[4]=%c\n", *ptr);
12 ptr++;
ProgC - Ponteiros 66
SADA DO DEBUGGER (gdb) (continuao)
13 printf("caractere[5]=%x\n", *ptr);
(gdb) x/8cb 0xbf99964a
0xbf99964a: 49 '1' 50 '2' 51 '3' 52 '4' 65
'A' 0 '\0' 79 'O' -106 '\226'
14 ptr++;//saiu da "frase"
15 *ptr='F';//est acessando endereo invlido
16 printf("caractere fora=%c\n", *ptr);
17 printf("frase=%s\n", frase);
(gdb) x/8cb 0xbf99964a
0xbf99964a: 49 '1' 50 '2' 51 '3' 52 '4' 65
'A' 0 '\0' 70 'F' -106 '\226'
18 return 0;
19 }
ProgC - Ponteiros 67
Cuidados com ponteiros

Ver discusso em
http://stackoverflow.com/questions/2583656/what-is-the-meaning-of-wild-pointer-in-c
ProgC - Ponteiros 68
Ponteiros const

O que est definido como constante em cada

declarao?
const int result = 10;
const char *resposta_ptr = "Eletronica";
char *const nome_ptr = "IF-SC";
const char *const teste_ptr = "Florianopolis";
ProgC - Ponteiros 69
Ponteiros const

O que est definido como constante em cada

declarao?
const int result = 10; // result um inteiro e o valor
no pode ser alterado
const char *resposta_ptr = "Eletronica"; // os dados
(char) so constantes, mas a varivel resposta_ptr, no.
//resposta_ptr um ponteiro que pode apontar para outro
endereo.
//os dados apontados por resposta_ptr so constantes.
char *const nome_ptr = "IF-SC"; // nome_ptr um ponteiro
que constante.
// os dados apontados por nome_ptr podem ser mudados.
const char *const teste_ptr = "Florianopolis"; //aqui,
nem os dados nem o ponteiro podem ser alterados.
ProgC - Ponteiros 70
Bibliografia e Crdito das Figuras

OUALLINE, S. Practical C Programming. 3. ed.

O'Reilly, 1997.

ARGOUD, F. I. M. Introduo Linguagem C (notas

de aula). Florianpolis, 2009.

http://home.netcom.com/~tjensen/ptr/pointers.htm

http://br.geocities.com/cesarakg/pointers.html

http://pt.wikibooks.org/wiki/Programar_em_C/Ponteiros

http://www.difranco.net/cop2220/op-prec.htm