domingo, 24 de abril de 2011

Programação em C - Apostila da UFMG parte final

AULA 11 - Tipos de Dados Definidos Pelo Usuário

Estruturas - Primeira parte

Uma estrutura agrupa várias variáveis numa só. Funciona como uma ficha pessoal que tenha nome, telefone e endereço. A ficha seria uma estrutura. A estrutura, então, serve para agrupar um conjunto de dados não similares, formando um novo tipo de dados.

- Criando

Para se criar uma estrutura usa-se o comando struct. Sua forma geral é:
struct nome_do_tipo_da_estrutura
{
tipo_1 nome_1;
tipo_2 nome_2;
...
tipo_n nome_n;
} variáveis_estrutura;
O nome_do_tipo_da_estrutura é o nome para a estrutura. As variáveis_estrutura são opcionais e seriam nomes de variáveis que o usuário já estaria declarando e que seriam do tipo nome_do_tipo_da_estrutura.  Um primeiro exemplo:
struct est{
    int i;
    float f;
} a, b;

Neste caso, est é uma estrutura com dois campos, i e f. Foram também declaradas duas variáveis, a e b que são do tipo da estrutura, isto é, a possui os campos i e f, o mesmo acontecendo com b.




Vamos criar uma estrutura de endereço:
struct tipo_endereco
{
        char rua [50];
        int numero;
        char bairro [20];
        char cidade [30];
        char sigla_estado [3];
        long int CEP;
};
Vamos agora criar uma estrutura chamada ficha_pessoal com os dados pessoais de uma pessoa:
struct ficha_pessoal
{
        char nome [50];
        long int telefone;
        struct tipo_endereco endereco;
};
Vemos, pelos exemplos acima,  que uma estrutura pode fazer parte de outra ( a struct tipo_endereco é usada pela struct ficha_pessoal).

- Usando

Vamos agora utilizar as estruturas declaradas na seção anterior para escrever um programa que preencha uma ficha.
#include <stdio.h>
#include <string.h>
struct tipo_endereco
{
        char rua [50];
        int numero;
        char bairro [20];
        char cidade [30];
        char sigla_estado [3];
        long int CEP;
};
 
struct ficha_pessoal
{
        char nome [50];
        long int telefone;
        struct tipo_endereco endereco;
};
 
main (void)
{
      struct ficha_pessoal ficha;
      strcpy (ficha.nome,"Luiz Osvaldo Silva");
      ficha.telefone=4921234;
      strcpy (ficha.endereco.rua,"Rua das Flores");
      ficha.endereco.numero=10;
      strcpy (ficha.endereco.bairro,"Cidade Velha");
      strcpy (ficha.endereco.cidade,"Belo Horizonte");
      strcpy (ficha.endereco.sigla_estado,"MG");
      ficha.endereco.CEP=31340230;
      return 0;
}
O programa declara uma variável ficha do tipo ficha_pessoal e preenche os seus dados. O exemplo mostra como podemos acessar um elemento de uma estrutura: basta usar o ponto (.). Assim, para acessar o campo telefone de ficha, escrevemos:
ficha.telefone = 4921234;
Como a struct ficha pessoal possui um campo, endereco, que também é uma struct, podemos fazer acesso aos campos desta struct interna da seguinte maneira:
ficha.endereco.numero = 10;
 ficha.endereco.CEP=31340230;
Desta forma, estamos acessando, primeiramente, o campo endereco da struct ficha e, dentro deste campo, estamos acessando o campo numero e o campo CEP.

- Matrizes de estruturas

Um estrutura é como qualquer outro tipo de dado no C. Podemos, portanto, criar matrizes de estruturas. Vamos ver como ficaria a declaração de um vetor de 100 fichas pessoais:
struct ficha_pessoal fichas [100];
Poderíamos então acessar a segunda letra da sigla de estado da décima terceira ficha fazendo:
fichas[12].endereco.sigla_estado[1];
Analise atentamente como isto está sendo feito ...

AUTO AVALIAÇÃO
Veja como você está. Escreva um programa fazendo o uso de struct's. Você deverá criar uma struct chamada Ponto, contendo apenas a posição x e y (inteiros) do ponto. Declare 2 pontos, leia a posição (coordenadas x e y) de cada um e calcule a distância entre eles. Apresente no final a distância entre os dois pontos.

 

Estruturas - Segunda parte


- Atribuindo

Podemos atribuir duas estruturas que sejam do mesmo tipo. O C irá, neste caso, copiar uma estrutura, campo por campo, na outra. Veja o programa abaixo:
struct est1 {
    int i;
    float f;
};

void main()
{
    struct est1 primeira, segunda;         /* Declara primeira e segunda como structs do tipo est1 */
           primeira.i = 10;
    primeira.f = 3.1415;

    segunda = primeira;                             /* A segunda struct e' agora igual a primeira */
    printf(" Os valores armazenasdos na segunda struct sao :  %d  e  %f ", segunda.i , segunda.f);
}
São declaradas duas estruturas do tipo est1, uma chamada primeira e outra chamada segunda. Atribuem-se valores aos dois campos da struct primeira.   Os valores de primeira são copiados em segunda apenas com a expressão de atribuição:
segunda = primeira;
Todos os campos de primeira serão copiados na segunda. Note que isto é diferente do que acontecia em vetores, onde, para fazer a cópia dos elementos de um vetor em outro, tínhamos que copiar elemento por elemento do vetor. Nas structs é muito mais fácil!
Porém, devemos tomar cuidado na atribuição de structs que contenham campos ponteiros. Veja abaixo:
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
 
struct tipo_end
{
      char *rua;     /* A struct possui um campo que é um ponteiro */
      int numero;
};
 
void main()
{
   struct tipo_end end1, end2;
   char buffer[50];
   printf("\nEntre o nome da rua:");
   gets(buffer);         /* Le o nome da rua em uma string de buffer */
   end1.rua = (char *) malloc((strlen(buffer)+1)*sizeof(char));  /* Aloca a quantidade de memoria
                                           suficiente para armazenar a string */
   strcpy(end1.rua, buffer);   /* Copia a string */
   printf("\nEntre o numero:");
   scanf("%d", &end1.numero);
 
   end2 = end1;         /* ERRADO end2.rua e end1.rua estao apontando para a mesma regiao de memoria */
 
   printf("Depois da atribuicao:\n Endereco em end1 %s %d  \n Endereco em end2 %s %d", end1.rua,end1.numero,end2.rua, end2.numero);
 
   strcpy(end2.rua, "Rua Mesquita");             /* Uma modificacao na memoria apontada por end2.rua causara' a modificacao do
                                     que e' apontado por end1.rua, o que, esta' errado !!!  */
   end2.numero = 1100;                     /* Nesta atribuicao nao ha problemas */
 
   printf(" \n\nApos modificar o endereco em end2:\n Endereco em end1 %s %d \n Endereco em end2 %s %d", end1.rua, end1.numero, end2.rua, end2.numero);
}
Neste programa há um erro grave, pois ao se fazer a atribuição end2 = end1, o campo rua de end2 estará apontando para a mesma posição de memória que o campo rua de end1. Assim, ao se modificar o conteúdo apontado por end2.rua estaremos também modificando o conteúdo apontado por end1.rua !!!

- Passando para funções

No exemplo apresentado no ítem usando, vimos o seguinte comando:
strcpy (ficha.nome,"Luiz Osvaldo Silva");
Neste comando um elemento de uma estrutura é passado para uma função. Este tipo de operação pode ser feita sem maiores considerações.

Podemos também passar para uma função uma estrutura inteira. Veja a seguinte função:
void PreencheFicha (struct ficha_pessoal ficha)
{
...
}
Como vemos acima é fácil passar a estrutura como um todo para a função. Devemos observar que, como em qualquer outra função no C, a passagem da estrutura é feita por valor. A estrutura que está sendo passada, vai ser copiada, campo por campo, em uma variável local da função PreencheFicha. Isto significa que alterações na estrutura dentro da função não terão efeito na variável fora da função. Mais uma vez podemos contornar este pormenor usando ponteiros e passando para a função um ponteiro para a estrutura.

- Ponteiros

Podemos ter um ponteiro para uma estrutura. Vamos ver como poderia ser declarado um ponteiro para as estruturas de ficha que estamos usando nestas seções:
struct ficha_pessoal *p;
Os ponteiros para uma estrutura funcionam como os ponteiros para qualquer outro tipo de dados no C. Para usá-lo, haveria duas possibilidades. A primeira é apontá-lo para uma variável struct já existente, da seguinte maneira:
struct ficha_pessoal ficha;
struct ficha_pessoal *p;
p  = &ficha;
A segunda é alocando memória para  ficha_pessoal usando, por exemplo, malloc():
#include <stdlib.h>
main()
{
    struct ficha_pessoal *p;
    int a = 10; /* Faremos a alocacao dinamica de 10 fichas pessoais */
    p = (struct ficha_pessoal *) malloc (a * sizeof(struct ficha_pessoal));
    p[0].telefone = 3443768;             /* Exemplo de acesso ao campo telefone da primeira ficha apontada por p */
    free(p);
}

Há mais um detalhe a ser considerado. Se apontarmos o ponteiro p  para uma estrutura qualquer (como fizemos em p  = &ficha; ) e quisermos acessar um elemento da estrutura poderíamos fazer:
(*p).nome
Os parênteses são necessários, porque o operador . tem precedência maior que o operador * . Porém, este formato não é  muito usado. O que é comum de se fazer é acessar o elemento nome através do operador seta, que é formado por um sinal de "menos" (-) seguido por um sinal de "maior que" (>), isto é: -> . Assim faremos:
p->nome
A declaração acima é muito mais fácil e concisa. Para acessarmos o elemento CEP dentro de endereco faríamos:
p->endereco.CEP
Fácil, não?
AUTO AVALIAÇÃO
Seja a seguinte struct que é utilizada para descrever os produtos que estão no estoque de uma loja :
struct Produto {
    char nome[30];     /* Nome do produto */
    int codigo;             /* Codigo do produto */
    double  preco;     /* Preco do produto */
};

a) Escreva uma instrução que declare uma matriz de Produto com 10 itens de produtos;
b) Atribua os valores "Pe de Moleque", 13205 e R$0,20 aos membros da posição 0 e os valores "Cocada Baiana", 15202 e R$0,50 aos membros da posição 1 da matriz anterior;
c) Faça as mudanças que forem necessárias para usar um ponteiro para Produto ao invés de uma matriz de Produtos. Faça a alocação de memória de forma que se possa armazenar 10 produtos na área de memória apontada por este ponteiro e refaça as atribuições da letra b;
d) Escreva as instruções para imprimir os campos que foram atribuídos na letra c.

Declaração Union

Uma declaração union determina uma única localização de memória onde podem estar armazenadas várias variáveis diferentes. A declaração de uma união é semelhante à declaração de uma estrutura:
union nome_do_tipo_da_union
{
tipo_1 nome_1;
tipo_2 nome_2;
...
tipo_n nome_n;
} variáveis_union;



Como exemplo, vamos considerar a seguinte união:
union angulo
        {
        float graus;
        float radianos;
        };
Nela, temos duas variáveis (graus e radianos) que, apesar de terem nomes diferentes, ocupam o mesmo local da memória. Isto quer dizer que só gastamos o espaço equivalente a um único float. Uniões podem ser feitas também com variáveis de diferentes tipos. Neste caso, a memória alocada corresponde ao tamanho da maior variável no union. Veja o exemplo:
#include <stdio.h>
#define GRAUS 'G'
#define RAD 'R'
union angulo
        {
        int graus;
        float radianos;
        };
void main()
{
union angulo ang;
char op;
printf("\nNumeros em graus ou radianos? (G/R):");
scanf("%c",&op);
if (op == GRAUS)
  {
  ang.graus = 180;
  printf("\nAngulo: %d\n",ang.graus);
  }
else if (op == RAD)
  {
  ang.radianos = 3.1415;
  printf("\nAngulo: %f\n",ang.radianos);
  }
else printf("\nEntrada invalida!!\n");
}







Temos que tomar o maior cuidado pois poderíamos fazer:
#include <stdio.h>
union numero
        {
        char Ch;
        int I;
        float F;
        };
main (void)
{
union numero N;
N.I = 123;
printf ("%f",N.F); /* Vai imprimir algo que nao e' necessariamente 123 ...*/
return 0;
}
O programa acima é muito perigoso pois você está lendo uma região da memória, que foi "gravada" como um inteiro, como se fosse um ponto flutuante. Tome cuidado! O resultado pode não fazer sentido.

Enumerações

Numa enumeração podemos dizer ao compilador quais os valores que uma determinada variável pode assumir. Sua forma geral é:
enum nome_do_tipo_da_enumeração {lista_de_valores} lista_de_variáveis;
Vamos considerar o seguinte exemplo:
enum dias_da_semana {segunda, terca, quarta, quinta, sexta, sabado, domingo};
O programador diz ao compilador que qualquer variável do tipo dias_da_semana só pode ter os valores enumerados. Isto quer dizer que poderíamos fazer o seguinte programa:
#include <stdio.h>
enum dias_da_semana {segunda, terca, quarta, quinta, sexta,
                                                sabado, domingo};
main (void)
{
enum dias_da_semana d1,d2;
d1=segunda;
d2=sexta;
if (d1==d2)
        {
        printf ("O dia e o mesmo.");
        }
else
        {
        printf ("São dias diferentes.");
        }
return 0;
}
Você deve estar se perguntando como é que a enumeração funciona. Simples. O compilador pega a lista que você fez de valores e associa, a cada um, um número inteiro. Então, ao primeiro da lista, é associado o número zero, o segundo ao número 1 e assim por diante. As variáveis declaradas são então variáveis int.

O Comando sizeof

O operador sizeof é usado para se saber o tamanho de variáveis ou de tipos. Ele retorna o tamanho do tipo ou variável em bytes. Devemos usá-lo para garantir portabilidade. Por exemplo, o tamanho de um inteiro pode depender do sistema para o qual se está compilando. O sizeof é  um operador porque ele é substituído pelo tamanho do tipo ou variável no momento da compilação. Ele não é uma função. O sizeof admite duas formas:
sizeof nome_da_variável
sizeof (nome_do_tipo)
Se quisermos então saber o tamanho de um float fazemos sizeof(float). Se declararmos a variável f como float e quisermos saber o seu tamanho faremos sizeof f. O operador sizeof também funciona com estruturas, uniões e enumerações.
Outra aplicação importante do operador sizeof é para se saber o tamanho de tipos definidos pelo usuário. Seria, por exemplo, uma tarefa um tanto complicada a de alocar a memória para um ponteiro para a estrutura ficha_pessoal, criada na primeira página desta aula, se não fosse o uso de sizeof. Veja o exemplo:
#include <stdio.h>
struct tipo_endereco
        {
        char rua [50];
        int numero;
        char bairro [20];
        char cidade [30];
        char sigla_estado [3];
        long int CEP;
        };
struct ficha_pessoal
        {
        char nome [50];
        long int telefone;
        struct tipo_endereco endereco;
        };
void main(void)
{
struct ficha_pessoal *ex;
ex = (struct ficha_pessoal *) malloc(sizeof(struct ficha_pessoal));
...
free(ex);
}

- O Comando typedef

O comando typedef permite ao programador definir um novo nome para um determinado tipo. Sua forma geral é:
typedef antigo_nome novo_nome;
Como exemplo vamos dar o nome de inteiro para o tipo int:
typedef int inteiro;
Agora podemos declarar o tipo inteiro.
O comando typedef também pode ser utilizado para dar nome a tipos complexos, como as estruturas. As estruturas criadas no exemplo da página anterior poderiam ser definidas como tipos através do comando typedef. O exemplo ficaria:
#include <stdio.h>
typedef struct tipo_endereco
        {
        char rua [50];
        int numero;
        char bairro [20];
        char cidade [30];
        char sigla_estado [3];
        long int CEP;
        } TEndereco;
typedef struct ficha_pessoal
        {
        char nome [50];
        long int telefone;
        TEndereco endereco;
        }TFicha;
void main(void)
{
TFicha *ex;
...
}
Veja que não é mais necessário usar a palavra chave struct para declarar variáveis do tipo ficha pessoal. Basta agora usar o novo tipo definido TFicha.

Uma aplicação de structs: as listas simplesmente encadeadas

Várias estruturas de dados complexas podem ser criadas utilizando simultaneamente structs e ponteiros. Uma destas estruturas é a lista encadeada. Uma lista encadeada é uma seqüência de structs, que são os nós da lista, ligados entre si através de ponteiros. Esta seqüência pode ser acessada através de um ponteiro para o primeiro nó, que é a cabeça da lista. Cada nó contém um ponteiro que aponta para a struct que é a sua sucessora na lista. O ponteiro da última struct da lista aponta para NULL, indicando que se chegou ao final da lista. Esta estrutura de dados é criada dinamicamente na memória (utiliza-se malloc() e free()), de modo que se torna simples introduzir nós nela, retirar nós, ordenar os nós, etc. Não vamos entrar em detalhes sobre todos os algoritmos que poderíamos criar em uma lista encadeada, pois isto geralmente é feito em cursos de algoritmos e estruturas de dados, não se incluindo no escopo deste curso. Aqui, veremos somente formas de se criar uma lista encadeada em C e também maneiras simples de percorrer esta lista.
Supondo que queiramos criar uma lista encadeada para armazenar os produtos disponíveis em uma loja. Poderíamos criar um nó desta lista usando a seguinte struct:
struct Produto {
    int codigo; /* Codigo do produto */
    double preco; /* Preco do produto */
    struct Produto *proximo;    /* Proximo elemento da lista encadeada de Produtos */
};

Note que esta struct possui, além dos campos de dados codigo e preco, um campo adicional que é um ponteiro para uma struct do tipo Produto. É este campo que será utilizado para apontar para o próximo nó da lista encadeada. O programa a seguir faz uso desta struct, através de um novo tipo criado por um typedef, para criar uma lista de produtos de uma loja:
#include <stdio.h>
#include <stdlib.h>

/* Estrutura que será usada para criar os nós da lista */

typedef struct tipo_produto {
    int codigo;                  /* Codigo do produto */
    double preco;                /* Preco do produto */
    struct tipo_produto *proximo;    /* Proximo elemento da lista encadeada de Produtos */
}  TProduto;

/* Prototipos das funcoes para inserir e listar produtos */

void inserir(TProduto **cabeca);
void listar (TProduto *cabeca);

int main()
{
    TProduto *cabeca = NULL;        /* Ponteiro para a cabeca da lista */
    TProduto *noatual;               /* Ponteiro a ser usado para percorrer a lista no momento de desalocar seus elementos*/
    char q;                          /* Caractere para receber a opcao do usuario */
    do {
        printf("\n\nOpcoes: \nI -> para inserir novo produto;\nL -> para listar os produtos; \nS -> para sair \n:");
        scanf("%c", &q);     /* Le a opcao do usuario */
        switch(q) {
            case 'i': case 'I': inserir(&cabeca); break;
            case 'l': case 'L': listar(cabeca); break;
            case 's': case 'S': break;
            default: printf("\n\n Opcao nao valida");
        }
        fflush(stdin);    /* Limpa o buffer de entrada */
    } while ((q != 's') && (q != 'S') );

/* Desaloca a memoria alocada para os elementos da lista */

    noatual = cabeca;
    while (noatual != NULL)
    {
        cabeca = noatual->proximo;
        free(noatual);
        noatual = cabeca;
    }
}

/* Lista todos os elementos presentes na lista encadeada */

void listar (TProduto *noatual)
{
    int i=0;
    while( noatual != NULL)    /* Enquanto nao chega no fim da lista */
    {
        i++;
        printf("\n\nProduto numero %d\nCodigo: %d \nPreco:R$%.2lf", i, noatual->codigo, noatual->preco);
        noatual = noatual->proximo;     /* Faz noatual apontar para o proximo no */
    }
}

/* Funcao para inserir um novo no, ao final da lista */

void inserir (TProduto **cabeca)
{
    TProduto *noatual, *novono;
    int cod;
    double preco;
    printf("\n Codigo do novo produto: ");
    scanf("%d", &cod);
    printf("\n Preco do produto:R$");
    scanf("%lf", &preco);
    if (*cabeca == NULL)    /* Se ainda nao existe nenhum produto na lista */
    {
/* cria o no cabeca */
        *cabeca = (TProduto *) malloc(sizeof(TProduto));
        (*cabeca)->codigo = cod;
        (*cabeca)->preco = preco;
        (*cabeca)->proximo = NULL;
    }
    else
    {
/* Se ja existem elementos na lista, deve percorre-la ate' o seu final e inserir o novo elemento */
        noatual = *cabeca;
        while(noatual->proximo != NULL)
            noatual = noatual->proximo;    /* Ao final do while, noatual aponta para o ultimo no */
        novono = (TProduto *) malloc(sizeof(TProduto));/* Aloca memoria para o novo no */
        novono->codigo = cod;
        novono->preco = preco;
        novono->proximo = NULL;
        noatual->proximo = novono;     /* Faz o ultimo no apontar para o novo no */
    }
}

É interessante notar que, no programa anterior não existe limite para o número de produtos que se vai armazenar na lista. Toda vez que for necessário criar um novo produto, memória para ele será alocada e ele será criado no final da lista. Note que a função inserir recebe o endereço do ponteiro cabeça da lista. Qual a razão disto? A razão é que o endereço para o qual a cabeça da lista aponta poderá ser modificado caso se esteja inserindo o primeiro elemento na lista. Tente entender todos os passos deste programa, pois ele possui várias das características presentes em programas que manipulam listas encadeadas. Também é importante notar que várias outras estruturas de dados complexas podem ser criadas com structs contendo ponteiros que apontam para outras structs.
AUTO AVALIAÇÃO
Crie uma struct para descrever restaurantes. Os campos devem armazenar o nome do restaurante, o endereço, o tipo de comida (brasileira, chinesa, francesa, italiana, japonesa, etc) e uma nota para a cozinha (entre 0 e 5). Crie uma lista encadeada com esta struct e escreva um programa que:
a) Insira um novo restaurante na lista;
b) Leia uma lista de restaurantes a partir de um arquivo;
c) Grave a lista de restaurantes para um arquivo;
d) Liste todos os restaurantes na tela;
e) Liste os restaurantes com cozinha com nota superior a um determinado valor, determinado pelo usuário;
f) Liste todos os restaurantes com determinado tipo de comida, determinado pelo usuário.

Nenhum comentário:

Postar um comentário

Postar um comentário

Cursos 24 Horas - Nao perca Tempo Capacite-se