Problema com a ordem dos procedimentos

[Knectus 0]

Boas ..

É a primeira vez que me registo, mas já utilizo o site ao tempo, gosto bastante da organização.

Preciso de uma ajudinha com um trabalho pendente á cerca de uma semana,

tenho poucos dias mais para acabar e venho aqui como ultimo recurso, gosto de tentar sempre sozinho,

mas visto que cheguei a um ponto sem saida venho aqui pedir ajuda.

É o seguinte, eu preciso de elabora um programa em Pascal para controlar as notas dos testes, mas infelizmente a ordem dos procedimentos não corresponde, sei que tenho alguns erros amadores que preciso de corrigir, mas o que realmente necessitava era fazer de maneira que o compilador leia numa ordem correcta os procedimentos.

Desde Já muito obrigado pela atenção 

O programa deve:

  - Trabalhar com uma matriz para guardar as notas de cada módulo a cada disciplina.

  (Considerar 10 disciplinas com 6 módulos cada)    ---- FEITO ----

 

  - Permitir consultar as notas de determinado módulo de determinada disciplina  --- FEITO ---

 

  - Mostrar os módulos (e respectivas disciplinas) não concluidos --- POR FAZER ---

 

  - Calcular a média de notas dos módulos por disciplina  --- POR FAZER ---

 

  - Outras funções que aches úteis --- QUASE FEITO ---

" var a: integer;
c:char;
nota:array [1..10,1..6] of integer ;
dis:integer;

Procedure Linha;
	var i : integer;
  Begin
   for i:= 1 to 80 do
   write('-');
  end;
  
  
   Procedure InserirModulo;
	var	im:integer;
	begin
		writeln('Escolha qual o Modulo que quer inserir a nota (1 - 7)');
  		readln (IM);
	     case im of
    			1 : begin
		     writeln('Primeiro Modulo');
    			     readln (nota[dis,1]);
    			    end;
    			2 : begin
		     writeln('Segundo Modulo');
   	 		     readln (nota[dis,2]);
   	 		    end;
   	 		3 : begin
		     writeln('Terceiro Modulo');
   	 		     readln (nota[dis,3]);
   	 		    end;
   	 		4 : begin
		     writeln('Quarto Modulo');
   	 		     readln (nota[dis,4]);
   	 		    end;
    			5 : begin
		     writeln('Quinto Modulo');
   	 		     readln (nota[dis,5]);
   	 		    end;
    			6 : begin
		     writeln('Sexto Modulo');
    			     readln (nota[dis,6]);
    			    end;
    			7 : begin
		     writeln('Setimo Modulo');
    			     readln (nota[dis,7]);
    			    end;
    		end;
     end;
  
Procedure InserirDisciplina;
 Begin
		 write(' Qual é a Disciplina que quer Inserir a Nota do Modulo? ');
		 writeln;
		 writeln;
	 writeln('---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+');
	 writeln('--   1 Português | 2 Area de Integraçao | 3 Inglês     +---+');
		 writeln('---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+');
		 writeln('--   4 Matematica | 5 Fisico/Quimica | 6 TIC    ---+---+---+');
		 writeln('---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+');
		 writeln('--   7 Sistemas Operativos | 8 Redes | 9 PSI   ----+---+---+');
		 writeln('---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+');
		 writeln('--   10 Educação Fisica |   ---+---+---+---+---+---+---+---+');
		 writeln('---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+');
		 readln(a);
  		 writeln;
   case a of
    	1 : begin 
     writeln('Disciplina: Portugues');
          dis:=1 
    end;
    	2 : begin
     writeln('Disciplina: Area De Integração');
          dis:=2
         end;
    	3 : begin 
     writeln('Disciplina: Inglês');
    	     dis:=3;
    	    end;
    	4 : begin 
     writeln('Disciplina: Matematica');
    	     dis:=4;
    	    end;
    	5 : begin
     writeln('Disciplina: Fisico/Quimica');
    	     dis:=5;
    	    end;
    	6 : begin
     writeln('Disciplina: TIC');
    	     dis:=6;
    	    end;
    	7 : begin
     writeln('Disciplina: Sistemas Operativos');
    	     dis:=7;
    	    end;
    	8 : begin
     writeln('Disciplina: Redes');
    	     dis:=8;
    	    end;
    	9 : begin
     writeln('Disciplina: Programaçao de Sistemas Operativos');
    	     dis:=9;
    	    end;
    	10 : begin
      writeln('Disciplina: Educaçao Fisica');
    	      dis:=10;
    	     end;
   end;
   Inserirmodulo;
end;
     
     Procedure ReadModulo;
     var modulo:integer;
     	begin
     	 writeln ('Qual a Disciplina que deseja visualizar? ');
		 writeln;
		 writeln;
	 writeln('---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+');
	 writeln('--   1 Português | 2 Area de Integraçao | 3 Inglês     +---+');
		 writeln('---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+');
		 writeln('--   4 Matematica | 5 Fisico/Quimica | 6 TIC    ---+---+---+');
		 writeln('---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+');
		 writeln('--   7 Sistemas Operativos | 8 Redes | 9 PSI   ----+---+---+');
		 writeln('---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+');
		 writeln('--   10 Educação Fisica |   ---+---+---+---+---+---+---+---+');
		 writeln('---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+');
           readln (dis);
  		 writeln;
     		writeln ('Qual o Modulo que deseja visualizar? (1 - 7)');
     		readln (modulo);
		writeln ('A nota que teve foi:',nota[dis,modulo]);   		
     	end;
     	
     	Procedure MenuPrincipal ;
     		var X:integer;
     	 begin
     	 	writeln ('Escolha uma Opção :');
           	writeln (' 1 - Calcular a Media por Disciplina ');
           	writeln (' 2 - Inserir a nota de um Modulo ');
           	writeln (' 3 - Ler a nota de um Modulo ');
           	writeln (' 4 - Sair do Programa');
           	case x of
           		1 : writeln ('Em construção');
           		2 : InserirDisciplina;
           		3 : ReadModulo;
           		4 : exit;
           	end;
           end;

	    Procedure RepeatTeste;  
  begin   
    WriteLn ('Deseja voltar ao Inicio ou Sair do Programa?');
    writeln (' Pressione <S> para Sair ou <V> para Voltar ao Inicio.');  
     C := ReadKey;
    	if c = 'v' then
    begin
     	clrscr;  
     	MenuPrincipal;
     end
      else 
 exit;
    end;     	
     	
     	
begin
    dis:= 0;
    linha;
    Writeln('Bem vindo, este programa guarda as notas das suas disciplinas');  
    linha;
    writeln;
    MenuPrincipal;
    writeln;
end. "

PS: Tenho o programa por acabar, espero conseguir dentro de dias

[nunopicado 1,247]

Não percebi bem o teu problema...

Queres que o compilador leia os procedimentos numa determinada ordem?

Qual o motivo disto?

A única situação que me ocorre que isto possa interessar é quando os procedimentos chamam uns aos outros, e o de cima tem de chamar o de baixo... É isso?

Se assim for o que precisas é declarar os procedimentos antes de os fazeres (implementares).

Para isso usa-se por exemplo a palavra chave Forward:

program Project1;

uses
    crt;

procedure teste1;
begin
     writeln(1);
end;

procedure mostratudo;
begin
     teste1;
     teste2;
end;

procedure teste2;
begin
     writeln(2);
end;

begin
     clrscr;
     Writeln('Apenas Teste1');
     Teste1;
     readln;
     Writeln('Apenas Teste2');
     Teste2;
     readln;
     Writeln('Ambos os testes:');
     mostratudo;
     readln;
end. 

Este teste iria dar erro no procedure mostratudo, pois o procedure teste2 lá chamado ainda não foi declarado, logo, o compilador não o conhece.

Para resolver, basta uma linha:

program Project1;

uses
    crt;

procedure teste2;forward;
procedure teste1;
begin
     writeln(1);
end;

procedure mostratudo;
begin
     teste1;
     teste2;
end;

procedure teste2;
begin
     writeln(2);
end;

begin
     clrscr;
     Writeln('Apenas Teste1');
     Teste1;
     readln;
     Writeln('Apenas Teste2');
     Teste2;
     readln;
     Writeln('Ambos os testes:');
     mostratudo;
     readln;
end. 

Coloca-se então a primeira linha do procedimento que está "fora de ordem" antes de ser chamado a primeira vez, tal qual como está no próprio procedimento. À frente dele, coloca-se a palavra "forward;"

Assim o compilador, logo aí ao inicio, fica a saber que lá mais à frente vai ter um procedimento com aquele nome, pelo que já não dá erro.

Pessoalmente gosto de por os forwards logo a seguir às declarações de uses, constantes, tipos e variáveis e imediatamente antes de começar a escrever os procedimentos... Assim não há perigo de termos o forward depois de um procedimento que precise de chamar outro mais à frente.

Outra maneira de resolver isto é com as palavras interface e implementation, mas penso que para o caso não há necessidade de entrar por aí...

Se for outra coisa a tua duvida avisa...

[Knectus 0]

Muito Obrigado,

A minha duvida é essa mesma..

Mas o problema continua, é que eu sou obrigado a utilizar o compilador pzim, e a palavra chave "forward" não é reconhecido .. 

E sim, eu quero que o compilador leia os procedimentos por ordem, quero que o procedimento "MenuPrincipal" funcione ..

[nunopicado 1,247]

Até há pouco tempo eu não conhecia o PZim... Conheci recentemente e por várias pessoas que, sendo obrigadas a usá-lo por algum motivo, não conseguem depois fazer o seu trabalho simplesmente porque a linguagem pascal não foi completamente implementada...

Porque razão continuam professores a indicá-lo para mim é uma incógnita!

Já vi que o zim não tem nem o forward nem o interface/implementation, o que limita muito este tipo de operação.

Sugiro-te outra aproximação ao problema, caso o programa o permita...

Trata-se de uma alteração ao procedimento MenuPrincipal, por forma a que ele não tenha de ser chamado senão a primeira vez:

Procedure MenuPrincipal ;
var 
   X:char;
begin
     repeat    
           clrscr;
           linha;
           Writeln('Bem vindo, este programa guarda as notas das suas disciplinas');  
           linha;
           writeln;
           writeln ('Escolha uma Opção :');
           writeln (' 1 - Calcular a Media por Disciplina ');
           writeln (' 2 - Inserir a nota de um Modulo ');
           writeln (' 3 - Ler a nota de um Modulo ');
           writeln (' 4 - Sair do Programa');
           x:=readkey;
           case x of
                '1' : writeln ('Em construção');
                '2' : InserirDisciplina;
                '3' : ReadModulo;
           end;
     until x='4';
end;

Deste modo, o menuprincipal é executado apenas uma vez, quando arranca o programa. Lá dentro é criado um loop (repeat neste caso) que será executado enquanto não for escolhida a opção 4 (sair).

Dentro do loop, será então executado um ou outro procedimento conforme a opção do utilizador. Esse procedimento será executado, por exemplo, inserirdisciplina, e quando terminar, ainda estará dentro do loop, pois não chegou a sair dele. Deste modo, o menuprincipal corre durante toda a duração do programa.

Também o outro procedimento que tens, o repeatteste, deixa de ser necessário.

Espero que ajude...

[Knectus 0]

Ajudou bastante, obrigado

Acho que é pelo facto de ser totalmente em português, e ter uma aparência que incentiva mais os alunos a programar.

- Mas pessoalmente eu acho que não compensa, ate que é limitado ..

Eu actualizei o meu programa e ate que adoptei a sua ideia do repeat, com este novo procedimento:

      Procedure CalcularDisciplina;

        var i: integer;

        media:real;

        y:char;

  begin

    repeat;

  writeln;

  writeln ('Qual a disciplina que quer calcular a media?');

writeln;

writeln;

writeln('---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+');

writeln('--  1 Português | 2 Area de Integraçao | 3 Inglês    +---+');

writeln('---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+');

writeln('--  4 Matematica | 5 Fisico/Quimica | 6 TIC    ---+---+---+');

writeln('---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+');

writeln('--  7 Sistemas Operativos | 8 Redes | 9 PSI  ----+---+---+');

writeln('---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+');

writeln('--  10 Educação Fisica |  ---+---+---+---+---+---+---+---+');

writeln('---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+');

  read(dis);

  for i := 2 to 7 do

  begin

media:= nota[dis,1]+ nota[dis,i];

end;

writeln('A media da Disciplina é : ',media:2:2);

writeln;

writeln ('Quer voltar a fazer a media de uma disciplina? (S/N) ');

y:=readkey;

clrscr;

writeln;

  until y='n';  

end;

Encontrei um obstáculo mas na criação deste procedimento " Mostrar os módulos (e respectivas disciplinas) não concluídos ",

se tiver alguma ideia que possa partilhar eu agradeço

[nunopicado 1,247]

hmmmmm

Sugiro-te aí que faças antes de mais a inicialização da matriz:

procedure ResetMatriz;
var
   i,j:integer;
begin
        for i:=1 to 10 do
            for j:=1 to 7 do
                nota[i,j]:=-1;
end;

Este procedimento deverá ser chamado no programa principal, antes de chamares o menu principal. Podes colocá-lo onde tens a inicialização da variaval dis, e se quiseres, até podes passar a inicialização da variavel dis para dentro deste procedimento.

Depois, podes então criar um procedimento MostraInacabados. Algo deste género:

procedure MostraInacabados;
var
   i,j:integer;
   TotalmenteConcluida:boolean;
begin
       writeln('Listagem de módulos inacabados:');
       writeln;
       for i:=1 to 10 do
            begin
                    TotalmenteConcluida:=true;
                    Write('Disciplina ',i,': ');
                    for j:=1 to 7 do
                         if nota[i,j]=-1 then begin
                                                              if not TotalmenteConcluida then write(', ');
                                                              write(j);
                                                             TotalmenteConcluida:=false;
                                                      end;
                   if TotalmenteConcluida then writeln('Disciplina com todos os módulos concluídos!')
                                                      else writeln;
           end;
end;

A variavel TotalmenteConcluida tem aqui duas funções:

Por um lado, se chegar ao fim do loop FOR dos módulos (j:=1 to 7) sem ser alterada, é sinal que nenhum dos modulos tinha o valor -1, ou seja, já tinham todos alguma nota atribuida. Se isto acontecer, escreve essa informação em frente do numero/nome da disciplina.

Por outro lado, dá uma pequena ajuda ao escrever os módulos em falta. Como da primeira vez que um módulo em falta for escrito ela ainda terá um valor verdadeiro, mas a partir daí terá sempre um valor falso, usam-se para, caso tenha um valor falso (ou seja, já escreveu algum modulo anteriormente), escreve uma ',' para separar os numeros dos modulos.

O resto também é simples... Como toda a matriz foi inicializada com o valor -1 (que nunca poderia ser uma nota oficial), ao correr o procedimento mostrainacabados, se ainda lá estiver o valor -1 é porque não teve ainda nenhuma nota inserida no respectivo módulo.

Uma coisa que te sugiro, pois facilita bastante a programação e a leitura do programa, é que cries um array de constantes com o nome das disciplinas: (Já vi que o pascalzim não permite arrays de constantes, pelo que terá mesmo de ser de variáveis:

var
   Disciplinas:array[1..10] of string;

Como é uma variavel, terás de a inicializar com os nomes das disciplinas. Pode ficar mesmo no procedimento de inicialização da matriz, que ficaria então assim:

procedure ResetMatriz;
var
   i,j:integer;
begin
        // Aqui insere-se os nomes das disciplinas
        Disciplinas[1]:='dfdfgdfgdfg';
        Disciplinas[2]:='gdfgdfgdfgdfb';
        Disciplinas[3]:='gdfgddfgdgd';
        Disciplinas[4]:='dfgdgdfgdfgd';
        Disciplinas[5]:='dgfgdfgdfgdfg';
        Disciplinas[6]:='dgfgdgdgdgdf';
        Disciplinas[7]:='gdfgdfgdfgdf';
        Disciplinas[8]:='gdfgdgdfdgfgd';
        Disciplinas[9]:='gdfgdfgdfg';
        Disciplinas[10]:='dgfgdfgdfgdfgd';

        for i:=1 to 10 do
            for j:=1 to 7 do
                nota[i,j]:=-1;
end;

Com isto, além de poderes substituir as diversas vezes que tens de escrever o nome da disciplina chamado-a apenas pelo numero, podes ao mostrar os modulos inacabados mostrar não o numero, mas o nome, sem trabalho extra. Basta alterar a linha que escreve o numero da disciplina no procedimento MostraInacabados pela seguinte linha:

Write(Disciplinas[i],': ');  // em vez de Write('Disciplina ',i,': ');

Por exemplo, no teu procedimento InserirDisciplina, toda a estrutura case poderia ser substituida por isto:

if (a>=1) and (a<=10) then begin
                                                   dis:=a;
                                                   writeln('Disciplina: ',Disciplinas[a]);
                                           end;

Espero que ajude....

[Knectus 0]

WOW, muito bem pensado, eu iria demorar dias ate perceber como mostrar as notas e fazer a array de string, já tinha pensado em fazer a array, mas seria difícil eu conseguir, visto que sou amador, e é muito raro eu trabalhar com boolean.

- Tive que ler e compilar varias vezes o procedimento "MostraInacabados" para realmente perceber como funcionava 😲

Mas seja como for agradeço pelo seu tempo, espero tirar boa nota

[nunopicado 1,247]

No que toca à programação, o essencial em qualquer linguagem é ter pensamento lógico, tal como têm os computadores...

Um computador não quer saber de talvez, serás e porquês... Tudo é uma questão de verdadeiro ou falso, e nisso, as variáveis boolean são o que há de mais próximo ao que o computador "pensa"... Dão imenso jeito!

Não não sou profissional, longe disso... Nunca ganhei dinheiro com programação, nem o meu trabalho é nesta área. Inclusivamente estive alguns anos nem programar e só recentemente (lá para novembro do ano passado) voltei a isto porque precisei de um programa que simplesmente não existia... ( a necessidade aguça o engenho)

Depois conta a nota que tens... E se precisares de alguma coisa, apita...

[Knectus 0]

Sim, concordo, pensamento lógico é essencial

Hmmm, muito bem, eu programo á cerca de uns 3 meses, mas apenas com pascal e um pouco de PHP ..

Ahah, okay, eu depois digo a nota que tive 😎