Euro - Dollar - Umrechner

[rojhat2049]

Hier habe ich einen Euro - Dollar - Umrechner programmiert

Delphi-Quellcode:

unit Unit1;
interface
uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls;
type
  TForm1 = class(TForm)
    edt1: TEdit;
    edt2: TEdit;
    edt3: TEdit;
    grp1: TGroupBox;
    lbl2: TLabel;
    lbl3: TLabel;
    grp2: TGroupBox;
    lbl1: TLabel;
    grp3: TGroupBox;
    scrlbr1: TScrollBar;
    edt4: TEdit;
    procedure edtDblClick(Sender: TObject);
    procedure FormCreate(Sender: TObject);
    procedure scrlbr1Change(Sender: TObject);
  private
    { Private declarations }
  public
    { Public declarations }
  end;
var
  Form1: TForm1;
implementation
{$R *.dfm}
var
  kurs, euro, dollar :Single;
  code               :Integer;
  s                  :string;
procedure umwandeln;
  begin
    with Form1 do
    begin
      Val(edt1.text, kurs, code) ;
      Val(edt2.Text,dollar , code) ;
      Val(edt3.Text,euro ,code) ;
     end;
    end;
    procedure euro_dollar;
    begin
     umwandeln;
     Str(euro*kurs:8:2,s);
     Form1.edt2.text :=s;
     end;
     procedure dollar_euro;
     begin
       umwandeln;
       Str(dollar/kurs:8:2,s);
       Form1.edt3.text :=s;
       end;
procedure TForm1.edtDblClick(Sender: TObject);
begin
    umwandeln;
    if kurs>0
    then if sender =edt3
         then euro_dollar
         else dollar_euro;
end;

[Luckie]

Ich denke nicht, dass dein Code irgendetwas enthält, was einen deutlichen Meherwert aufweist. Deshalb denke ich, dass dein Code nicht ganz hier in die Code-Lib passt. Wenn du dein Programm vorstellen willst, dann kannst du dies aber gerne in der entsprechenden Sparte tun.

[Matze]

Hallo,

dem schließe ich mich an, auch wenn es nett gemeint ist. Für die Zukunft aber ein paar Hinweise.

Mit deinem Code kann man fast nichts anfangen, da du die VCL nutzt (TEdit) etc. D.h. um den Code zum Laufen zu bekommen, muss man erst einmal die ganzen Komponenten verwenden. Wenn die Werte aus einer Datei, einer ComboBox o.ä. kommen, muss man deinen Code beispielsweise anpassen bzw. man muss ihn immer anpassen

Dann nutzt du globale Variablen, ohne die dein Code nicht laufen würden, daher ist es sinnvoll, das als Funktion zu schreiben. Diese kann man 1:1 übernehmen und leicht und vielseitig verwenden. Obendrein kürzt das den Code aufs Wesentliche. Im vorliegen Beispiel könnte das so aussehen:

Delphi-Quellcode:

function EuroToDollar(const Euro, Kurs: Double): Double;
begin
  Result := Euro * Kurs;
end;

function DollarToEuro(const Dollar, Kurs: Double): Double;
begin
  Result := Dollar / Kurs;
end;

Evtl. mit Beispielaufruf und da kannst du die VCL auch gerne verwenden:

Delphi-Quellcode:

LblEuro.Caption := FloatToStr(DollarToEuro(StrToFLoat(EdtDollar.Text), StrToFloat(EdtKurs.Text)));

Was das ":8:2" in deinem Code soll, habe ich nicht ganz verstanden.
Deine Formatierung hat mich auch erst verwirrt. Es sieht auf den ersten Blick aufgrund der schlechten Einrückung so aus, als seien in der Prozedur "umwandeln" weitere Prozeduren enthalten.

Das als Hinweise, was wir hier erwarten. :)

Einen schönen Abend wünscht
Matze

[Luckie]

Zitat:

Zitat von Matze

Was das ":8:2" in deinem Code soll, habe ich nicht ganz verstanden.

Zwei Nachkommastellen. ;)

[Wolfgang Mix]

Erstmal herzlich willkommen in der DP :dp:

Dein Thema ist hier in der DP schon mehrfach durchgekaut worden.
Das hättest Du mit unserer Funktion "Suchen" herausfinden können.
Wenn Du wirklich Interressantes zu bieten hast, schau 'mal hier unter "Suchen",
was es schon gibt, bevor Du etwas einstellst und versuche es noch einmal.
Lasse Dich aber nicht entmutigen, wir haben hier alle auch 'mal ganz klein
angefangen!

Gruß

Wolfgang

[Matze]

@Luckie: Ah ok, das habe ich immer über Format gelöst, nie über "Str()". Wieder was gelernt, danke (ich bleibe dennoch bei "Format"). ;)

[Wolfgang Mix]

Jaja, das stammt noch von TP :)

[DP-Maintenance]

Dieses Thema wurde von "Daniel G" von "Neuen Beitrag zur Code-Library hinzufügen" nach "Open-Source" verschoben.
Passt besser in OpenSource...

[Back2Code]

Delphi-Quellcode:

var
  euro, dollar : Double;
  i : integer;
  kurs : double = 1.32;

{$R *.res}

begin
WriteLn('-----------------------------------------------------------------');
WriteLn('#####################Umrechner########################');
WriteLn('-----------------------------------------------------------------');
WriteLn('Tragen Sie den aktuellen Kurs von einem Dollar ein!');
ReadLn(kurs);
    for i := 1 to 10000 do begin
    WriteLn('-----------------------------------------------------------------');
    WriteLn(FloatToStr(kurs) + (' Dollar = 1 Euro. Tragen Sie nun ihren Betrag in Euro ein!'));
    ReadLn(euro);
    WriteLn('******************************');
    dollar := kurs * euro;
    WriteLn('-----------------------------------------------------------------');
    WriteLn(FloatToStr(dollar) + (' Dollar!'));
    WriteLn('-----------------------------------------------------------------');
    WriteLn();
    WriteLn();
    WriteLn();
    WriteLn();
    end;
end.

[Klaus01]

Guten Morgen,

warum läst Du die Schleife 10000 mal durchlaufen?

Grüße
Klaus

[Back2Code]

Zitat:

Zitat von Klaus01 (Beitrag 1176274)

Guten Morgen,

warum läst Du die Schleife 10000 mal durchlaufen?

Grüße
Klaus

Der Source ist noch vor meiner Zeit, wo ich etwas von while Schleifen gehört hatte :-D Und damals hab ich das Problem so gelöst, dass es nach einer Eingabe halt wiederholt wird.

[Jonas Shinaniganz]

und auch nix von

Delphi-Quellcode:

repeat 
...
until();

oder

Delphi-Quellcode:

var
  label label1;
begin
  label1;
  ...
  goto label1 ;

oder

und ich bin noch nicht ganz 1 Jahr dabei und mal eben derbe kreativ:)

Delphi-Quellcode:

var
  I : Integer;
  hack : @I;
begin
  for I := 0 to 1 do
  begin
  ...
  hack^ := 0;
  end;

[himitsu]

Zitat:

Zitat von Jonas Shinaniganz (Beitrag 1176288)

Delphi-Quellcode:

var
  I : Integer;
  hack : @I;
begin
  for I := 0 to 1 do
  begin
  ...
  hack^ := 0;
  end;

Das vergiß man ganz schnell wieder. :warn:
Das Gleiche gilt für

Delphi-Quellcode:

hack : Integer absolute I;

.

Denn die Codeoptimierung läßt auch ganz gerne mal die Schleifen rückwäts laufen oder in einem anderem/optimierten Wertebereich.
z.B. ein

Delphi-Quellcode:

for i := 3 to 5 do

kann Delphi/FPC ganz schnell mal in ein

Delphi-Quellcode:

for i := 2 downto 0 do

optimieren.

So wie es klingt hast du dementsprechend noch nicht wirklich Überblick über gewisse Interna des Compilers, bzw. der Sprache, und "Sowas" machen zu können.



Von GOTO für "einfache" Schleifen wird auch einfach mal abgeraten ... Beründung: is halt so Und übersichtlicher/optimierter wird es

Und was ist mit While-Schleifen oder Break?

[Jonas Shinaniganz]

Stimmt himitsu. Ich bin heute nicht so ernst bei der Sache weil das erste Jahr als Azubi jetzt rumm ist und wir am Sonntag noch entsprechend getankt hatten *g*

Jedenfalls hast du Recht, http://de.wikipedia.org/wiki/Spaghetticode

Grüße