Plano de Aula Segunda-feira Tarde 13/10/2014 Objetivo: Introduzir o conceito de alocação dinâmica na memória e registros / structs.

Transcrição

1 Instituto Federal de Santa Catarina - Câmpus Chapecó Ensino Médio Integrado em Informática - Módulo IV Unidade Curricular: Programação Estruturada Professora: Lara Popov Zambiasi Bazzi Oberderfer Plano de Aula Segunda-feira Tarde 13/10/2014 Objetivo: Introduzir o conceito de alocação dinâmica na memória e registros / structs. Metodologia: Explicar junto com a turma o desenvolvimento dos seguintes exercícios (a). Após cada exercício, os alunos poderão treinar com um exercício semelhante (b). 1. Alocação Dinâmica na Memória As declarações abaixo alocam memória para diversas variáveis. A alocação é estática, pois acontece antes que o programa comece a ser executado: char c; int i; int v[10]; Às vezes, a quantidade de memória a alocar só se torna conhecida durante a execução do programa. Para lidar com essa situação é preciso recorrer à alocação dinâmica de memória. A alocação dinâmica é gerenciada pelas funções malloc e free, que estão na biblioteca stdlib. Para usar esta biblioteca, é preciso dizer #include <stdlib.h> no início do programa. Função malloc A função malloc (abreviatura de memory allocation) aloca um bloco de bytes consecutivos na memória do computador e devolve o endereço desse bloco. O número de bytes é especificado no argumento da função. No seguinte fragmento de código, malloc aloca 1 byte: char *ptr; ptr = malloc( 1); scanf( "%c", ptr); O endereço devolvido por malloc é do tipo "genérico" void *. O programador armazena esse endereço num ponteiro de tipo apropriado. No exemplo acima, o endereço é armazenado num ponteiro-para-char. Para alocar um tipo-de-dado que ocupa vários bytes, é preciso recorrer ao operador sizeof, que diz quantos bytes o tipo especificado tem: typedef struct { int dia, mes, ano; data; data *d; d = malloc( sizeof (data)); d->dia = 31; d->mes = 12; d->ano = 2008; [As aparências enganam: sizeof não é uma função.] Overhead. Cada invocação de malloc aloca um bloco de bytes consecutivos maior que o solicitado: os bytes adicionais são usados para guardar informações administrativas sobre o bloco de bytes (essas informações permitem que o bloco seja corretamente desalocado, 1

2 mais tarde, pela função free). O número de bytes adicionais pode ser grande, mas não depende do número de bytes solicitado no argumento de malloc. Não é recomendável, portanto, invocar malloc repetidas vezes com argumento muito pequeno. É preferível alocar um grande bloco de bytes e retirar pequenas porções desse bloco na medida do necessário. 1. Verificação do tamanho. Compile e execute o seguinte programa: typedef struct { int dia, mes, ano; data; int main( void) { printf( "sizeof (data) = %d\n", sizeof (data)); printf( "sizeof (data *) = %d\n", sizeof (data *)); return 0; A memória é finita Se a memória do computador já estiver toda ocupada, malloc não consegue alocar mais espaço e devolve NULL. Convém verificar essa possibilidade antes de prosseguir: ptr = malloc( sizeof (data)); if (ptr == NULL) { printf( "Socorro! malloc devolveu NULL!\n"); exit( EXIT_FAILURE); A codificação frequente e repetida desse teste é cansativa para o programador e desvia a atenção do leitor. Por isso, vamos usar a seguinte versão alternativa de malloc: void *mallocc( size_t nbytes) { void *ptr; ptr = malloc( nbytes); if (ptr == NULL) { printf( "Socorro! malloc devolveu NULL!\n"); exit( EXIT_FAILURE); return ptr; O parâmetro de mallocc é do tipo size_t. Em muitos computadores, size_t é equivalente a unsigned int. A função mallocc não está em nenhuma biblioteca e é desconhecida fora destas notas de aula. Ela é apenas uma abreviatura conveniente. Função free As variáveis alocadas estaticamente dentro de uma função desaparecem quando a execução da função termina. Já as variáveis alocadas dinâmicamente continuam a existir mesmo depois que a execução da função termina. Se for necessário liberar a memória ocupada por essas variáveis, é preciso recorrer à função free. 2

3 A função free libera a porção de memória alocada por malloc. O comando free( ptr) avisa o sistema de que o bloco de bytes apontado por ptr está livre. A próxima chamada de malloc poderá tomar posse desses bytes. A função free não deve ser aplicada a uma parte de um bloco de bytes alocado por malloc; aplique free apenas ao bloco todo. Convém não deixar ponteiros "soltos" (= dangling pointers) no seu programa, pois isso pode ser explorado por hackers para atacar o seu computador. Portanto, depois de cada free( ptr), atribua NULL a ptr: free( ptr); ptr = NULL; Atribuir um valor a um ponteiro que se tornou inútil é decididamente deselegante, mas não há como lidar com hackers de maneira elegante Para não cansar o leitor com detalhes repetitivos, estas notas não seguem a recomendação de segurança acima. Vetores e matrizes Eis como um vetor (= array) com n elementos inteiros pode ser alocado (e depois desalocado) durante a execução de um programa: int *v; int n, i; scanf( "%d", &n); v = mallocc( n * sizeof (int)); for (i = 0; i < n; ++i) scanf( "%d", &v[i]); for (i = n; i > 0; --i) printf( "%d ", v[i-1]); free( v); (A propósito, veja observação sobre vetores e endereços em outra página.) Do ponto de vista conceitual (mas apenas desse ponto de vista) o comando v = mallocc( 100 * sizeof (int)); tem o mesmo efeito que a alocação estática int v[100]; A propósito, convém lembrar que não permite escrever "int v[n]", a menos que n seja uma constante, definida por um #define. Matrizes bidimensionais são implementadas como vetores de vetores. Uma matriz com m linhas e n colunas é um vetor cada um de cujos m elementos é um vetor de n elementos. O seguinte fragmento de código faz a alocação dinâmica de uma tal matriz: 3

4 int **A; int i; A = mallocc( m * sizeof (int *)); for (i = 0; i < m; ++i) A[i] = mallocc( n * sizeof (int)); O elemento de A que está no cruzamento da linha i com a coluna j é denotado por A[i][j]. 1. Escreva uma função que receba um caractere c e transforme c em uma cadeia de,caracteres, ou seja, devolva uma cadeia de caracteres de comprimento 1 tendo c como único elemento. 2. Escreva um programa que leia um número inteiro positivo n seguido de n números inteiros e imprima esses n números em ordem invertida. Por exemplo, ao receber o seu programa deve imprimir O seu programa não deve impor limitações sobre o valor de n. 2. Tipos Estruturados / Registros / Structs Um registro é uma coleção de várias variáveis, possivelmente de tipos deferentes. Na linguagem C, registros são conhecidos como STRUCTS. O exemplo abaixo declara um registro data com três campos inteiros: struct { int dia; int mês; int ano; data; É indicado que se coloque sempre o nome do registro, outra forma de representar: struct dma { int dia; int mês; int ano; ; struct data x; /* um registro x do tipo data */ Para atribuição de valores nos campos de um registro, temos: x.dia = 23; x.mes = 08; x.ano = 2013; struct data x; /* um registro x do tipo data */ 4

5 Exemplo: A função abaixo recebe a data de início de um evento e a duração do evento em dias. Ela devolve a data de fim do evento. struct dma fim_evento (struct dma datainicio, int duracao) { struct dma datafim; datafim.dia =... datafim.mes =... datafim.ano =... return datafim; O código foi omitido porque é um tanto enfadonho: deve levar em conta a existência de meses com 31 dias, de meses com 30 dias, com 29 dias etc. Eis como essa função poderia ser usada: int main( void) { struct dma a, b; int d; scanf( "%d %d %d", &a.dia, &a.mes, &a.ano); scanf( "%d", &d); b = fim_evento( a, d); printf( "%d %d %d\n", b.dia, b.mes, b.ano); return EXIT_SUCCESS; 1. Complete o código da função fim_evento acima. 2. Escreva uma função que receba dois structs do tipo dma, cada um representando uma data válida, e devolva o número de dias que decorreram entre as duas datas. 3. Escreva uma função que receba um número inteiro que representa um intervalo de tempo medido em minutos e devolva o correspondente número de horas e minutos (por exemplo, converte 131 minutos em 2 horas e 11 minutos). Use uma struct como a seguinte: struct hm { int horas; int minutos; ; Structs e ponteiros Cada registro tem um endereço na memória do computador. (Você pode imaginar que o endereço de um registro é o endereço de seu primeiro campo, mas essa detalhe é irrelevante.) É muito comum usar um ponteiro para guardar o endereço de um registro. Dizemos que um tal ponteiro aponta para o registro. Por exemplo, struct dma *p; /* p é um ponteiro para registros dma */ struct dma x; p = &x; /* agora p aponta para x */ (*p).dia = 31; /* mesmo efeito que x.dia = 31 */ 5

6 [Cuidado! A expressão *p.dia, que equivale a *(p.dia), tem significado muito diferente de (*p).dia.] A expressão p->mes é uma abreviatura muito útil para a expressão (*p).mes: p->mes = 8; /* mesmo efeito que (*p).mes = 8 */ p->ano = 1998; Registros podem ser tratados como um novo tipo-de-dados. Por exemplo, typedef struct dma data; data x; data *p; p = &x; TYPEDEF A sintaxe de typedef é fácil. Primeiro, escreva uma declaração de uma variável do tipo desejado. Por exemplo, int *ptri; declara uma variável ptri (do tipo ponteiro-para-inteiro). Agora escreva "typedef" antes da declaração: typedef int *ptri; Com isso, ptri passa a ser o nome de um novo tipo (idêntico ao tipo ponteiro-parainteiro). Esse tipo pode ser usado para declarar novos ponteiros-para-inteiros, como p e q: ptri p, q; Outro exemplo: struct { int x; int y; ponto; declara uma variável ponto (que é um par ordenado de inteiros). Preceda a declaração de um typedef: typedef struct { int x; int y; ponto; Agora ponto passa a ser o nome de um novo tipo (idêntico a par ordenado de inteiros). Esse tipo pode ser usado para declarar novos pontos: ponto a, b; 4. Defina um registro empregado para guardar os dados (nome, sobrenome, data de nascimento, RG, data de admissão, salário) de um empregado de sua empresa. Defina um vetor de empregados para armazenar todos os empregados de sua empresa. Referências: ASCENCIO, Ana F. G.; CAMPOS, Edilene A. V. de. Fundamentos da programação de computadores. 2ª ed. São Paulo: Pearson Pratice Hall, MIZRAHI, Victorine V. Treinamento em Linguagem C. 2ª ed. São Paulo: Pearson Pratice Hall,