Pascal - giudizio programma

adesso ho scritto un programma come quello che hai suggerito però con tre operazioni di lettura!
prima un numero,poi il segno,e poi l' altro numero,perchè tutti su un rigo nn li faceva leggere!cioè il compilatore non dava errore,però quando andavi a inserire i numeri scompariva l'interfaccia del programma!

Ecco un piccolo esempio, scritto in 5 min, ma testato e funzionante:

Java:

import java.io.*;
public class calc{
public static void main(String[] args){
System.out.print("Inserisci operazione: ");
BufferedReader in = null;
String my_string = ""; 
try{
in = new BufferedReader(new InputStreamReader(System.in));
my_string = in.readLine(); 
}catch(IOException e1){

}

if(my_string.contains("+")){
System.out.println("Addizione!");
my_string = my_string.replace("+", " ");
String[] add = my_string.split(" ");
int n1 = Integer.parseInt(add[0]);
int n2 = Integer.parseInt(add[1]);
int n3 = n1 + n2;
System.out.println(n1 + "+" + n2 + "=" + n3);
System.out.println(n3);
}else if(my_string.contains("-")){
System.out.println("Sottrazione!");
my_string = my_string.replace("-", " ");
String[] add = my_string.split(" ");
int n1 = Integer.parseInt(add[0]);
int n2 = Integer.parseInt(add[1]);
int n3 = n1 - n2;
System.out.println(n1 + "-" + n2 + "=" + n3);
}else if(my_string.contains("*")){
System.out.println("Moltiplicazione!");
my_string = my_string.replace("*", " ");
String[] add = my_string.split(" ");
int n1 = Integer.parseInt(add[0]);
int n2 = Integer.parseInt(add[1]);
int n3 = n1 * n2;
System.out.println(n1 + "*" + n2 + "=" + n3);
}else if(my_string.contains(":")){
System.out.println("Divisione!");
my_string = my_string.replace(":", " ");
String[] add = my_string.split(" ");
int n1 = Integer.parseInt(add[0]);
int n2 = Integer.parseInt(add[1]);
int n3 = n1 / n2;
System.out.println(n1 + ":" + n2 + "=" + n3);
}
}

P.S: Se sei interessato alla programmazione Pascal con GUI, allora ti consiglio Lazarus, IDE per Pascal, con un pacco di roba! Se sei su windows ti basta scaricare solo il file exe e poi lo installi ed è tutto configurato, invece se sei su linux, devi installare lazarus, e poi Free Pascal, pacchetti: fpc e fpc-src

non conosco il linguaggio che hai usato ma a naso vedo che hai fatto leggere l'operazione in una stringa e poi verifichi il segno che contiene la stringa con l' istruzione .contains....esiste una codifica in pascal di quest' istruzione?

Ecco qua: borlandpascal.wikia.com/wiki/… istruzione POS!

grazie mille

se vuoi puoi provare pilotlogic.com/sitejoom/index.php/codetyphon/… è lazarus già bello e pronto basta eseguire il setup funziona sia su windows che su linux.
Ultimamente Lazarus è molto migliorato, ovviamente non è al livello di Delphi, ma il compilatore freepascal usato da lazarus è molto buono.

Per quanto riguarda il tuo programmino io continuo a dire che se c'e' codice rindondante bisogna accorparlo, il codice rindondante è la prima causa di bachi nei programmi e la manutenzione risulta sempre più problematica andando avanti con lo sviluppo.
G.

codice rindondante?
comunque grazie all'aiuto di little hacker sono arrivato a questo codice,sicuramente migliore del primo

program calcolatrice;
uses crt;
const
 dim=3;
var
 num:array[1..dim]of real;
 scelta:char;
 x,y:integer;
 s,appoggio,app2:string;
 label 1;
begin
  clrscr;
  writeln('programma calcolatrice');
  repeat
  1:
  write('scrivi l''operazione che vuoi eseguire: ');
  readln(s);
  x:=pos('+',s);
  if x<>0
   then
   begin
    appoggio:=copy(s,1,(x-1));
    y:=length(s);
    app2:=copy(s,(x+1),y);
    val(appoggio,num[1]);
    val(app2,num[2]);
    num[dim]:=(num[1])+(num[2]);
    writeln('ecco la somma: ',num[dim]:2:1);
   end;
  x:=0;
  x:=pos('-',s);
  if x<>0
   then
   begin
     appoggio:=copy(s,1,(x-1));
     y:=length(s);
     app2:=copy(s,(x+1),y);
     val(appoggio,num[1]);
     val(app2,num[2]);
     num[dim]:=(num[1])-(num[2]);
     writeln('ecco la differenza: ',num[dim]:2:1);
    end;
  x:=0;
  x:=pos('*',s)or pos('x',s);
  if x<>0
   then
   begin
    appoggio:=copy(s,1,(x-1));
    y:=length(s);
    app2:=copy(s,(x+1),y);
    val(appoggio,num[1]);
    val(app2,num[2]);
    num[dim]:=(num[1])*(num[2]);
    writeln('ecco il prodotto: ',num[dim]:2:1);
    end;
  x:=0;
  x:=pos('/',s)or pos(':',s);
  if x<>0
   then
   begin
    appoggio:=copy(s,1,(x-1));
    y:=length(s);
    app2:=copy(s,(x+1),y);
    val(appoggio,num[1]);
    val(app2,num[2]);
    if num[2]=0
     then
     begin
      writeln('il divisore dev''essere diverso da 0');
      goto 1;
     end;
    num[dim]:=(num[1])/(num[2]);
    writeln('ecco il quoziente: ',num[dim]:2:1);
    end;
  write('vuoi effettuare un''altra operazione?(S/N): ');
  readln(scelta);
  until (scelta<>'S')and(scelta<>'s');
  writeln('termine elaborazione');
  readln;
end.

Rindondante in questo caso vuol dire codice ripetuto e non necessario.
Ti faccio un piccolo esempio, tenendo come base il tuo codice:

program calcolatrice;
  uses crt;
  Type
    tyTipoOperazione = (tyAddizione, tySottrazione, tyDivisione, tyMoltiplicazione);
var
  x:integer;
  scelta:char;
  tyOperazione: tyTipoOperazione;
  s, sparola:string;
  nRisultato: Real;
Function GetOperazione(s: String):tyTipoOperazione;
begin
  if pos('+',s) > 0 then
  begin
    x := pos('+',s);
    sParola := 'la somma: ';
    result := tyAddizione;
  end
  else if pos('-',s) > 0 then
  begin
    x := pos('-',s);
    sParola := 'la differenza: ';
    result := tySottrazione;
  end
  else if (pos('*',s) > 0) or (pos('x',s) > 0) then
  begin
    x := pos('*',s)or pos('x',s);
    sParola := 'il prodotto: ';
    result := tyMoltiplicazione;
  end
  else if (pos('/',s) > 0) or (pos(':',s) > 0) then
  begin
    x := pos('/',s)or pos(':',s);
    sParola := 'il quoziente: ';
    result := tyDivisione;
  end;
end;

Function ritornaOperazione(x: integer; tyOperazione: tyTipoOperazione; s: String):Real;
Var num: array[1..2] of real;
    appoggio, app2: String;
begin
  appoggio:=copy(s, 1, (x-1));
  app2:=copy(s,(x+1), length(s));
  val(appoggio,num[1]);
  val(app2,num[2]);
  Case tyOperazione of
    tyAddizione:       Result := (num[1])+(num[2]);
    tySottrazione:     Result := (num[1])-(num[2]);
    tyDivisione:
    begin
      if num[2]=0 then
      begin
        writeln('il divisore dev''essere diverso da 0');
        num[2] := 1;
       end;
       Result := (num[1])/(num[2]);
    end;
    tyMoltiplicazione: Result := (num[1])*(num[2]);
  end;
end;

begin
  clrscr;
  writeln('programma calcolatrice');
  repeat
    write('scrivi l''operazione che vuoi eseguire: ');
    readln(s);
    tyOperazione := GetOperazione(s);
    nRisultato := RitornaOperazione(x, tyOperazione, s);
    writeln('ecco '+sParola, nRisultato:2:1);
    write('vuoi effettuare un''altra operazione?(S/N): ');
    readln(scelta);
  until (scelta<>'S')and(scelta<>'s');
  writeln('termine elaborazione');
  readln;
end.

Ho usato il dev-pascal il quale non mi permette di usare i parametri in OUT, dunque devo dichiarare delle variabili globali, poi ho dichiarato il tipo delle 4 operazionni da eseguire, ho accorpato in due funzioni il codice ripetuto più volte ossia l'estrazione dei numeri dalla stringa e l'estrazione dell'operazione da effettuare, data la stringa dell'operazione estraggo il tipo di operazione e lo passo alla funzione che elabora la stringa e ritorna il risultato che poi viene stampato.

Ciò non toglie niente al tuo sorgente, non voglio dire che sia meglio o peggio del mio, quello che voglio evidenziare è il fatto che ripetere pezzi di codice aumenta il rischio di inserire errori e rende difficile la manutenzione.
Vista l'ora tarda spero di non aver inserito cavolate
PS: ho semplificato un po' nel caso in cui il divisore è = 0