Capitulo11 Estruturas

Elementos de programao em C
Estruturas e unies
Francisco A. C. Pinheiro, Elementos de Programao em C, Bookman, 2012.
Visite os stios do livro para obter material adicional: www.bookman.com.br e www.facp.pro.br/livroc
() Elementos de programao em C 1 / 36
Sumrio
1 Declarao de estruturas
2 Referenciando os componentes
3 Estruturas com componente flexvel
4 Vetores de estruturas
5 Iniciando estruturas
6 Declarao de unies
7 Referenciando os componentes
8 () Elementos de programao em C 2 / 36
Declarao de estruturas
As estruturas so declaradas atravs de variveis do tipo estrutura que
especifica os seus componentes.
As estruturas so declaradas atravs de variveis do tipo estrutura que
especifica os seus componentes.
Exemplo
Para o tipo estrutura ao lado as struct {
seguintes declaraes so int matr ;
possveis: float nota1 ;
float nota2 ;
}
struct { struct r_aluno { typedef struct {

int matr ; int matr ; int matr ;
float nota1 ; float nota1 ; float nota1 ;
float nota2 ; float nota2 ; float nota2 ;
} aluno , } aluno ; } tp_r_aluno ;
aluno_regular ; struct r_aluno tp_r_aluno aluno ,
aluno_regular , aluno_regular ;
alun o_espe cial ;
Referenciando os componentes
Operador de seleo direta
hOpSelecaoDiretai ::= hIdEstruturai . hIdComponentei
hIdEstruturai ::= Identificador da estrutura, geralmente uma varivel de

tipo estrutura.
hIdComponentei ::= Identificador do componente.
Operador de seleo direta
hOpSelecaoDiretai ::= hIdEstruturai . hIdComponentei
hIdEstruturai ::= Identificador da estrutura, geralmente uma varivel de

tipo estrutura.
Exemplo
aluno.nota1 Componente nota1 da estrutura armazenada em aluno.
aluno.matr Componente matr da mesma estrutura.
Operador de seleo indireta
hOpSelecaoIndiretai ::= hPtrEstruturai -> hIdComponentei
hPtrEstruturai ::= Varivel do tipo ponteiro para estrutura.
Operador de seleo indireta
hOpSelecaoIndiretai ::= hPtrEstruturai -> hIdComponentei
hPtrEstruturai ::= Varivel do tipo ponteiro para estrutura.
Exemplo
ptr_aluno->nota1 Componente nota1 da estrutura apontada
por ptr_aluno.
ptr_aluno->matr Componente matr da mesma estrutura.
Usando estruturas como valor de retorno e argumento
Exemplo
O programa ao lado l # include < stdio .h >
os dados de um aluno, struct r_aluno {
armazenando-os em int matr ;
float nota1 ;
uma estrutura e float nota2 ;
imprimindo-os em };
struct r_aluno ler_aluno ( void );
seguida. void imp_aluno ( struct r_aluno );
int main ( void ) {
struct r_aluno aluno = ler_aluno ();
imp_aluno ( aluno );
return 0;
}
continua...
Usando estruturas como valor de retorno e argumento

Exemplo
...continuao
struct r_aluno ler_aluno ( void ) {
struct r_aluno al ;
printf (" Digite os dados do aluno \ n ");
printf (" Matricula : ");
scanf ("% d " , & al . matr );
printf (" Primeira nota : ");
scanf ("% f " , & al . nota1 );
printf (" Segunda nota : ");
scanf ("% f " , & al . nota2 );
return al ;
}
void imp_aluno ( struct r_aluno al ) {
printf (" Matr : % d Notas : %5.2 f %5.2 f " ,
al . matr , al . nota1 , al . nota2 );
printf (" Media : %5.2 f \ n " ,
( al . nota1 + al . nota2 ) / 2);
}
Ponteiros para estruturas
Exemplo
O programa ao lado # include < stdio .h >
modifica o exemplo struct r_aluno {
anterior, usando um int matr ;
float nota1 ;
ponteiro para a float nota2 ;
estrutura aluno. };
void ler_aluno ( struct r_aluno *);
void imp_aluno ( struct r_aluno *);
int main ( void ) {
struct r_aluno aluno ;
ler_aluno (& aluno );
imp_aluno (& aluno );
return 0;
}
continua...
Exemplo
...continuao
void ler_aluno ( struct r_aluno * al ) {
printf (" Digite os dados do aluno \ n ");
printf (" Matricula : ");
scanf ("% d " , & al - > matr );
scanf ("% f " , & al - > nota1 );
scanf ("% f " , & al - > nota2 );
}
void imp_aluno ( struct r_aluno * al ) {
al - > matr , al - > nota1 , al - > nota2 );
( al - > nota1 + al - > nota2 ) / 2);
}
O contedo do endereo apontado por um ponteiro para estrutura a

prpria estrutura.
Se al um ponteiro para uma estrutura, ento *al a prpria

estrutura apontada por al.
Exemplo
Considerando que al um ponteiro para a estrutura aluno dos exemplos
anteriores, o que representam as expresses a seguir?
&(*al)
al->nota1
(*al).nota1
(&(*al))->nota1
&(*al).nota1
&((*al).nota1).
*al.nota1
Exemplo
&(*al) Endereo da estrutura armazenada no endereo

apontado por al. Isto , &(*al) = al.
al->nota1
(*al).nota1
(&(*al))->nota1
&(*al).nota1
&((*al).nota1).
*al.nota1
Exemplo

al->nota1 Componente nota1 da estrutura apontada por al.
(*al).nota1
(&(*al))->nota1
&(*al).nota1
&((*al).nota1).
*al.nota1
Exemplo

(*al).nota1 Componente nota1 da estrutura *al.
(&(*al))->nota1
&(*al).nota1
&((*al).nota1).
*al.nota1
Exemplo

(&(*al))->nota1 Componente nota1 da estrutura
cujo endereo &(*al).
&(*al).nota1
&((*al).nota1).
*al.nota1
Exemplo

&(*al).nota1 Endereo do componente nota1 da estrutura *al.
&((*al).nota1).
*al.nota1
Exemplo

&((*al).nota1). Endereo do componente nota1 da estrutura *al.
*al.nota1
Exemplo

&((*al).nota1). Endereo do componente nota1 da estrutura *al.
*al.nota1 Expresso invlida.
Estruturas com componente flexvel
O ltimo componente de uma estrutura contendo mais de um

componente nomeado pode ser de um tipo vetor incompleto.
componente (vetor) flexvel.
Antes do uso deve haver alocao explcita de espao em memria
para armazenar os elementos do vetor.
O tamanho de um tipo estrutura com componente flexvel o mesmo
que se o componente no existisse.
Exemplo
No programa ao lado # include < stdio .h >
a estrutura apontada # include < stdlib .h >
pela varivel reg_a struct r1 {
int matr ;
alocada com 4 int vendas_mes [];
elementos para o vetor };
int main ( void ) {
vendas_mes. struct r1 * reg_a ;
reg_a = ( struct r1 *) malloc (
sizeof ( struct r1 ) + sizeof ( int [4]));
for ( int i = 0; i < 4; i ++) {
printf ("% d \ n " , reg_a - > vendas_mes [ i ]);
}
return 0;
}
Vetores de estruturas
Um vetor de estruturas um vetor cujos elementos so de um tipo

estrutura.
Exemplo
struct { typedef struct {
int matr ; int matr ;
float nota1 ; float nota1 ;
float nota2 ; float nota2 ;
} v_alunos [20]; } tp_r_aluno ;
tp_r_aluno v_alunos [20];
Exemplo. O programa # include < stdio .h >
ao lado usa um vetor # define QTD_AL (10)
de estruturas para struct r_aluno {
int matr ;
armazenar (e float nota1 ;
imprimir) os dados de float nota2 ;
};
dez alunos. void imp_alunos ( struct r_aluno []);
int main ( void ) {
struct r_aluno v_alunos [ QTD_AL ];
printf (" Digite os dados dos % d alunos \ n " ,
QTD_AL );
for ( int i = 0; i < QTD_AL ; i ++) {
printf (" Matricula % d : " , ( i + 1));
scanf ("% d " , & v_alunos [ i ]. matr );
scanf ("% f " , & v_alunos [ i ]. nota1 );
scanf ("% f " , & v_alunos [ i ]. nota2 );
}
continua...
Exemplo. imp_alunos ( v_alunos );

continuao... return 0;
}
void imp_alunos ( struct r_aluno al []) {
for ( int i = 0; i < QTD_AL ; i ++) {
al [ i ]. matr , al [ i ]. nota1 , al [ i ]. nota2 );
( al [ i ]. nota1 + al [ i ]. nota2 ) / 2);
}
}
Exemplo
Para o vetor v_alunos ao lado, o que struct r_aluno {
representam as seguintes expresses? int matr ;
float nota1 , nota2 ;
} v_alunos [1000];
v_alunos
*(v_alunos + 2)
&v_alunos[2]
v_alunos[2].matr
(*v_alunos).matr
Exemplo
} v_alunos [1000];
v_alunos Ponteiro para a estrutura, apontando inicialmente

para o primeiro elemento.
*(v_alunos + 2)
&v_alunos[2]
v_alunos[2].matr
(*v_alunos).matr
Exemplo
} v_alunos [1000];

*(v_alunos + 2) Estrutura armazenada no elemento
apontado por (v_alunos + 2).
&v_alunos[2]
v_alunos[2].matr
(*v_alunos).matr
Exemplo
} v_alunos [1000];

&v_alunos[2] Endereo do terceiro elemento do vetor.
v_alunos[2].matr
(*v_alunos).matr
Exemplo
} v_alunos [1000];

v_alunos[2].matr Componente matr da estrutura armazenada

no terceiro elemento do vetor.
(*v_alunos).matr
Exemplo
} v_alunos [1000];

v_alunos[2].matr Componente matr da estrutura armazenada

no terceiro elemento do vetor.
(*v_alunos).matr Componente matr da estrutura armazenada no
elemento apontado por v_alunos.
Exemplo
Se pa aponta para o segundo elemento struct r_aluno {
do vetor ao lado, e sabendo que os int matr ;
operadores -> e . tm maior precedncia float nota1 , nota2 ;
} v_alunos [1000];
que ++, o que representam as seguintes
expresses?
pa++->matr
++pa->matr
++(pa->matr)
(++pa)->matr
Exemplo
} v_alunos [1000];
expresses?
pa++->matr Componente matr do segundo elemento.

Ponteiro incrementado.
++pa->matr
++(pa->matr)
(++pa)->matr
Exemplo
} v_alunos [1000];
expresses?

++pa->matr Componente matr do segundo elemento.
Componente incrementado.
++(pa->matr)
(++pa)->matr
Exemplo
} v_alunos [1000];
expresses?

++(pa->matr) Componente matr do segundo elemento.
(++pa)->matr
Exemplo
} v_alunos [1000];
expresses?

++(pa->matr) Componente matr do segundo elemento.
(++pa)->matr Componente matr do terceiro elemento.
Iniciando estruturas
As variveis do tipo estrutura podem ser iniciadas com uma relao de

iniciao.
Exemplo
struct {
int matr ;
float nota1 ;
float nota2 ;
} aluno = {130518 , 4.57 , 8.33 , 9.54} ,
aluno_regular = {234 , 7.65};
Iniciao seletiva e componentes agregados
A iniciao seletiva se faz indicando o componente com a notao

.hnome_componentei
Os componentes agregados podem ser especificados com chaves.
Exemplo
struct {
int matr ;
struct {
char sexo ;
int rg ;
} sit ;
float nota1 ;
float nota2 ;
} reg_a = {1111 , m , 715 , 8.54 , 5.73} ,
reg_b = {2222 , f } ,
reg_c = {. sit = { f , 32} , 215.3} ,
reg_d = {3333 , { m , 234} , 86.44};
Iniciao com literais compostos
As variveis automticas podem ser iniciadas com literais compostos.
Exemplo
struct r_aula {
char topico [20];
int ini ;
int fim ;
} aula =
( struct r_aula ){" Programacao " , 10 , 12};
Declarao de unies
Declarao de unies
As unies so declaradas por meio do tipo unio que especifica os seus

componentes.
Declarao de unies
Declarao de unies
As unies so declaradas por meio do tipo unio que especifica os seus

componentes.
Exemplo
Para o tipo unio ao lado as union {
seguintes declaraes so unsigned int regra ;
possveis: char norma ;
}
union { union doc_id { typedef union {

unsigned int unsigned int unsigned int
regra ; regra ; regra ;
char norma ; char norma ; char norma ;
} id ; }; } tp_doc_id ;
union doc_id id ; tp_doc_id id ;
Referenciando os componentes de uma unio
Os componentes de uma unio so referidos do mesmo modo que os

componentes de uma estrutura:
Por meio do operador de seleo direta
Por meio do operador de seleo indireta
Usando os componentes apropriados
O valor de uma unio deve ser acessado atravs do componente

utilizado para armazen-lo.
O comportamento indefinido se o valor de uma unio acessado com
um componente diferente do componente usado para armazen-lo.
Exemplo
Para a unio ao lado, aps a atribuio union u {
tst.num = 23, as expresses a seguir tm o int num ;
significado descrito: char texto [20];
} tst ;
printf("%d", tst.num) Correto: imprime o contedo da varivel

tst como um valor do tipo int.
printf("%s", tst.texto) Errado: imprime o contedo da varivel
tst como um valor do tipo char [20].
printf("%d", tst) Inapropriado: imprime o contedo da
varivel tst, convertendo-o do tipo
union u em um valor do tipo int.
Exemplo
Em cada impresso # include < stdio .h >
do programa ao lado union r {
apenas um valor est float a ;
double b ;
corretamente int c ;
referenciado. } tst ;
int main ( void ) {
tst . a = 34.5;
printf ("% g % g % d \ n " , tst .a , tst .b , tst . c );
tst . b = 34.5;
tst . c = 34.5;
return 0;
}
O programa produz a seguinte sada: 34.5 5.47401e-315 1107951616

0 34.5 0
4.76441e-44 34.5 34
Unies como componentes de estruturas
comum usar unies como componentes de estruturas, juntamente com

um outro componente indicando como a unio deve ser interpretada.
Exemplo
union doc_id { struct r_doc { typedef union {
unsigned int char tipo ; unsigned int
regra ; union { regra ;
char norma ; unsigned int char norma ;
}; regra ; } tp_id ;
struct r_doc { char norma ; struct r_doc {
char tipo ; } id ; char tipo ;
union doc_id id ; char * resumo ; tp_id id ;
char * resumo ; }; char * resumo ;
}; };

Exemplo. O programa # include < stdio .h >
ao lado l o tipo e a typedef union {
identificao de um unsigned int regra ;
char norma ;
documento. Existem } tp_id ;
dois formatos para a struct r_doc {
char tipo ;
identificao, variando tp_id id ;
de acordo com o tipo. char * resumo ;
};
Ambos so void obtem_id ( tp_id * , char );
armazenados em uma void imp_doc ( struct r_doc *);
mesma varivel do void limpa_linha ( void );
int main ( void ) {
tipo unio. struct r_doc doc ;
printf (" Digite o tipo de documento : ");
doc . tipo = getchar ();
continua... limpa_linha ();
obtem_id (& doc . id , doc . tipo );
imp_doc (& doc );
return 0;
}
...continuao, void obtem_id ( tp_id * id , char tipo ) {

if ( tipo == r ) {
printf (" id regra ( numerico ): ");
scanf ("% u " , & id - > regra );
} else {
if ( tipo == n ) {
printf (" id norma ( char ): ");
scanf ("% c " , & id - > norma );
}
continua... }
}
...continuao. void imp_doc ( struct r_doc * d ) {

printf (" tipo : % c id : " , d - > tipo );
if (d - > tipo == r ) {
printf ("% u \ n " , d - > id . regra );
} else {
if (d - > tipo == n ) {
printf ("% c \ n " , d - > id . norma );
} else {
printf (" tipo invalido \ n ");
}
}
}
void limpa_linha () {
while ( getchar () != \n ) { };
}
Iniciando unies
Iniciando unies
As unies so explicitamente iniciadas com o valor correspondente ao seu

primeiro componente especificado entre chaves, podendo haver a iniciao
seletiva, indicando-se um componente especfico da unio.
Iniciando unies
Iniciando unies
As unies so explicitamente iniciadas com o valor correspondente ao seu

primeiro componente especificado entre chaves, podendo haver a iniciao
seletiva, indicando-se um componente especfico da unio.
Exemplo
Para a declarao de tipo ao lado, union doc_id {
unsigned int regra ;
char norma ;
};
Iniciao Corresponde a
union doc_id id = {1234}; id.regra = 1234;
union doc_id id = {t}; id.regra = t;
union doc_id id = {.norma = t}; id.norma = t;
Campos de bits
Campos de bits
Define componentes de tipo inteiro com uma quantidade limitada de
bits.
O tipo de um campo de bits deve ser
_Bool,
signed int,
unsigned int, ou
algum outro tipo dependente da implementao.
O tipo int ser implementado como signed int ou unsigned int,
dependendo da implementao.
Campos de bits
Campos de bits
Define componentes de tipo inteiro com uma quantidade limitada de
bits.
O tipo de um campo de bits deve ser
_Bool,
signed int,
unsigned int, ou
algum outro tipo dependente da implementao.
O tipo int ser implementado como signed int ou unsigned int,
dependendo da implementao.
Exemplo
A estrutura ao lado usa dois campos de struct r_arq {
bits. char id [9];
_Bool grv : 1;
unsigned int perm : 3;
}
Campos de bits
Campos de bits
So altamente dependentes da implementao:

No podem ser acessados com o operador de endereo (&).
Podem ser no-nomeados.
Os campos no-nomeados podem ser especificados com zero bits.
Um campo de bits pode ser alocado na mesma unidade de
armazenamento que o campo precedente, ou no.
O uso de um campo com 0 bits faz com que o prximo no seja
alocado na mesma unidade que o campo precedente.
Compatibilidade de estruturas e unies
Duas estruturas ou unies (declaradas em diferentes unidades de

compilao) so compatveis se
1 possuem a mesma etiqueta.
2 Adicionalmente, se os tipos so completos, deve existir uma
correspondncia entre os seus componentes tal que os componentes
correspondentes devem
ser declarados na mesma ordem (apenas para estruturas);
ter tipos compatveis;
ter nomes iguais (se forem nomeados); e
ser do mesmo tamanho (se forem campos de bits).

Exemplo
A compilao do seguinte programa gera um executvel com
comportamento indefinido.
prgA.c prgB.c
# include < stdio .h > # include < stdio .h >

void fun ( void ); struct s1 {
struct s1 { int a , b ;
int a ; char c ;
int b ; };
}; struct s1 var2 = {111 , 222 , s };
struct s1 void fun ( void ) {
var1 = {33 , 44}; printf ("% d % d % c \ n " , var2 .a , var2 .b ,
struct s1 var2 ; var2 . c );
int main ( void ) { }
var2 = var1 ;
fun ();
return 0;
}
Bibliografia
Bibliografia
ISO/IEC
C Programming Language Standard
ISO/IEC 9899:2011, International Organization for Standardization;
International Electrotechnical Commission, 3rd edition, WG14/N1570
Committee final draft, abril de 2011.
Francisco A. C. Pinheiro
Elementos de programao em C
Bookman, Porto Alegre, 2012.
www.bookman.com.br, www.facp.pro.br/livroc

Capitulo11 Estruturas

Diunggah oleh

Informasi Dokumen

Judul Asli

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

Capitulo11 Estruturas

Diunggah oleh

Hak Cipta:

Format Tersedia

Elementos de programao em C

Francisco A. C. Pinheiro, Elementos de Programao em C, Bookman, 2012.

Visite os stios do livro para obter material adicional: www.bookman.com.br e www.facp.pro.br/livroc

3 Estruturas com componente flexvel

struct { struct r_aluno { typedef struct {

Operador de seleo direta

hOpSelecaoDiretai ::= hIdEstruturai . hIdComponentei

hIdEstruturai ::= Identificador da estrutura, geralmente uma varivel de

hIdComponentei ::= Identificador do componente.

Operador de seleo direta

hOpSelecaoDiretai ::= hIdEstruturai . hIdComponentei

hIdEstruturai ::= Identificador da estrutura, geralmente uma varivel de

hIdComponentei ::= Identificador do componente.

Operador de seleo indireta

hOpSelecaoIndiretai ::= hPtrEstruturai -> hIdComponentei

hPtrEstruturai ::= Varivel do tipo ponteiro para estrutura.

hIdComponentei ::= Identificador do componente.

Operador de seleo indireta

hOpSelecaoIndiretai ::= hPtrEstruturai -> hIdComponentei

hPtrEstruturai ::= Varivel do tipo ponteiro para estrutura.

hIdComponentei ::= Identificador do componente.

Usando estruturas como valor de retorno e argumento

Usando estruturas como valor de retorno e argumento

Ponteiros para estruturas

Ponteiros para estruturas

Ponteiros para estruturas

O contedo do endereo apontado por um ponteiro para estrutura a

Se al um ponteiro para uma estrutura, ento *al a prpria

Ponteiros para estruturas

Ponteiros para estruturas

&(*al) Endereo da estrutura armazenada no endereo

Ponteiros para estruturas

&(*al) Endereo da estrutura armazenada no endereo

Ponteiros para estruturas

&(*al) Endereo da estrutura armazenada no endereo

Ponteiros para estruturas

&(*al) Endereo da estrutura armazenada no endereo

Ponteiros para estruturas

&(*al) Endereo da estrutura armazenada no endereo

Ponteiros para estruturas

&(*al) Endereo da estrutura armazenada no endereo

Ponteiros para estruturas

&(*al) Endereo da estrutura armazenada no endereo

Estruturas com componente flexvel

O ltimo componente de uma estrutura contendo mais de um

Estruturas com componente flexvel

Um vetor de estruturas um vetor cujos elementos so de um tipo

Exemplo. imp_alunos ( v_alunos );

v_alunos Ponteiro para a estrutura, apontando inicialmente

v_alunos Ponteiro para a estrutura, apontando inicialmente

v_alunos Ponteiro para a estrutura, apontando inicialmente

v_alunos Ponteiro para a estrutura, apontando inicialmente

v_alunos[2].matr Componente matr da estrutura armazenada

v_alunos Ponteiro para a estrutura, apontando inicialmente

v_alunos[2].matr Componente matr da estrutura armazenada

pa++->matr Componente matr do segundo elemento.

pa++->matr Componente matr do segundo elemento.

pa++->matr Componente matr do segundo elemento.

pa++->matr Componente matr do segundo elemento.

As variveis do tipo estrutura podem ser iniciadas com uma relao de

Iniciao seletiva e componentes agregados

A iniciao seletiva se faz indicando o componente com a notao

Iniciao com literais compostos