//Cria o menu inicial
menu1 (){
system ("cls");
cabecalho();
printf ("OPÇÕES\n\n1 - Novo jogo. \n2 - Instruções.\n3 - Sair.\n\n\n---> ");
validaopcao ();
switch (opcao){
case 1:
system ("cls");
cabecalho();
informa ();
break;
case 2:
system ("cls");
cabecalho();
printf ("\t\t\t INSTRUÇÕES\n\n");
printf ("1 - Informe os nomes dos jogadores. \n2 - As jogadas são alternadas. \n3 - Ganha o jogador que marcar três posições em sequencia.\n");
getch ();
menu1();
break;
case 3:
system("CLS");
printf("\n\n *********************************************************\n");
printf(" * *\n");
printf(" * Obrigado por jogar TicTacToe. *\n * Desenvolvido por José Tarciso e Olliver Felipe. *\n * *\n * Pressione qualquer tecla para sair... *\n * *\n *********************************************************");
printf("\a\a\a");
getch();
printf("\a\a");
exit (EXIT_SUCCESS);
break;
}
}
//Valida entrada do menu inicial, impedindo que a opção do usuário seja menor que 1 ou maior que 3.
validaopcao (){
/*ValordoScanf é uma variavel do tipo inteiro, ela receberá um valor retornado pela função scanf(), esta que por sua vez retorna 1 se a entrada
de dados for valida e 0 se for inválida. o loop se encarrega de forçar que o usuario informe um valor inteiro e a função fflush(stdin)
se encarrega de limpar a entrada de dados anterior evitando um loop infinito*/
valorDoScanf = 0;
mensagemDeErro = 0;
do {
if(mensagemDeErro >= 1){
system ("cls");
cabecalho ();
printf ("OPÇÕES\n\n1 - Novo jogo. \n2 - Instruções.\n3 - Sair.\n\n\n");
printf("ATENÇÃO! Não insira letras nem símbolos! \nVocê deve digitar um número inteiro entre 1 e 3.\n\n\n---> ");
}
fflush(stdin);
valorDoScanf = scanf ("%d", &opcao);
mensagemDeErro++;
} while(valorDoScanf == 0);
while (opcao < 1 || opcao > 3){
system ("cls");
cabecalho ();
printf ("\n\n%d não é uma opção válida.\n", opcao);
printf ("Por favor, escolha 1, para jogar, 2 para informações ou 3 para sair.\n\n");
printf ("---> ");
valorDoScanf = 0;
mensagemDeErro = 0;
do {
if(mensagemDeErro >= 1){
printf("\nVocê deve digitar um número inteiro entre 1 e 3.\n\n--->");
}
fflush(stdin);
valorDoScanf = scanf ("%d", &opcao);
mensagemDeErro++;
} while(valorDoScanf == 0);
}
}
main (){
setlocale (LC_ALL, "Portuguese");
system ("color 07");
//Essse loop "ZERA" as casas do tabuleiro para qualquer novo jogo.
for (i=0; i<=3; i++){
for (j=0;j<=3; j++){
casa[i][j] = '\0';
}
}
if (opcao == 5){
system ("cls");
cabecalho();
informa ();
} else {
menu1();
informa ();
}
opcao=0;
//O loop seguinte repete o jogo enquanto se iniciarem novos jogos com os mesmos jogadores.
do {
//A função da estrutura de decisão abaixo é informar novamente ao programa os nomes dos
//jogadores 1 e 2. O programa só passará por ela, em caso de novo jogo com jogadores iguais aos da partida anterior.
if (nomeaux == 1){
strcpy (nome1, nomeaux1);
strcpy (nome2, nomeaux2);
cabecalho ();
tabuleiro ();
}
//Laço de repetição que determina a duração do jogo.
while (vencedor == 0 && turno < 9) {
tabuleiro ();
jogada ();
system ("cls");
cabecalho ();
tabuleiro ();
for (i=1; i<=3; i++){
verificavencedor (i, 1, i, 2, i, 3); //verifica vencedor nas colunas
verificavencedor (1, i, 2, i, 3, i); //verifica vencedos nas linhas
}
verificavencedor (1, 1, 2, 2, 3, 3); //verifica vencedor na primeira diagona
verificavencedor (1, 3, 2, 2, 3, 1); //verifica vencedor na segunda diagonal
}
printf ("Pressione qualquer tecla para continuar...\n\n");
getch ();
placar ();
printf ("Pressione qualquer tecla para continuar...\n\n");
getch ();
menu2();
} while (opcao == 1);
printf("Obrigado por jogar TicTacToe\nDesenvolvido por José Tarciso e Olliver Felipe.\n\n Pressione qualquer tecla para sair...");
getch();
}
void filter( int op, struct tlist *l)
{
filter_pass = 1;
int i, num;
do
{
//verifica opção selecionada pelo usuario.
if(op == 1)
{
cabecalho("INSERIR");
if(l->last == MAX)
{
printf("\t\t# ERRO: Lista cheia! [ENTER]");
getche();
break;
}
else
{
printf("\t\tDIGITE UM NUMERO: ");
geti(&num);
i = search(num, l);
if(i != -1)
{
printf("\n\t\t# NUMERO JA ESTA NA LISTA! [ENTER]");
getche();
}
else add(num, l);
}
}
else
{
cabecalho("REMOVER");
printf("\t\tDIGITE O NUMERO: ");
geti(&num);
i = search(num, l);
if(i == -1)
{
printf("\n\t\t# NUMERO NAO ENCONTRADO! [ENTER]");
getche();
}
else retire(i, l);
}
printf("\n\n\t\t# DESEJA CONTINUAR? [1] SIM [9] NAO");
printf("\n\t\t# OPCAO: ");
geti(&op);
}
while(op == 1);
}
static void getRandomNumberMinMaxTest() {
cabecalho("getRandomNumberMinMaxTest()");
int i;
int numSorteado;
int limiteMin = 10, limiteMax = 100;
int algumNumeroSorteado = 0;
int algumNumeroSorteadoAlemDoLimiteMaximo = 0;
int algumNumeroSorteadoAntesDoLimiteMinimo = 0;
for (i=0; i<1000; i++) {
numSorteado = getRandomNumberMinMax(limiteMin, limiteMax);
if (numSorteado != 0) {
algumNumeroSorteado++;
}
if (numSorteado > limiteMax) {
algumNumeroSorteadoAlemDoLimiteMaximo++;
}
if (numSorteado < limiteMin) {
algumNumeroSorteadoAntesDoLimiteMinimo++;
}
}
ENSURE(algumNumeroSorteado >= 0);
ENSURE(algumNumeroSorteadoAlemDoLimiteMaximo == 0);
ENSURE(algumNumeroSorteadoAntesDoLimiteMinimo == 0);
}
int main()//Função principal
{
//Procedimento cabecalho
cabecalho();
//Declaração de variáveis
float idade[3];
float peso[3];
int i;
//Obervação coloquei o laço indo até 3 para testar, tinha que ir até 10
//de acordo com o exercicio
for(i=0; i < 3; i++)
{
printf("\nIntroduza a idade da pessoa %d\n",i+1);
scanf("%f",&idade[i]);
printf("\nIntroduza o peso da pessoa %d\n",i+1);
scanf("%f",&peso[i]);
}
//Impressão de resultados
printf("\n****-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_****\n");
printf("\nA idade da pessoa que tem o maior peso = %.0f\n",
idade_e_maior_peso(peso,idade) );
printf("\nO peso da pessoa que tem a menor idade = %.0f\n",
peso_e_menor_idade(peso,idade) );
printf("\n****-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_****\n");
system("pause");
return 0;
}
//Valida uma jogada em posição livre e, caso a posição informada não estivesse marcada, marca
//a posição informada e, após isso, alterna o jogador que jogará o próximo turno.
validajogada (){
if (casa[linha][coluna] == 'X' || casa[linha][coluna] == 'O'){
system ("cls");
cabecalho ();
tabuleiro ();
if (jogador == 1)
printf ("\nA posição escolhida já foi marcada. \n\n%s, ainda é sua vez.\n", nome1);
if (jogador == 2)
printf ("\nA posição escolhida já foi marcada. \n\n%s, ainda é sua vez.\n", nome2);
printf ("\nInforme as novas coordenadas da sua jogada.\n");
printf ("Linha: ");
scanf ("%d", &linha);
validalinha ();
printf ("Coluna: ");
scanf ("%d", &coluna);
validacoluna();
validajogada ();
} else {
if (jogador == 1){
casa[linha][coluna] = 'X';
jogador = 2;
} else {
casa[linha][coluna] = 'O';
jogador = 1;
}
}
}
// Exercício 3
void exercicio_3() {
// Declaração
int matriz[X_TAM_3][X_TAM_3], vetor[Y_TAM_3], k = INIT_2;
// Inicializações
inicializa_matriz_sequencia_int((int *)matriz, INIT_2, X_TAM_3, X_TAM_3);
for (int i = 0; i < Y_TAM_3; i++)
vetor[i] = 0;
// Exibições
system("clear");
cabecalho();
puts("\n------------------ Matriz original ------------------");
imprime_matriz_int((int *)matriz, X_TAM_3, X_TAM_3);
// Multiplicando a matriz por 5
mult_matriz_num_self_int((int *)matriz, 5, X_TAM_3, X_TAM_3);
puts("\n------------------ Matriz após multiplicação por 5 ------------------");
imprime_matriz_int((int *)matriz, X_TAM_3, X_TAM_3);
// lineariza a matriz
if(lineariza_matriz_int((int *)matriz, X_TAM_3, X_TAM_3, vetor, Y_TAM_3)){
puts("\n------------------ Matriz linearizada ------------------");
imprime_vetor_int(vetor, Y_TAM_3);
}
}
//Obriga coluna estar entre 1 e 3.
validacoluna (){
while (coluna < 1 || coluna > 3){
system ("cls");
cabecalho ();
tabuleiro ();
printf ("Entrada inválida!\n\n");
if (jogador == 1){
printf ("%s, ainda é sua vez.\n\n", nome1);
} else {
printf ("%s, ainda é sua vez. \n\n", nome2);
}
printf ("Por favor, escolha um valor de 1 até 3 para a posição escolhida. \n\n\n");
printf ("Coluna: ");
do {
valorDoScanf = 0;
mensagemDeErro = 0;
if(mensagemDeErro >= 1){
printf("\nVocê deve digitar um número inteiro entre 1 e 3.\n\n--->");
}
fflush(stdin);
valorDoScanf = scanf ("%d", &coluna);
mensagemDeErro++;
} while(valorDoScanf == 0);
}
}
//Cria o menu inicial
menu1 (){
system ("cls");
cabecalho();
printf ("OPÇÕES\n\n");
printf ("1 - Novo jogo. \n2 - Instruções.\n3 - Sair.\n\n");
printf ("---> ");
/*Valor do Scanf é uma variavel do tipo inteiro, ela receberá um valor gerado pela função scanf()
esta que por sua vez retorna um valor inteiro, 1 se a entrada de dados for validada e 0 se não for validada,
o loop se encarrega de forçar a tela ate que o usuario informe um valor inteiro e a função fflush(stdin) se encarrega
de limpar a entrada de dados, para que não caia em um loop infinito*/
valorDoScanf = 0;
mensagemDeErro = 0;
do {
if(mensagemDeErro >= 1){
printf("\nVocê deve digitar um número inteiro entre 1 e 3.\n\n---> ");
}
fflush(stdin);
valorDoScanf = scanf ("%d", &opcao);
mensagemDeErro++;
} while(valorDoScanf == 0);
validaopcao ();
switch (opcao){
case 1:
system ("cls");
cabecalho();
informa ();
break;
case 2:
system ("cls");
cabecalho();
printf ("\t\t\t INSTRUÇÕES\n\n");
printf ("1 - Informe os nomes dos jogadores. \n2 - As jogadas são alternadas. \n3 - Ganha o jogador que marcar três posições em sequencia.\n");
getch ();
menu1();
break;
case 3:
system("CLS");
printf("\n\n *********************************************************\n");
printf(" * *\n");
printf(" * Obrigado por jogar TicTacToe. *\n * Desenvolvido por José Tarciso e Olliver Felipe. *\n * *\n * Pressione qualquer tecla para sair... *\n * *\n *********************************************************");
printf("\a\a\a");
getch();
printf("\a\a");
exit (EXIT_SUCCESS);
break;
}
}
static void menorTest() {
cabecalho("menorTest()");
ENSURE(menor(1, 2) == 1);
ENSURE(menor(2, 1) == 1);
ENSURE(menor(-1, 5) == -1);
ENSURE(menor(5, -1) == -1);
ENSURE(menor(5, 5) == 5);
}
menu2(){
system ("cls");
cabecalho();
printf ("E aí, querem jogar mais uma?\n\n");
printf ("1 - Jogar com os mesmos jogadores.\n");
printf ("2 - Jogar com jogadores diferentes.\n");
printf ("3 - Sair.\n\n");
printf ("---> ");
validaopcao();
switch (opcao){
/*
Para jogar com os mesmos jogadores, os nomes informados no incício são transmitidos para
variáveis auxiliares, ativa-se nomeaux, vencedor e turno recebem 0 e as casas são zeradas.
*/
case 1:
strcpy (nomeaux1,nome1);
strcpy (nomeaux2,nome2);
nomeaux = 1;
vencedor = 0;
turno = 0;
//Zera as casas do tabuleiro, para reiniciar o jogo com os mesmos jogadores.
for (i=0; i<=3; i++)
for (j=0;j<=3; j++)
casa[i][j] = '\0';
break;
/*
Para jogar com jogadores diferentes, zera-se a quantidade de vitórias, anulam-se vencedor,
turno e variável nomeaux e invoca-se a função main desde o seu início.
*/
case 2:
vitorias1=0;
vitorias2=0;
vitoriasdavelha=0;
vencedor = 0;
turno = 0;
nomeaux = 0;
if (jogador == 1)
jogador = 2;
if (jogador == 2)
jogador = 1;
system ("cls");
opcao = 5;
main ();
break;
case 3:
system("CLS");
printf("\n\n *********************************************************\n");
printf(" * *\n");
printf(" * Obrigado por jogar TicTacToe. *\n * Desenvolvido por José Tarciso e Olliver Felipe. *\n * *\n * Pressione qualquer tecla para sair... *\n * *\n *********************************************************");
printf("\a\a\a");
getch();
printf("\a\a");
exit (EXIT_SUCCESS);
break;
}
}
int main() {
char arquivo[500], autor[500], descricao[500];
scanf("%[^\n] ", arquivo);
scanf("%[^\n] ", autor);
scanf("%[^\n] ", descricao);
cabecalho(arquivo, autor, descricao);
return 0;
}
// imprimeAllDisciplina: imprime todas as disciplinas
// que a fila contém
void imprimeAllDisciplina(tFila *f){
if(vazia(f))
printf("\n\n\t\t# Atencao: Lista Vazia! [ENTER]");
else{
cabecalho("Disciplinas");
imprime(f);
}
fflush(stdin);
getchar();
}
void imprimir(struct tlist *l)
{
cabecalho("IMPRESSAO");
if(filter_pass)
{
print(l);
printf("\n\t\t\t # [ENTER]");
}
else
printf("\n\n\t\t# INSERIR DADOS! [ENTER]");
getche();
}
void menu(int *op)
{
cabecalho("MENU PRINCIPAL");
printf("\t\t[1] INSERIR LISTA\n");
printf("\t\t[2] RETIRAR LISTA\n");
printf("\t\t[3] VERIFICAR NUMERO\n");
printf("\t\t[4] IMPRIMIR LISTA\n");
printf("\t\t[9] SAIR\n\n");
printf("\t\t# OPCAO: ");
geti(op);
}
// pesquisaAvancada: permite ao usuario escolher
// qualquer forma deseja buscar na fila
void pesquisaAvancada(tFila *f){
int codigo, opcao, flag = 0;
float cargaHoraria;
tCelula *celula = f->frente->prox;
if(vazia(f))
printf("\n\n\t\t# Erro: Cadastrar disciplinas! [ENTER]");
else{
cabecalho("Pesquisa Avancada");
printf("\t\t\t1 - Codigo");
printf("\n\t\t\t2 - Carga Horaria");
printf("\n\n\t\tOpcao: ");
fflush(stdin);
scanf("%d", &opcao);
switch(opcao){
case 1:
printf("\n\t\tInforme o codigo: ");
fflush(stdin);
scanf("%d", &codigo);
while(celula != NULL){
if(celula->disciplina.codigo == codigo){
imprimeDisciplina(celula->disciplina);
flag = 1;
}
celula = celula->prox;
}
break;
case 2:
printf("\n\t\tInforme a Carga Horaria: ");
fflush(stdin);
scanf("%f", &cargaHoraria);
while(celula!= NULL){
if(celula->disciplina.cargaHoraria == cargaHoraria){
imprimeDisciplina(celula->disciplina);
flag = 1;
}
celula = celula->prox;
}
break;
default:printf("\n\n\t\tOpcao invalida!");
}
}
if(!flag) printf("\n\t\tNao ha resultados para essa consulta! [ENTER]");
fflush(stdin);
getchar();
}
// menu: exibi as opções do menu
// e retorna a opção selecionada
int menu()
{
int op;
cabecalho("MENU PRINCIPAL");
printf("\t\t[1] LER ARQUIVO\n");
printf("\t\t[2] LER RESULTADO\n");
printf("\t\t[9] SAIR\n\n");
printf("\t\t# OPCAO: ");
fflush(stdin);
scanf("%d", &op);
return op;
}
int main(int argc, char *argv[]){ /* funcao principal que recebe uma letra 'n', 'e' ou 'p' de maneira a escolher a funcao que define o novo formato da imagem */
switch(argv[1][0]) {
case 'n':{
cabecalho("# negativo", 1, 1);
negativo();
break;
}
case 'e': {
cabecalho("# espelho", 1, 1);
espelho();
break;
}
case 'p': {
cabecalho("# padrao", atoi(argv[2]), atoi(argv[3]));
padrao(atoi(argv[2]), atoi(argv[3]));
break;
}
default:
return EXIT_FAILURE; /* Opção desconhecida (STDLIB)*/
}
return EXIT_SUCCESS; /* Termina o programa com sucesso (STDLIB) */
}
//Essa função recebe parâmetros de 1 até 3, que dizem respeito às coordenadas maracadas pelos
//jogadores, verifica e informa se houve vencedor.
verificavencedor(int a, int b, int c, int d, int e, int f){
if (casa[a][b] == 'X' && casa[c][d] == 'X' && casa[e][f] == 'X'){
jogador = 1;
vencedor = 1;
system ("cls");
cabecalho ();
trofeu ();
printf ("___________________________________________________________________________\n\n");
printf ("\t\t\t\t Parabéns!\n\t\t\t%s, você foi o(a) vencedor(a)!\n", nome1);
printf ("___________________________________________________________________________\n\n");
} else {
if (casa[a][b] == 'O' && casa[c][d] == 'O' && casa[e][f] == 'O'){
jogador = 2;
vencedor = 1;
vencedor = 1;
system ("cls");
cabecalho ();
trofeu ();
printf ("___________________________________________________________________________\n\n");
printf ("\t\t\t\t Parabéns!\n\t\t\t%s, você foi o(a) vencedor(a)!\n", nome2);
printf ("___________________________________________________________________________\n\n");
}
}
}
tabuleiro (){ //tabuleiro temporário
system ("cls");
cabecalho ();
printf ("\n\t\t\t # # \n ");
printf ("\t\t\t %c # %c # %c \n", casa[1][1], casa[1][2], casa[1][3]);
printf ("\t\t\t # # \n ");
printf ("\t\t\t ################# \t%s joga com X\n", nome1);
printf ("\t\t\t # # \n");
printf ("\t\t\t %c # %c # %c \n", casa[2][1], casa[2][2], casa[2][3]);
printf ("\t\t\t # # \n ");
printf ("\t\t\t ################# \t%s joga com O\n", nome2);
printf ("\t\t\t # # \n");
printf ("\t\t\t %c # %c # %c \n", casa[3][1], casa[3][2], casa[3][3]);
printf ("\t\t\t # #\n\n");
}
// menu: menu atribui o valor escolhido
// pelo usuário por referência
void menu(int *op){
cabecalho("Menu Principal");
// opções do menu
printf("\t\t1 - Cadastrar Disciplina\n");
printf("\t\t2 - Excluir Disciplina\n");
printf("\t\t3 - Imprimir Disciplinas\n");
printf("\t\t4 - Verificar Lista\n");
printf("\t\t5 - Esvaziar Lista\n");
printf("\t\t6 - Pesquisa Avancada\n");
printf("\t\t0 - Sair\n");
printf("\n\t\tOpcao: ");
fflush(stdin);
scanf("%d", op);
}
// excluiDisciplina: desenfileira o primeiro elemento da fila
void excluiDisciplina(tFila *f){
int posicao, cont = 0, enc = 0;
tDisciplina disciplina;
if(vazia(f))
printf("\n\n\t\t# Erro: Cadastrar disciplinas! [ENTER]");
else{
cabecalho("Remover disciplina");
// remove a primeira disciplina da fila
desenfileira(f, &disciplina);
printf("\n\t\tDisciplina: %s removida! [ENTER]", disciplina.nome);
}
fflush(stdin);
getchar();
}
void pesquisar(struct tlist *l)
{
int num, j;
cabecalho("PESQUISA");
if(filter_pass)
{
printf("\t\tDIGITE O NUMERO: ");
geti(&num);
j = search(num, l);
if(j != -1)
printf("\n\n\t\tITEM: %d - POSICAO %d. [ENTER]", l->item[j], j);
else
printf("\n\t\t# ERRO: NUMERO NAO ENCONTRADO! [ENTER]");
}
else printf("\n\n\t\t# INSERIR DADOS! [ENTER]");
getche();
}
int main()
{
float n, d;
cabecalho("Calcular o dobro de um número");
printf("Informe um valor:");
scanf("%f", &n);
d = dobrar( n );
printf("\nO dobro de %f é %f.\n\n", n, d);
rodape("FIM");
return 0;
}
/*
A função PLACAR conta as vitórias de cada um dos jogadores, bem como os empates,
e imprime na tela o resultado.
*/
placar (){
if (jogador == 1 && vencedor == 1)
++vitorias1;
if (jogador == 2 && vencedor == 1)
++vitorias2;
if (vencedor == 0 && turno >= 9) {
++vitoriasdavelha;
vencedor = 0;
printf ("Xiiiii, deu velha!\n");
}
system ("cls");
cabecalho();
printf ("|\t\t\t\t PLACAR |\n");
printf ("___________________________________________________________________________\n\n");
printf ("%s venceu %d vez(es)\n\n", nome1, vitorias1);
printf ("%s venceu %d vez(es)\n\n", nome2, vitorias2);
printf ("A velha ganhou %d vez(es).\n\n\n", vitoriasdavelha);
}
// openFile: recebe com parâmetro o nome
// do arquivo a ser lido, imprime o dados
// do arquivo e retornar se foi possivel
// abrir ou não o arquivo
int openFile(char arquivo[], int escolha){
FILE *fptr;
int i = 0;
char cha[MAX];
char ch[MAX];
int a[MAX], b[MAX];
tPilha p[MAX];
cabecalho("LENDO ARQUIVO...");
fptr = fopen(arquivo, "r");
if(escolha){
if(fptr == NULL){
printf("\t\t# ERRO: IMPOSSIVEL ABRIR O ARQUIVO. [ENTER]");
fflush(stdin);
getchar();
return 0;
}else{
while(fscanf(fptr, "%s %d %d", ch, &a[i], &b[i]) != EOF){
if(!i){
// converte caracter para inteiro
// pega o valor da primeira linha do arquivo
int j = ch[0]-'0';
// inicializa os blocos
for(int i = 0; i < j; i++){
inicializa(&p[i]);
empilhar(i,&p[i]);
}
}
filter(p, ch, a[i], b[i]);
i++;
}
}
fflush(stdin);
getchar();
}else
if(fptr == NULL)
return 0;
else
while(fgets(cha,MAX, fptr) != NULL)
printf("\t\t%s", cha);
fclose(fptr);
return 1;
}
//Valida entrada do menu inicial, impedindo que a opção do usuário seja menor que 1 ou maior que 3.
validaopcao (){
while (opcao < 1 || opcao > 3){
system ("cls");
cabecalho ();
printf ("\n\n%d não é uma opção válida.\n", opcao);
printf ("Por favor, escolha 1, para jogar, 2 para informações ou 3 para sair.\n\n");
printf ("---> ");
valorDoScanf = 0;
mensagemDeErro = 0;
do{
if(mensagemDeErro >= 1){
printf("\nVocê deve digitar um número inteiro entre 1 e 3.\n\n--->");
}
fflush(stdin);
valorDoScanf = scanf ("%d", &opcao);
mensagemDeErro++;
} while(valorDoScanf == 0);
}
}
// insereDisciplina: enfileira a disciplina informada na fila
void insereDisciplina(tFila *f){
tDisciplina disciplina;
cabecalho("Cadastro");
printf("\t\tCodigo: ");
fflush(stdin);
scanf("%d", &disciplina.codigo);
printf("\t\tNome da Disciplina: ");
fflush(stdin);
gets(disciplina.nome);
printf("\t\tCarga Horaria: ");
fflush(stdin);
scanf("%f", &disciplina.cargaHoraria);
// enfileira a disciplina na fila
enfileira(disciplina, f);
}
int main(){
//union
FILE *arq, *arq2; //Ponteiros para arquivos
int valor_reg, tam_registro, pos_inicial_regis;
pos_inicial_regis = valor_reg = tam_registro = 0;
tp_buffer *bufferpoll = (tp_buffer*)malloc(sizeof(tp_buffer)*PAGES);
initbuffer(bufferpoll);
arq = fopen("file/meta.dat", "r");
if(arq == NULL){
printf("Read Error\n");
return 0;
}
fread(&valor_reg, sizeof(int), 1, arq);
tp_table *s = (tp_table*)malloc(sizeof(tp_table)*valor_reg); //Aloca um vetor com o numero de colunas da tupla
tam_registro = load_metadata(arq, s, valor_reg);
fclose(arq);
arq2 = fopen("file/data.dat", "r");
if(arq2 == NULL){
printf("Read Error\n");
return 0;
}
load_data(arq2, bufferpoll, tam_registro);
fclose(arq2);
//para imprimir
//printbufferpoll(bufferpoll, s, 0, valor_reg); //Parametros são: buffer, estrutura dos meta dados, página a ser impressa e quantos campos tem a "tabela"
cabecalho(s, valor_reg);
pos_inicial_regis = 1 * tam_registro;
drawline(bufferpoll, s, valor_reg, &pos_inicial_regis, 0); // (buffer, meta, numero de campos, posicao inicial, pagina)
printf("\n");
free(s);
free(bufferpoll);
return 0;
}
