teste

PROJETO: Coleção de alunos

Implementar um TAD coleção de inteiros e fazer um programa que usa esse TAD com as seguintes funções:
  • Criar a coleção (Prguntando ao usuário o tamanho máximo).
  • Inserir um valor inteiro perguntando ao usuário.
  • Perguntar ao usuário o valor inteiro e remover.
  • Perguntar ao usuário um valor inteiro e retornar sim ou não se ele existe na coleção.
  • Destruir a coleção.
Antes de cada folha de código está o nome da folha:


===================
index.c
===================
//Este programa contém a função de criar uma coleção TAD
//Desenvolvido por: Kássio Rômulo Lima Sousa CP09126-81
//                  Núbia Cristine Silveira dos Santos CP09142-81.
//Setembro/2010

#define TAMANHONOME 40
#define FALSE 0
#define TRUE 1
#include <stdio.h>
#include "colecao.h"

struct colaluno{
      char nome[TAMANHONOME];
      int codigo;
      int nascimento;
};

Colecao *c;


int comp(void * a, void* b){
    int *pa;
    Aluno *pb;
    pa = (int*)a;
    pb = (Aluno*)b;
    if(*pa == pb -> codigo){
       return TRUE;
    }
    else return FALSE;
}

int main(void){   
    
        int max_itens, codigo, nascimento, Key, Key2;
        char opcao;
        Aluno *a, *b;

        printf("_______________________________\n");
        printf("|              UFMA           |\n");
        printf("| Kassio Romulo  - CP09126-81 |\n");
        printf("| Nubia Cristine - CP09142-81 |\n");
        printf("|_____________________________|\n");
        getch();
        printf("\n 1: Criar Colecao. \n 0: Sair.");
        printf("\tOpcao: ");   
           while(opcao != '0'){
              scanf("%s", &opcao);
                         
              switch(opcao){
                
                       case '1':
                            printf("\nTamanho maximo da colecao: "); 
                            scanf("%d", &max_itens);
                            c = colCriar(max_itens);
                            printf("\n 2: Inserir dados de Alunos. \n 0: Sair. \nOpcao: ");
                            break;  
                
                       case '2': 
                            a = (Aluno*)malloc(sizeof(Aluno));
                            printf("\n Nome: ");
                            getchar();
                            scanf("%s", a->nome);
                            printf(" Codigo: ");
                            scanf("%d", &(a->codigo));
                            printf(" Ano de Nascimento: ");
                            scanf("%d", &(a->nascimento));
                            colInserir(c , (void*)a);
                            printf("\n 2: Inserir dados de Alunos.\n 3: Buscar Aluno.\n 4: Destruir Colecao.\n 5: Remover cadastro\n 0: Sair.\n Opcao:");  
                            break;
                
                       case '3':
                            printf("\n Entre com o codigo do aluno:");
                            scanf(" %d", &Key);
                            a = colBuscar(c, (void*)&Key, comp);
                            printf("\n Nome:%s", a->nome);
                            printf(" Codigo:%d\n", a->codigo);
                            printf(" Ano de Nascimento:%d\n", a->nascimento);
                            printf("\n 2: Inserir dados de Alunos.\n 3: Buscar Aluno.\n 4: Destruir Colecao.\n 5: Remover cadastro\n 0: Sair.\n Opcao:");
                            break;
                
                       case '4':
                            colDestruir(c);
                            printf("\n 1: Criar Nova Colecao. \n 0: Sair. \n Opcao:");     
                            break;
                      
                       case '5':
                            printf("\n Entre com o codigo do aluno:");
                            scanf(" %d", &Key2);
                            b = colretirar(c, Key2, comp);
                            if(b != NULL){
                            printf("\n Sucesso!\n\n", b);
                            }
                            printf("\n 2: Inserir dados de Alunos.\n 3: Buscar Aluno.\n 4: Destruir Colecao.\n 5: Remover cadastro\n 0: Sair.\n Opcao:");
                            break;
              }
           }                   
}

=====================
colecao.c
=====================
//Este programa contém a função de criar uma coleção, e criar formulários, retirar, buscar, e destruir
//Desenvolvido por: Kássio Rômulo Lima Sousa CP09126-81
//                  Núbia Cristine Silveira dos Santos CP09142-81.
//Setembro/2010

#define __COLECAO_C_
#define FALSE 0
#define TRUE 1
#include <stdio.h>        /* Biblioteca Padrão */
#include <assert.h>        /* Afirmacoes de verificacao de pré condicao */
#include "colecao.h"    /* Inclui as especificações do TAD */
#include <stdlib.h>        /* Biblioteca Padrão */

struct _colecao_ { 
    int numItens;     /* numero de itens na colecao */
    int maxItens;      /* tamanho máximo da colecao */
    void **itens;     /* vetor com os itens */
};

/*----------------------------- colCriar -----------------------------------------
               Constroi uma nova colecao pedida pelo usuário
--------------------------------------------------------------------------------
condicao Inicial: (maxItens > 0)
Retorno da função: retorna um ponteiro para uma colecao vazia ou NULL em caso de erro
--------------------------------------------------------------------------------*/
Colecao* colCriar(int max){
    Colecao *c;
    if ( max > 0 ){                                // Testa Condição Inicial
       c = (Colecao*)malloc(sizeof(Colecao));      // Se for verdadeira aloca espaço para a coleção
    }
    if(!c){
       printf("** Erro: Memoria Insuficiente **"); // Se der erro e "c" não for verdadeiro, retorna erro!
       getch();
       exit (1);
    }
     if( c != NULL ){
       c -> itens = (void**)malloc(sizeof(void*)); //Se "c" for verdadeiro aloca espaço para Itens
       if ( c-> itens != NULL ){                   // Se Itens for verdadeiro
          c->maxItens = max;
          c->numItens = 0;
          return c;
       }
    }
    return NULL;
}

/*------------------------------- colInserir -------------------------------------
                    Adiciona um item há colecao
--------------------------------------------------------------------------------
Condição Inicial: c é uma coleçao criada por uma chamada a colCriar e numItens < maxItens
Retorno da Função: item é adicionado há colecao
--------------------------------------------------------------------------------*/
int colInserir( Colecao *c, void *dado){
    if ( c!= NULL){
       if(c->numItens < c-> maxItens){
            c->itens [c->numItens] = dado;
            c->numItens++;
            return TRUE;
       }
    }    
    else return FALSE;  
}

/*--------------------------------- colBuscar ------------------------------------
                     Encontra um item na coleção
--------------------------------------------------------------------------------
Condição Inicial: c é uma coleção criada por uma chamada a colCriar
Retorno da função: retorna a posicao do item identificado por key se ele existir, ou
                   FALSE caso contrario
--------------------------------------------------------------------------------*/             
void* colBuscar(Colecao* c, void* Key, int comp(void*, void*)){
   int i=0;
  
   if(c != NULL){
      if(c->numItens > 0){                         
         while((comp(Key, c->itens[i]) != TRUE) && (i < (c->numItens))){
             i++; 
         }
         if((comp(Key,c->itens[i])) == TRUE){
            return c->itens[i];
         }
         else return FALSE;     
      }                 
   }
}

/*--------------------------------- colRetirar ------------------------------------
                            Retira um item da coleção
--------------------------------------------------------------------------------
Condição Inicial: c é uma coleção criada por uma chamada a colCriar
Retorno da função: retorna a posicao do item identificado por key se ele existir, ou
                   FALSE caso contrario
--------------------------------------------------------------------------------*/ 
void* colretirar(Colecao* c, void* Key2, int comp(void*, void*)){
      int i=0, j=0;

      if(c != NULL){
          if(c -> numItens > 0){
               while((comp(Key2,c->itens[i]) != TRUE) && (i < (c->numItens))){
                         i++;
               }
               if(comp(Key2,c->itens[i])==TRUE){
                     free(c->itens[i]);
                     for(j = i ; j < c->numItens ; j++){
                             c->itens[j] = c->itens[j+1];
                     }
               c->numItens--;
               }
          }
      }else return NULL;
}

/*------------------------------- colDestruir ------------------------------------
                         Destroi uma colecao
--------------------------------------------------------------------------------
Condição Inicial: c é uma coleção criada por uma chamada a colCriar
Retorno da função: libera a memória alocada pela colecao
--------------------------------------------------------------------------------*/
int colDestruir(Colecao *c){
    register int i;  
    if(c!=NULL){
       if(c->numItens > 0){
          for(i=0;i < c->numItens;i++){
             free(c->itens[i]);
          }
       }
    free(c->itens);
    free(c);
    printf("\n Colecao Destruida com sucesso!! \n");
    return TRUE;
    }
    else{
       printf("\n Erro ao tentar destruir colecao!");
       return FALSE;
    }
}
 

======================
colecao.h
=====================

//Este programa contém a função de criar uma coleção, e criar formulários, retirar, buscar, e destruir
//Desenvolvido por: Kássio Rômulo Lima Sousa CP09126-81
//                  Núbia Cristine Silveira dos Santos CP09142-81.
//Setembro/2010

//Arquivo de especificação para o TAD

#ifndef __COLECAO_H
#define __COLECAO_H

typedef struct _colecao_ Colecao;
typedef struct colaluno Aluno;

Colecao*  colCriar(int maxItens);

int colInserir( Colecao *c, void *dado);

int colDestruir(Colecao *c);

void* colBuscar(Colecao* c, void* Key, int comp(void*, void*));

void* colretirar(Colecao* c, void* Key, int comp(void*, void*));

int comp(void* a, void* b);

#endif