API tools faq
paste
Advertisement
FoxTuGa

Student_Manag

FoxTuGa
Oct 29th, 2011
126
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 20.85 KB | None | 0 0
raw download clone embed print report
  1. /* Leandro Soares - 26/10/2011 */
  2. /* Programa completo, testado e comentado. */
  3.  
  4. #include <stdio.h>
  5. #include <stdlib.h>
  6. #include <conio.h>
  7. #include <string.h>
  8. #include <time.h>
  9. #include <ctype.h>
  10.  
  11. #define TRUE 1
  12.  
  13. typedef struct {    // Funcao onde é guardada a data.
  14.     int dia;
  15.     int mes;
  16.     int ano;
  17. }tagData;
  18.  
  19. typedef struct {    //Funcao membro onde é guardada uma nota e os campos respectivos.
  20.     char sigla[4];
  21.     int modulo;
  22.     int cla;
  23.     tagData data;
  24. }tagNota;
  25.  
  26. typedef struct {    // Funcao lider.
  27.     char nome[20];
  28.     int num;
  29.     tagNota notas[91];
  30.     int qtd;
  31. }tagAlunos;
  32.  
  33.  
  34. /* Prototipos de funcoes */
  35. tagAlunos AskName_and_Num(tagAlunos Aluno); // Funcao que pede o nome e o numero do Aluno.
  36. char Menu(void); // Funcao Menu, faz return de um char que representa uma accao.
  37. tagAlunos InserirNota(tagAlunos Aluno, char Siglas[][4]);   // Funcao para inserir uma nota.
  38. void PreencherSiglas(char Siglas[][4]); // Funcao para preencher as siglas das disciplinas.
  39. tagAlunos PreencherStructAlunos(tagAlunos Aluno); // Preencher/inicializar a estructura Aluno do tipo tagAlunos.
  40. void VerificarModulo(tagAlunos Aluno, char sig[4], int nmod, int Array[]);
  41. /* Verificar se o modulo da disciplina introduzida, está disponivel. Array[] é uma array controladora,
  42. indice(0) controla se está disponivel, indice(1) controla em que posição está disponivel.*/
  43. void PAUSA(void); // Similar ao system("pause");
  44. void InserirData_Lanc(int datas[3]); // Inserir a data de lançamento das notas.
  45. int VerificarDia(int dia, int Dia_do_mes); // Verificar se o dia está em ordem.
  46. int Verificar_7Dias(int dia, int mes, int ano); // Verificar se o dia/mes/ano correspondem com a regra dos 7 dias antes.
  47. int Dias_do_Mes(int mes, int ano); // A funcao retorna quantos dias tem o mes em questão.
  48. int VerificarSiglas(char ctemp[], char siglas[][4]); // Funcao que verifica se a sigla introduzida está bem introduzida.
  49. tagAlunos ApagarNota(tagAlunos Aluno,char Siglas[][4]); // Funcao principal para apagar uma nota.
  50. void PedirSigla(char sigla[]); // Funcao que pede uma sigla (disciplina).
  51. tagAlunos ApagarN(tagAlunos Aluno, int startidx); // Funcao que apaga (puxa todas as variaveis da direita para a esquerda).
  52. float MediaPos_e_ModAtraso(tagAlunos Aluno, char Siglas[][4], int control[]); // Calcular a Media de todas as disciplinas e modulos em atraso.
  53. int MediaDisciplina(tagAlunos Aluno, char Sigla[4], int control[]); // Calcular Media por disciplina.
  54. int MaxModulos(int modulo, int indice); // Calcular o maximo de modulos que cada disciplina tem.
  55.  
  56.  
  57. int main() {
  58.     /* Declaracoes */
  59.     tagAlunos Aluno = { "\0", -1 };
  60.     char op = '\0';
  61.     char Siglas[11][4], sig[4];
  62.     int control[2], idx, negativas;
  63.     float media;
  64.     /* Fim de Declaracoes */
  65.  
  66.     /* Inicializacoes */
  67.     media = 0.0;
  68.     control[0] = 0; // Notas positivas.
  69.     control[1] = 0; // Notas negativas.
  70.     idx = negativas = 0;
  71.  
  72.     PreencherSiglas(Siglas);
  73.     Aluno = PreencherStructAlunos(Aluno);
  74.     Aluno = AskName_and_Num(Aluno); // Leitura do nome e numero do Aluno.
  75.     /* Fim de Inicializacoes */
  76.  
  77.     /* Menu principal */
  78.     while(TRUE) {
  79.         op = Menu();
  80.         if( op == 't' ) // Se op = "t", o programa faz exit.
  81.             break;
  82.         if( op == 'q' ) { // Se op = "q" o programa solicita a entrada de uma nota.
  83.             if( Aluno.qtd == 90 ) { // Se ja foram introduzidas 90 notas, o programa deixa de receber novas notas.
  84.                 system("cls");
  85.                 printf("Numero maximo de notas atingido!!!");
  86.                 continue;
  87.             }
  88.             Aluno = InserirNota(Aluno, Siglas); // Inserir uma nota.
  89.             Aluno.qtd++; // Incrementar o controlo de notas.
  90.         }
  91.         else    if( op == 'w' ) { // Se op = "w", o programa permite apagar uma nota.
  92.             if( Aluno.qtd == 0 ) { // Se nao houverem notas introduzidas, nao se pode apagar uma nota.
  93.                 system("cls");
  94.                 printf("Numero minimo de notas atingido!!!");
  95.                 continue;
  96.             }
  97.             Aluno = ApagarNota(Aluno, Siglas); // Apagar um nota.
  98.             Aluno.qtd--; // Decrementar o controlo de notas.
  99.         }
  100.         else    if( op == 'e' ) { // Se, op = "e", o programa calcula a media do aluno.
  101.             media = MediaPos_e_ModAtraso(Aluno, Siglas, control); // Esta funcao retorna a soma das medias de todas as disciplinas.
  102.             /* control[0] sao as positivas */
  103.             /* control[1] sao as negativas */
  104.             system("cls");
  105.             printf("Media: %.2f\n", media);
  106.             printf("Modulos em Atraso: %d\n", control[1]);
  107.             PAUSA();
  108.         }
  109.         else    if( op == 'r' ) { // Se op = "r", o programa calcula a media de cada disciplina.
  110.             system("cls");
  111.             for(idx=0; idx < 11; idx++) { // Corre o ciclo 11 vezes (o numero de disciplinas).
  112.                 /* Idx, representa o indice que depois e usado na array bidimensional Siglas
  113.                 que e onde esta situado cada disciplina.*/
  114.                 media = MediaDisciplina(Aluno, Siglas[idx], control); // Retorna a media da disciplina introduzida.
  115.                 if( media != 0 || control[1] != 0 ) {
  116.                     printf("%s\n", Siglas[idx]); // Output da Disciplina.
  117.                     if( media != 0 )
  118.                         printf("\tMedia: %.2f\n", media); // Output da media.
  119.                     else    if( control[1] != 0 )
  120.                         printf("\tModulos em Atraso: %d", control[1]); // Output dos modulos em atraso.
  121.                 }
  122.                 PAUSA();
  123.             }
  124.         }
  125.     }
  126.     return 0;
  127. }
  128.  
  129. char Menu(void) {
  130.     /* Declaracoes */
  131.     char op = '\0';
  132.     tagAlunos Aluno;
  133.  
  134.     system("cls");
  135.     /* Ciclo que mostra o Menu ate ser pressionada uma das teclas: (q,w,e,r,t) */
  136.     while(op != 'q' && op != 'w' && op != 'e' && op != 'r' && op != 't') {
  137.         printf("\t\t\tMenu\n\n");
  138.         printf("q - Inserir uma nota.\n");
  139.         printf("w - Apagar uma nota.\n");
  140.         printf("e - Media das notas e o numero de modulos em atraso.\n");
  141.         printf("r - Media por disciplina.\n\n");
  142.         printf("t - Sair\n");
  143.         fflush(stdin);
  144.         op = getch(); // Leitura do char controlador do menu.
  145.         system("cls");
  146.     }
  147.  
  148.     return op; // Retorno do char "op" para a Main().
  149. }
  150.  
  151. tagAlunos PreencherStructAlunos(tagAlunos Aluno) {
  152.     /* Declaracoes */
  153.     int idx;
  154.  
  155.     /* Ciclo que roda as Notas para Inicializar */
  156.     for(idx=0; idx < 91; idx++) {
  157.         Aluno.notas[idx].cla = 0;
  158.         Aluno.notas[idx].modulo = -1;
  159.         strcpy(Aluno.notas[idx].sigla, "\0");
  160.         Aluno.notas[idx].data.dia = -1;
  161.         Aluno.notas[idx].data.mes = -1;
  162.         Aluno.notas[idx].data.ano = -1;
  163.     }
  164.     strcpy(Aluno.nome, "\0"); // Inicilizar o nome.
  165.     Aluno.num = -1; // Inicilizar o numero.
  166.     Aluno.qtd = 0; // Inicializar a quantidade de notas.
  167.     return Aluno;
  168. }
  169.  
  170. tagAlunos AskName_and_Num(tagAlunos Aluno) {
  171.     /* Leitura do Nome */
  172.     printf("Nome: ");
  173.     fflush(stdin);
  174.     gets(Aluno.nome);
  175.     system("cls");
  176.  
  177.     /* Leitura do Numero */
  178.     printf("Numero: ");
  179.     fflush(stdin);
  180.     scanf("%d", &Aluno.num);
  181.  
  182.     system("cls");
  183.     return Aluno; // Retorno da estructura Aluno.
  184. }
  185.  
  186. void PreencherSiglas(char Siglas[][4]) {
  187.     /* Inicializacao a array bidimensional Siglas[][]. */
  188.     // 11 Disciplinas.
  189.     strcpy(Siglas[0], "PT");
  190.     strcpy(Siglas[1], "MAT");
  191.     strcpy(Siglas[2], "FQ");
  192.     strcpy(Siglas[3], "PSI");
  193.     strcpy(Siglas[4], "AC");
  194.     strcpy(Siglas[5], "RC");
  195.     strcpy(Siglas[6], "EF");
  196.     strcpy(Siglas[7], "SO");
  197.     strcpy(Siglas[8], "AI");
  198.     strcpy(Siglas[9], "ING");
  199.     strcpy(Siglas[10], "TIC");
  200. }
  201.  
  202. /* Funcoes Globais */
  203. void PAUSA(void) {
  204.     /* Similar ao system("pause"); */
  205.     printf("Clique numa tecla para continuar...");
  206.     fflush(stdin);
  207.     getch();
  208. }
  209.  
  210. int VerificarSiglas(char ctemp[], char siglas[][4]) {
  211.     /* Verificacao das Siglas */
  212.     int temp;
  213.     for(temp=0; temp < 11; temp++) { // Ciclo que corre 12x
  214.         if( !stricmp(ctemp, siglas[temp]) ) // Se a Sigla introduzida for igual a uma das Siglas da array bidimensional, entra no if().
  215.             return temp; // Se a Sigla coincidir com alguma da array bidimensional, entao retorna 1.
  216.     }
  217.     return -1; // Se a sigla nao coincidir com nenhuma, retorna 0.
  218. }
  219.  
  220. void PedirSigla(char sigla[]) {
  221.     /* Funcao que pede uma sigla */
  222.     char sig[4];
  223.  
  224.     system("cls");
  225.     printf("Sigla: ");
  226.     fflush(stdin);
  227.     gets(sig);
  228.  
  229.     strcpy(sigla, sig); // Copia a sigla da string temporaria (sig) para a string do parametro (sigla).
  230. }
  231.  
  232. void VerificarModulo(tagAlunos Aluno, char sig[4], int nmod, int Array[]) {
  233.     /* Declaracoes e Inicizalicao*/
  234.     int idx, end;
  235.     end = 0;
  236.  
  237.     /* Ciclo que compara as 90 notas e verificar se alguma das notas e modulos coincidem com as inseridas. */
  238.     for(idx=0; idx < 90; idx++) {
  239.         if( !stricmp(Aluno.notas[idx].sigla, sig) ) {
  240.             if( nmod != Aluno.notas[idx].modulo )
  241.                 continue;
  242.             else {
  243.                 end = 1; // Se aquele modulo/sigla ja tiver sido usado, entao "retorna" 1.
  244.                 break;
  245.             }
  246.         }
  247.     }
  248.     Array[0] = end; // 1 - Usado; 0 - Nao Usado.
  249.     Array[1] = idx; // Se ja foi usado, contem o valor de idx onde foi encontrada a coincidencia.
  250. }
  251.  
  252. int MaxModulos(int modulo, int indice) {
  253.     /* Declaracao e Inicializacao */
  254.     int controlo;
  255.     controlo = 0;
  256.  
  257.     /* Cada disciplina tem um numero determinado de modulos,
  258.     por isso, precisamos de algo que retorne o numero de modulos
  259.     existentes em cada disciplina.*/
  260.     switch(indice) {
  261.     case 1: controlo = 12; break;
  262.     case 2: controlo = 10; break;
  263.     case 3: controlo = 8; break;
  264.     case 4: controlo = 19; break;
  265.     case 5: controlo = 5; break;
  266.     case 6: controlo = 8; break;
  267.     case 7: controlo = 16; break;
  268.     case 8: controlo = 5; break;
  269.     case 9: controlo = 6; break;
  270.     case 10: controlo = 9; break;
  271.     case 11: controlo = 3; break;
  272.     }
  273.  
  274.     return controlo;
  275. }
  276. /* Fim de Funcoes Globais */
  277.  
  278. /* Inserir Notas */
  279. tagAlunos InserirNota(tagAlunos Aluno, char Siglas[][4]) {
  280.     /* Declaracoes */
  281.     char ctemp[4], ask;
  282.     int nmod, subidx, classific, ControloMaxMod, ControloMods;
  283.     int data[3], Controladorqtd[2];
  284.     /* Controladorqtd[0], varia entre 1 e 0, que controla se um modulo está disponivel ou não.
  285.     Controladorqtd[1], varia entre 0 e 90, que contem o indice da nota onde se encontra o modulo. */
  286.  
  287.     /* Inicializacoes */
  288.     nmod = subidx = classific = ControloMods = ControloMaxMod = 1;
  289.     ask = 'y';
  290.  
  291.     /* Ciclo Principal */
  292.     while(TRUE) {
  293.         PedirSigla(ctemp); // Leitura temporaria da sigla introduzida.
  294.  
  295.         /* Comparacao da sigla introduzida com as siglas possiveis. */
  296.         ControloMods = VerificarSiglas(ctemp, Siglas)+1;
  297.  
  298.         system("cls");
  299.         if(ControloMods != -1) { // Se a sigla introduzida coincidir com alguma das possiveis opcoes, avança.
  300.             /* Leitura do Numero do Modulo */
  301.             printf("Numero do Modulo: ");
  302.             scanf("%d", &nmod);
  303.  
  304.             /* Obtencao do numero max de modulos que a disciplina tem */
  305.             ControloMaxMod = MaxModulos(nmod, ControloMods);  
  306.             if( nmod > 0 && nmod <= ControloMaxMod ) { // Se o numero do modulo estiver em ordem, avançar.
  307.                 /* Verifica se o modulo introduzido esta disponivel atraves de Controladorqtd[0] */
  308.                 /* Controladorqtd[1] serve para indicar o indice que está disponivel. */
  309.                 VerificarModulo(Aluno, ctemp, nmod, Controladorqtd);
  310.                 if( Controladorqtd[0] ) { // Se o Modulo ja tiver sido preenchido, avançar.
  311.                     while(ask != 'y' || ask != 'n' ) {
  312.                         system("cls");
  313.                         printf("Nota ja existente, pretende substituir? y/n");
  314.                         fflush(stdin);
  315.                         ask = getch();
  316.                         system("cls");
  317.                         if ( ask == 'n' ) {
  318.                             return Aluno; // Acabar de inserir a nota, sem inserir uma nota.
  319.                         }
  320.                         if( ask == 'y' ) {
  321.                             /* Continuar a substituir a nota */
  322.                             subidx = Controladorqtd[1]; // subidx e o indice para substituir, ou introduzir uma nota.
  323.                             break;
  324.                         }
  325.                     }
  326.                 }
  327.                 else {
  328.                     /* Se o modulo estiver disponivel, entao o indice para introduzir a nota e igual a quantidade
  329.                     de notas ja existente (nao e Aluno.qtd+1, porque começa no 0)*/
  330.                     subidx = Aluno.qtd;
  331.                 }
  332.                 while(TRUE) {
  333.                     /* Introducao da classificacao */
  334.                     system("cls");
  335.                     printf("Classificacao: ");
  336.                     scanf("%d", &classific);
  337.  
  338.                     /* Verificar se a classificacao esta entre 0 e 20 */
  339.                     if( classific < 0 || classific > 20 ) {
  340.                         /* Se a classificao nao estiver correcta entao, e perguntado
  341.                         ao utilizador se quer acabar o programa. */
  342.                         while(ask != 'y' && ask != 'n') {
  343.                             system("cls");
  344.                             printf("Tem de ser entre 0 e 20!!\n\n");
  345.                             PAUSA();
  346.                             system("cls");
  347.                             printf("Pretende sair? y/n");
  348.                             fflush(stdin);
  349.                             ask = getch();
  350.  
  351.                         }
  352.                         if(ask == 'y')
  353.                             return Aluno; // Acabar de inserir a nota, sem inserir uma nota.
  354.                     }
  355.                     else
  356.                         break;
  357.                 }
  358.  
  359.                 /* Insercao das variaveis temporarias nas variaveis da estrutura. */
  360.                 InserirData_Lanc(data); // Inserir a data de lancamento da nota.
  361.  
  362.                 strcpy(Aluno.notas[subidx].sigla, ctemp);
  363.                 Aluno.notas[subidx].modulo = nmod;
  364.                 Aluno.notas[subidx].cla = classific;
  365.                 Aluno.notas[subidx].data.dia = data[0];
  366.                 Aluno.notas[subidx].data.mes = data[1];
  367.                 Aluno.notas[subidx].data.ano = data[2];
  368.                 /* Fim de insercao */
  369.                 break;
  370.             }
  371.             else {
  372.                 /* Se o numero do modulo introduzido nao estiver correcto entao,
  373.                 aparece uma mensagem de erro e repete o ciclo de introducao
  374.                 de uma nota. */
  375.                 system("cls");
  376.                 printf("\n ERRO: tem de ser entre 0 e %d\n\n", ControloMaxMod);
  377.                 PAUSA();
  378.             }
  379.         }
  380.     }
  381.  
  382.     system("cls");
  383.     return  Aluno;
  384. }
  385.  
  386. void InserirData_Lanc(int datas[3]) {
  387.     /* Funcao para introduzir a data de lancamento de uma nota. */
  388.     /* Declaracoes e Inicializacoes */
  389.     int diatemp, mestemp, anotemp, dia_do_mes;
  390.     diatemp = mestemp = anotemp = 0;
  391.  
  392.     /* Corre um ciclo, enquanto as datas introduzidas nao estiverem correctas */
  393.     while(TRUE) {
  394.         system("cls");
  395.         printf("Dia: ");
  396.         scanf("%d", &diatemp);
  397.  
  398.         printf("Mes: ");
  399.         scanf("%d", &mestemp);
  400.  
  401.         printf("Ano: ");
  402.         scanf("%d", &anotemp);
  403.  
  404.         dia_do_mes = Dias_do_Mes(mestemp, anotemp); // Quantos dias tem o mes introduzido.
  405.         system("cls");
  406.  
  407.         /* Verifica se o dia introduzio, esta em ordem com o dia maximo possivel. */
  408.         if( VerificarDia(diatemp, dia_do_mes ) ) {
  409.  
  410.             /* Verifica se a data introduzida, repeita com a regra dos 7 dias, isto e,
  411.             se a data vai ate a um maximo de 7 dias antes da data actual. */
  412.             if( Verificar_7Dias(diatemp, mestemp, anotemp) ) {
  413.                 /* Insercao da data temporaria na data da nota situada na estrutura. */
  414.                 datas[0] = diatemp;
  415.                 datas[1] = mestemp;
  416.                 datas[2] = anotemp;
  417.                 break;
  418.             }
  419.             else {
  420.                 /* Se a data nao respeitar a regra dos 7 dias, aparece uma mensagem de erro
  421.                 e pede ao utilizador para introduzir a data novamente. */
  422.                 printf("No maximo tem de ser 7 dias !!\n\n");
  423.                 PAUSA();
  424.             }
  425.         }
  426.         else {
  427.             /* Se o dia nao estiver entre 1 e o dia maximo do mes,
  428.             aparece uma mensagem de erro e volta a pedir a insercao
  429.             da data. */
  430.             printf("ERRO!!\n\n");
  431.             PAUSA();
  432.         }
  433.     }
  434.     system("cls");
  435. }
  436.  
  437. int Dias_do_Mes(int mes, int ano) {
  438.     /* Esta funcao serve para retornar a quantidade de dias que um determinado mes tem. */
  439.     int dias;
  440.     if( mes == 1 || mes == 3 || mes == 5 || mes == 7 || mes == 8 || mes == 10 || mes == 12 ) // Meses 31.
  441.         dias = 31;
  442.     else    if( mes == 2 ) { // Fevereiro (28 ou 29).
  443.         if( ( (!(ano % 4)) && (ano % 100) ) || (!(ano % 400)) ) // Ano bissexto ou nao.
  444.             dias = 29; // Bissexto, Fevereiro 29.
  445.         else
  446.             dias = 28; // Nao Bissexto, Fevereiro 28.
  447.     }
  448.     else // Restantes meses, 30.
  449.         dias = 30;
  450.     return dias;
  451. }
  452.  
  453. int VerificarDia(int dia, int Dia_do_mes) {
  454.     /* Retorna se o dia esta dentro dos parametros desejaveis. */
  455.     return (dia > 0 && dia < Dia_do_mes+1) ? 1 : 0; // 1-TRUE, 0-FALSE.
  456. }
  457.  
  458. int Verificar_7Dias(int dia, int mes, int ano) {
  459.     /* Funcao para verificar se a data respeita a regra dos 7 dias, isto e,
  460.     se a data vai ate a um maximo de 7 dias antes da data actual. */
  461.  
  462.     /* Declaracoes e Inicializacoes */
  463.     int count, diatemp, mestemp, anotemp, end;
  464.     time_t ltime;
  465.     struct tm *today;
  466.  
  467.     time(&ltime);
  468.     today =  localtime(&ltime);
  469.  
  470.     diatemp = today->tm_mday;
  471.     mestemp = today->tm_mon+1;
  472.     anotemp = today->tm_year+1900;
  473.     end = 0;
  474.  
  475.     /* Ciclo que corre 7 vezes (7dias).
  476.     Vai decrementando o dia, como consequencia o mes e tambem o ano
  477.     se necessario, e compara se a data introduzida coincide com alguma
  478.     das 7 opcoes que o ciclo da. */
  479.     for(count = 0; count < 7; count++) {
  480.  
  481.         /* Se a data coincidir com alguma das que o ciclo deu. */
  482.         if( diatemp == dia && mestemp == mes && anotemp == ano ) {
  483.             end = 1; // end = 1, significa que a data respeita a regra dos 7 dias.
  484.             break;
  485.         }
  486.         /* Se o dia nao coincidir com nenhum e entao decrementado. */
  487.         if(diatemp != 0 )
  488.             diatemp--;
  489.         else {
  490.             /* Se o dia chegar a 0, entao o mes e decrementado e o
  491.             dia e inicializado com o numero de dias maximo do mes. */
  492.             diatemp = Dias_do_Mes(mestemp, anotemp);
  493.             if(mestemp != 0 )
  494.                 mestemp--; // Decrementacao do mes.
  495.             else {
  496.                 /* Se o mes chegar a 0, entao o ano e decrementado e o
  497.                 mes e inicializado com o maximo numero de meses existente. */
  498.                 anotemp--;
  499.                 mestemp = 12;
  500.             }
  501.         }
  502.     }
  503.  
  504.     return end;
  505. }
  506. /* Fim de Inserir Notas */
  507.  
  508. /* Apagar Notas */
  509. tagAlunos ApagarNota(tagAlunos Aluno,char Siglas[][4]) {
  510.     /* Funcao para apagar uma nota. */
  511.  
  512.     /* Declaracoes e Inicializacoes */
  513.     int idx, ControloMods, controlqtd[2], nmod, ControloMaxMod;
  514.     char sig[4];
  515.  
  516.     ControloMods = idx = nmod = ControloMaxMod = 0;
  517.  
  518.     /* Pede uma sigla e o ciclo nao acaba enquanto a sigla
  519.     nao estiver correctamente introduzida. */
  520.     while( ControloMods != -1) {
  521.         PedirSigla(sig);
  522.         ControloMods = VerificarSiglas(sig, Siglas)+1;
  523.     }
  524.  
  525.     while( TRUE ) {
  526.         system("cls");
  527.         /* Introducao do numero do modulo. */
  528.         printf("Numero do Modulo: ");
  529.         scanf("%d", &nmod);
  530.  
  531.         /* Verificacao do numero maximo de modulos que cada disciplina tem. */
  532.         ControloMaxMod = MaxModulos(nmod, ControloMods);
  533.         if(nmod > 0 && nmod <= ControloMaxMod) {
  534.             /* Funcao para obter o indice onde esta situado a nota que se quer apagar,
  535.             o indice fica situado em controlqtd[1]. */
  536.             /* controlqtd[0], serve para verificar se a nota existe ou nao, sendo que,
  537.             1 significa que existe e 0 que nao existe. */
  538.             VerificarModulo(Aluno, sig, nmod, controlqtd);
  539.             if( controlqtd[0] == 1 ) {
  540.                 /* Funcao para copiar as notas da direita para a esquerda, isto e,
  541.                 apagar uma nota. */
  542.                 Aluno = ApagarN(Aluno, controlqtd[1]);
  543.                 break;
  544.             }
  545.         }
  546.         else {
  547.             /* Se o modulo nao estiver entre 0 e o numero max de modulos, aparece
  548.             uma mensagem de erro e reinicia o ciclo. */
  549.             system("cls");
  550.             printf("Tem de ser entre 0 e %d!!!\n\n", ControloMaxMod);
  551.             PAUSA();
  552.             continue;
  553.         }
  554.     }
  555.     return Aluno;
  556. }
  557.  
  558. tagAlunos ApagarN(tagAlunos Aluno, int startidx) {
  559.     /* Funcao para copiar as notas da direita para a esquerda
  560.     na array. */
  561.     int idx;
  562.  
  563.     /* Copiar as notas da direita para a esquerda enquanto
  564.     nao for encontrado um char '\0' no primeiro indice da sigla. */
  565.     for(idx = startidx; Aluno.notas[idx].sigla[0] != '\0' ; idx++) {
  566.         strcpy(Aluno.notas[idx].sigla, Aluno.notas[idx+1].sigla);
  567.         Aluno.notas[idx].modulo = Aluno.notas[idx+1].modulo;
  568.         Aluno.notas[idx].cla = Aluno.notas[idx+1].cla;
  569.         Aluno.notas[idx].data.dia = Aluno.notas[idx+1].data.dia;
  570.         Aluno.notas[idx].data.mes = Aluno.notas[idx+1].data.mes;
  571.         Aluno.notas[idx].data.ano = Aluno.notas[idx+1].data.ano;
  572.     }
  573.  
  574.     return Aluno;
  575. }
  576.  
  577. /* Media das Notas Positivas e Numero de Modulos em Atraso */
  578. float MediaPos_e_ModAtraso(tagAlunos Aluno, char Siglas[][4], int control[]) {
  579.     /* Funcao para obter e escrever a media do aluno. */
  580.  
  581.     /* Declaracoes e Inicializacoes */
  582.     int idx, positivastotais;
  583.     float mediatemp;
  584.  
  585.     mediatemp = 0.0;
  586.     positivastotais = 0;
  587.     control[0] = 0; // Modulos Positivos.
  588.     control[1] = 0; // Modulos Negativos.
  589.  
  590.     /* Se nao houver notas */
  591.     if( Aluno.qtd == 0 )
  592.         printf("Nao existem Notas!!");
  593.  
  594.     system("cls");
  595.     /* Soma a media de cada uma das 12 disciplinas. */
  596.     for(idx=0; idx < 11 ;idx++) {
  597.         mediatemp += MediaDisciplina(Aluno, Siglas[idx], control);
  598.         positivastotais += control[0]; // Incrementacao de positivas para divisao futura.
  599.     }
  600.     /* Como nao se pode dividir por 0 */
  601.     if( positivastotais == 0 )
  602.         return 0;
  603.  
  604.     /* Se as positivas forem diferente de 0 */
  605.     return (mediatemp / positivastotais);
  606. }
  607.  
  608. int MediaDisciplina(tagAlunos Aluno, char Sigla[4], int control[]) {
  609.     /* Funcao para calcular a media de uma disciplina. */
  610.  
  611.     /* Declaracoes e Iniciaizacoes */
  612.     int idx, temp, positivas, negativas;
  613.     temp = positivas = negativas = 0;
  614.  
  615.     /* Ciclo que soma as classificacoes da disciplina. */
  616.     for(idx=0; idx < 90 ; idx++) {
  617.         /* Verifica se a sigla da disciplina introduzida é igual
  618.         a sigla da nota cujo indice e idx.*/
  619.         if( !stricmp(Aluno.notas[idx].sigla,Sigla) ) {
  620.             if( Aluno.notas[idx].cla >= 10 ) {
  621.                 /* Se a nota for positiva, entao, temp soma a
  622.                 classificacao a si mesma. */
  623.                 temp += Aluno.notas[idx].cla;
  624.                 positivas++; // Incrementacao das notas positivas.
  625.             }
  626.             else {
  627.                 /* Se a nota for negativas, entao a variavel de controlo
  628.                 de negativas e incrementada. */
  629.                 negativas++;
  630.             }
  631.         }
  632.         if( Aluno.notas[idx].sigla[0] == '\0' ) {
  633.             /* Se o primeiro indice da sigla for '\0' entao significa que
  634.             o resto das notas no array, estao vazias. */
  635.             break;
  636.         }
  637.     }
  638.  
  639.     control[0] = positivas;
  640.     control[1] = negativas;
  641.     /* Como nao se pode dividir por 0 */
  642.     if( positivas == 0 )
  643.         return 0;
  644.  
  645.     /* Se as positivas forem diferente de 0, entao retorna a soma das
  646.     classificacoes pelas positivas. */
  647.     return temp / positivas;
  648. }
  649.  
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!