Você está na página 1de 16

Universidade de Brasília

Departamento de Ciência da Computação

Curso C: Estruturas
Prof. Ricardo Pezzuol Jacobi rjacobi@cic.unb.br

Linguagem C

Ricardo Jacobi

Estruturas
¥ Struct s‹o cole•›es de dados heterog•neos agrupados em uma mesma estrutura de dados ¥ Ex:
armazenas as coordenadas (x,y) de um ponto:
(x, y)

Linguagem C

Ricardo Jacobi

1

p2. } lista_de_variaveis. tipo_2 dado_2.. } p1. int y. ¥ A estrutura pode agrupar um nœmero arbitr‡rio de dados de tipos diferentes ¥ Pode-se nomear a estrutura para referencia-la Linguagem C Ricardo Jacobi 2 . tipo_n dado_n. y) struct { int x. .Estruturas ¥ Declara•‹o: (x. ¥ a estrutura contŽm dois inteiros. x e y ¥ p1 e p2 s‹o duas vari‡veis tipo struct contendo duas coordenadas cada.. Linguagem C Ricardo Jacobi Declaração ¥ Formato da declara•‹o: struct nome_da_estrutura { tipo_1 dado_1.

x = 10. /*atribuição */ p2. p2. } p2.y = 15.y >= p2.x) && (p1. struct ponto p1. struct { int x. Linguagem C Ricardo Jacobi 3 .. }.y) . int y.x >= p2. • Pode-se definir novas variáveis do tipo ponto Ricardo Jacobi Linguagem C Estruturas ¥ acesso aos dados: struct-var. } p1.campo ¥ Ex: p1.. int y. if (p1. int y.Nomeando uma Estrutura struct { int x. • struct ponto define um novo tipo de dado Repetição struct ponto { int x.

110 }.nome == “Afranio” Linguagem C Ricardo Jacobi 4 . a2. } a1. p2 = p1. ¥ Agora a1 e a2 apontam para o mesmo string nome: a1.x = p1. int idade. ¥ Atribui•‹o entre estruturas do mesmo tipo: struct ponto p1 = { 220. 110 }. a1.Atribuição de Estruturas ¥ Inicializa•‹o de uma estrutura: struct ponto p1 = { 220.nome = “Afranio”. a2 = a1.nome == a2. struct ponto p2.idade = 32.x = p1. /* p2.y */ ¥ Os campos correspondentes das estruturas s‹o automaticamente copiados do destino para a fonte Linguagem C Ricardo Jacobi Atribuição de Estruturas ¥ Aten•‹o para estruturas que contenham ponteiros: struct aluno { char *nome.x e p2. a1.

Composição de Estruturas struct retangulo { struct ponto inicio. struct retangulo r = { { 10. 40 } }. tmp.y -= 10.inicio. r.y = y. struct ponto fim. ¥ Acesso aos dados: r. } Linguagem C Ricardo Jacobi 5 . }. 20). return tmp.inicio. tmp. 20 }. Linguagem C Ricardo Jacobi Estruturas como parâmetros struct ponto cria_ponto (int x. int y) { struct ponto tmp. } main () { struct ponto p = cria_ponto(10. { 30 .x = x.x += 10.

20 }.x += p2. Linguagem C Ricardo Jacobi 6 . struct ponto p1 = { 10. p1.x.y}. printf(“Ponto P1: (%d %d)\n”. ¥ acesso via operador Ò->Ó: printf(“Ponto P1: (%d %d)\n”.y += p2.x. return p1. struct ponto p2) { p1.y. (*pp). pp->y}. pp->x.Operações ¥ opera•›es entre membros das estruturas devem ser feitas membro a membro: /* retorna uma cópia de p1 = p1 + p2 */ struct soma_pts (struct ponto p1. pp = &p1. (*pp). } /* retorna uma copia de p1 */ Linguagem C Ricardo Jacobi Ponteiros para Estruturas ¥ estruturas grandes s‹o passadas como par‰metro de forma mais eficiente atravŽs de ponteiros struct ponto *pp.

. char matricula[8]. strcpy(al. struct jogador Brasil[11] = { “Felix”. 32. /*atribui 5 a coordenada x do 2¼ ponto */ struct jogador { char *nome. /* cria um array de 10 pontos */ arp[1].matricula. .idade = 30. }. int idade. “00/0000” al. Linguagem C Ricardo Jacobi Espaço Alocado para um Estrutura struct aluno { char *nome. }. 30 al. /* ponteiro 4 bytes */ /* 2 bytes */ /* array 8 bytes */ struct aluno al * struct aluno al. “Xexeo” Linguagem C Ricardo Jacobi 7 .nome = “Xexeo”. “Carlos Alberto”. 24. }.. “00/0001”).x = 5. short idade.Arrays de Estruturas struct ponto arp[10].

PowerPC 603 . /* sizeof(aluno) bytes */ bytes */ bytes */ = 12 bytes */ Linguagem C Ricardo Jacobi 8 . /* 3 }. /* 2 char matricula[3].Função sizeof(tipo) ¥ A fun•‹o sizeof(tipo) retorna o tamanho em bytes ocupado em mem—ria pelo tipo de dado passado como par‰metro ¥ Ex: sizeof(int) sizeof(char) sizeof(struct ponto) sizeof(struct ponto *) => => => => 4 1 8 4 bytes byte bytes bytes Ricardo Jacobi Linguagem C Espaço Efetivo /* teste com Symantec C.Macintosh */ struct aluno { char *nome. /* 4 short idade.

char matricula[5]. /* 4 bytes */ /* 2 bytes */ /* 5 bytes */ /* sizeof(aluno1) = 12 bytes */ Linguagem C Ricardo Jacobi Espaço Efetivo /* teste com Symantec C. /* 4 bytes short idade. /* 2 bytes char matricula[7]. short idade. PowerPC 603 . PowerPC 603 .Macintosh */ struct aluno1 { char *nome.Espaço Efetivo /* teste com Symantec C. /* 7 bytes }. }. /* sizeof(aluno2) = 16 */ */ */ bytes */ ¥ no PowerMac uma estrutura Ž um mœltipo do tamanho da palavra. 32 bits Linguagem C Ricardo Jacobi 9 .Macintosh */ struct aluno2 { char *nome.

/* calloc retorna um ponteiro para um array com n elementos de tamanho size cada um ou NULL se não houver memória disponível.Alocação Dinâmica de Memória ¥ as fun•›es calloc e malloc permitem alocar blocos de mem—ria em tempo de execu•‹o void * malloc(size_t n). Se não há memória disponível malloc retorna NULL */ Linguagem C Ricardo Jacobi Alocação Dinâmica de Memória void * calloc(size_t n. size_t size). número de bytes alocados /* retorna um ponteiro void para n bytes de memória não iniciados. Os elementos são iniciados em zero */ ¥ o ponteiro retornado por malloc e calloc deve ser convertido para o tipo de ponteiro que invoca a fun•‹o: Linguagem C Ricardo Jacobi 10 .

.. free(pi). /* aloca espaço para um inteiro */ int *ai = (int *) calloc (n.. } ¥ pr—ximo aponta para uma estrutura do mesmo tipo Linguagem C Ricardo Jacobi 11 . Linguagem C /* libera todo o array */ /* libera o inteiro alocado */ Ricardo Jacobi Estrutras Autoreferenciadas ¥ ƒ poss’vel definir dentro de uma estrutura um ponteiro para a pr—pria estrutura: struct Qualquer { tipo_dado_1 dado_1. /* aloca espaço para um array de n inteiros */ ¥ toda mem—ria n‹o mais utilizada deve ser liberada atravŽs da fun•‹o free(): free(ai). struct Qualquer *proximo.Alocação Dinâmica de Memória int *pi = (int *) malloc (sizeof(int)). sizeof(int)).

pnode->proximo = NULL . struct IntNode *proximo. pnode = (IntNode *)malloc(sizeof(IntNode)). 7 0 Linguagem C raiz Ricardo Jacobi Lista de Inteiros ¥ Inserindo elementos na lista: IntNode *pnode.Lista de Inteiros ¥ Exemplo: lista encadeada de inteiros. raiz->proximo = NULL. raiz = (IntNode *)malloc(sizeof(IntNode)). /*terminador de lista*/ raiz->proximo = pnode. } *raiz. raiz Ž um ponteiro para o primeiro nodo da lista. 7 * 11 0 Ricardo Jacobi raiz Linguagem C 12 . pnode->dado = 11. struct IntNode { int dado. raiz->dado = 7.

pi->proximo = pinicio. IntNode *pnode. pi=(struct IntNode *)malloc(sizeof(struct IntNode)). struct IntNode *pinicio) { struct IntNode *pi. } Linguagem C Ricardo Jacobi 13 . while (pnode != NULL) { printf(“%d “. pnode = pnode->proximo. } return pi.. pnode = raiz.Percorrendo a Lista ¥ Percorre-se uma lista encadeada por meio de um ponteiro: . if (pi) { pi->dado = i. } Linguagem C Ricardo Jacobi Insere Nodo struct IntNode *insere_int (int i. pnode->dado)..

/* variavel global */ Linguagem C Ricardo Jacobi 14 . pi = pi->proximo. struct aluno *prox. char matricula[8]. struct aluno *ListaAlunos. short idade.Print Lista void print_list (struct IntNode *pi) { printf("\nLista = "). while (pi) { printf (" %d ". }. pi->dado). } } Linguagem C Ricardo Jacobi Lista de Alunos struct aluno { char *nome.

“0001/90”). insere_aluno(“Genoveva”.Insere Aluno int insere_aluno (char *n. 97. pa->prox = ListaAlunos. “0002/90”). pa->idade = id. pa->nome = n. ListaAlunos = pa. strcpy(pa->matricula. short id. insere_aluno(“Abriola”. 62. “0007/66”). } Linguagem C Ricardo Jacobi Criação Lista Alunos void main () { insere_aluno(“Castor”. 56. char *m) { struct aluno *pa. m). pa = (struct aluno *)malloc(sizeof(struct aluno)). } lista Abriola Genoveva Castor * 97 0007/66 * * 62 0002/90 * * 56 0001/90 0 Linguagem C Ricardo Jacobi 15 .

} } Linguagem C Ricardo Jacobi 16 . imprimeRec (lista->prox). } } Linguagem C Ricardo Jacobi Impressão Recursiva void imprimeRec ( aluno *lista ) { if ( lista != NULL ) { printf (“Aluno: %s \n”.Esvaziando a Lista /* esvazia a lista */ void esvazia_lista () { struct aluno *tmp. ListaAlunos = lista->prox. while (ListaAlunos != NULL) { tmp = ListaAlunos . lista->nome). free(tmp).