Command Line Calculator/de

│ Deutsch (de) │

Zurück zur Konsolenseite.

Kommandozeilenrechner

Das Programm Kommandozeilenrechner ist ein einfacher Taschenrechner für die Konsole (Windows) bzw. für das Terminal (Linux).

Um das Programm zu erstellen, erstellen Sie in Lazarus unter Projekt -> neues Projekt -> Programm ein neues Projekt.

Speichern Sie das Projekt in einem beliebigen Verzeichnis unter dem Namen rechne ab.

Hinweis:

Die bedingte Kompilierung wird für die unterschiedliche Ausgabe an der Konsole (Windows) / am Terminal (Linux) benötigt.

Komandozeilenrechner:

program Rechne;

{$mode objfpc}{$H+}
{$IMPLICITEXCEPTIONS OFF}

uses
  SysUtils
  {$IFDEF Windows} ,Windows {$ENDIF};

var
  wrdParameter: word = 0;
  intI: integer;
  intFehler: integer = 0;
  dblZahl1: double = 0.0;
  dblZahl2: double = 0.0;
  dblErgebnis: double = 0.0;
  strEingabe1: string = '';
  strEingabe2: string = '';
  strOperator: string = '';
  strAusgabe: string = '';

  // Bedingte Kompilierung für Windows
  {$IFDEF Windows}
  function funAnsiZuOEM(strUebergabe: string): string;
  begin

    funAnsiZuOEM := '';
    strUebergabe := Utf8ToAnsi(strUebergabe);
    strUebergabe := strUebergabe + #0;
    CharToOEM(PChar(strUebergabe), @strUebergabe[1]);
    Delete(strUebergabe, Length(strUebergabe), 1);
    Result := strUebergabe;

  end;
  {$EndIf}


  procedure subHilfe;
  begin
  // Bedingte Kompilierung für Windows
  {$IFDEF Windows}
    WriteLn('   Folgende Parameter rufen die Hilfe auf:');
    WriteLn('     ? oder /? oder -? oder --?');
    WriteLn('');
    WriteLn(funAnsiZuOEM('   Es sind folgende Operatoren zulässig:'));
    WriteLn('     Adition         +');
    WriteLn('     Subtraktion     -');
    WriteLn('     Multiplikation  *');
    WriteLn('     Division        / oder :');
    WriteLn('');
    WriteLn(funAnsiZuOEM('   Dem Programm müssen drei Parameter sein.'));
    WriteLn('   z. B.:');
    WriteLn('          3 + 4');
    WriteLn('');
  {$EndIf}


 // Bedingte Kompilierung für Linux / UNIX
  {$IFDEF UNIX}
    WriteLn('   Folgende Parameter rufen die Hilfe auf:');
    WriteLn('     ? oder /? oder -? oder --?');
    WriteLn('');
    WriteLn('   Es sind folgende Operatoren zulässig:');
    WriteLn('     Adition         +');
    WriteLn('     Subtraktion     -');
    WriteLn('     Multiplikation  *');
    WriteLn('     Division        / oder :');
    WriteLn('');
    WriteLn('   Dem Programm müssen drei Parameter sein.');
    WriteLn('   z. B.:');
    WriteLn('          3 + 4');
    WriteLn('');
  {$EndIF}

  end;


  procedure subFehlermeldung(intParameter: integer);
  begin

  // Bedingte Kompilierung für Windows
  {$IFDEF Windows}
    if intParameter = 0 then
    begin
      writeln(funAnsiZuOEM('   Es wurde kein Parameter übergeben!'));
      WriteLn('');
      subHilfe;
      Exit;
    end;

    if intParameter < 3 then
    begin
      WriteLn(funAnsiZuOEM('   Es wurden zuwenig Eingaben getätigt!'));
      WriteLn(funAnsiZuOEM('   Es müssen drei Parameter sein.'));
      WriteLn('');
      subHilfe;
    end;

    if intParameter > 3 then
    begin
      WriteLn(funAnsiZuOEM('   Es wurden zuviele Eingaben getätigt!'));
      WriteLn(funAnsiZuOEM('   Es müssen drei Parameter sein.'));
      WriteLn('');
      subHilfe;
    end;
  {$EndIf}

  // Bedingte Kompilierung für Linux / UNIX
  {$IFDEF UNIX}
    if intParameter = 0 then
    begin
      writeln('   Es wurde kein Parameter übergeben!');
      WriteLn('');
      subHilfe;
      Exit;
    end;

    if intParameter < 3 then
    begin
      WriteLn('   Es wurden zuwenig Eingaben getätigt!');
      WriteLn('   Es müssen drei Parameter sein.');
      WriteLn('');
      subHilfe;
    end;

    if intParameter > 3 then
    begin
      WriteLn('   Es wurden zuviele Eingaben getätigt!');
      WriteLn('   Es müssen drei Parameter sein.');
      WriteLn('');
      subHilfe;
    end;
  {$EndIf}

  end;


  function funParametertest: boolean;
  begin

    Result := False;
    wrdParameter := ParamCount;

    // Prüft, ob die Hilfe aufgerufen wurde
    if (wrdParameter = 1) then
    begin
      case strEingabe1 of
        '?', '/?', '-?', '--?':
        begin
          subHilfe;
          Exit;
        end;
      end;
      subFehlermeldung(wrdParameter);
      Exit;
    end;


    // Prüft, ob das Programm Parameter übergeben bekommen hat
    if wrdParameter = 0 then
    begin
      subFehlermeldung(wrdParameter);
      Exit;
    end;

    // Prüft, ob eine falsche Parameterzahl übergeben wurde
    if wrdParameter <> 3 then
    begin
      subFehlermeldung(wrdParameter);
      Exit;
    end;


    // Prüft, ob das Programm drei Parameter übergeben bekommen hat
    if (wrdParameter > 0) and (wrdParameter < 4) then
    begin
      strEingabe1 := ParamStr(1);
      strOperator := ParamStr(2);
      strEingabe2 := ParamStr(3);
      Result := True;
      Exit;
    end;

  end;

  procedure Haupt;
  begin

    // Ersetzt das Dezimalkomma durch den Dezimalpunkt
    for intI := 1 to Length(strEingabe1) do
      if strEingabe1[intI] = ',' then
        strEingabe1[intI] := '.';
    for intI := 1 to Length(strEingabe2) do
      if strEingabe2[intI] = ',' then
        strEingabe2[intI] := '.';


    // Konvertiert einen String in eine Zahl
    VAL(strEingabe1, dblZahl1, intFehler);
    if intFehler <> 0 then
    begin
      WriteLn('   Der 1. Parameter ist falsch');
      EXIT;
    end;

    // Konvertiert einen String in eine Zahl
    VAL(strEingabe2, dblZahl2, intFehler);
    if intFehler <> 0 then
    begin
      WriteLn('   Der 3. Parameter ist keine Zahl');
      EXIT;
    end;

    // Prüft, ob der richtige Operator übergeben wurde
    if (strOperator <> '+') and (strOperator <> '-') and
      (strOperator <> '/') and (strOperator <> ':') and (strOperator <> '*') then
    begin
      WriteLn('   Der 2. Parameter ist falsch');
      EXIT;
    end;

    // Führt die Grundrechenarten aus
    case strOperator of
      '+':
        dblErgebnis := dblZahl1 + dblZahl2;
      '-':
        dblErgebnis := dblZahl1 - dblZahl2;
      '/', ':':
        // verhindert eine Division durch 0
        if dblZahl2 = 0.0 then
        begin
          WriteLn(
            '   Eine Division durch Null ist nicht erlaubt!!');
          Exit;
        end
        else
          dblErgebnis := dblZahl1 / dblZahl2;
      '*':
        dblErgebnis := dblZahl1 * dblZahl2;
    end;


    // Wandelt die Fliesskommazahl in einen String fester Länge um
    STR(dblErgebnis: 20: 6, strAusgabe);

    // ersetzt den Dezimalpunkt durch das Dezimalkomma
    for intI := 1 to Length(strAusgabe[intI]) do
      if strAusgabe[intI] = '.' then
        strAusgabe[intI] := ',';

    // Gibt das Ergebnis auf der Konsole aus
    WriteLn('   Ergebnis = ', strAusgabe);

  end;

begin
  if funParametertest = True then
    Haupt;
end.

Beispiel für einen Aufruf unter Windows:

rechne 4 * 3,1

Beispiel für einen Aufruf unter UNIX/Linux (Achtung unter UNIX/Linux muss im Terminal der Multipikator * mit \ maskiert werden):

rechne 4 \* 3,1