Entwickler-Ecke :: Thema anzeigen - Habe beim Taschenrechner programmieren Probleme

oldmax - Di 15.08.06 13:31
Titel: Taschenrechner

Hi Magic87
Die Frage, wie mache ich, dass... wird dich ein Leben lang begleiten. Allerdings, die meisten stellen sich dieser Thematik nicht, haben einfach Spass am Leben und geniessen ihre Freizeit. Aber... wir sind ja nicht die meisten.. und darum geb ich dir einen Tip:
Rechnen tust du mit deinen Variablen im Hintergrund, und damit das funktioniert, mußt du sie am Anfang auf 0 setzen.
Wenn du unbedingt mit nur einem Editfeld arbeiten möchtest, mußt du dir Schritte überlegen, wie du bspw. eine Eingabe tätigen kannst, wann du diese Zahl mit anderen Werten berechnen wirst und mit welchen Ereignis du dies auslöst und wie du dann bei einer Neueingabe den angezeigten Wert verschwinden lassen kannst.
Also, versuchen wir aufzulösen.
Es gibt das Ereignis onKeyDown eines Editfeldes. Damit könntest du einmal das Editfeld löschen. Das darf aber nur einmal geschehen und das eingegebene Zeichen soll auch erhalten bleiben. Also mußt du die Routine ausblenden, wenn du ein Zeichen eingegeben hast. Dies geschieht z.B. durch Zuweisung von NIL an das OnKeyDown-Ereignis.

Delphi-Quelltext

1:
2:
3:
4:
5:
6:
7:
8:

....
Procedure myForm.MyEditKeyDown(Sender: TObject;Var Key:Word; Shift: TShiftState);
Begin
  MyEdit.Text:='';           // Editfeld für neue Eingaben leeren
  MyEdit.OnKeyDown:=Nil;     // diese Routine für weitere Eingaben entfernen
  MyEdit.Text:=Chr$(Key);    // das Zeichen dem textfeld zuweisen
end;
.....

So, nun hast du ein Zeichen eingegeben und den Aufruf der Procedure MyEditKeyDown ausgeblendet. Die Eingaben sollten nun wieder funktionieren. Wenn du nun auf deinen mathematischen Operator, ich nehme an, ein Button mit plus, minus, mal oder geteilt drückst, machst du zuerst deine Berechnung mittels deiner Variablen. Dann weist du durch entsprechende Umwandlung das Ergebnis dem Editfeld zu und danach gibst du wieder den Aufruf von KeyDown frei, indem du der Wariablen die Prozedur wieder zuweist.
Sieht dann ungefähr so aus

Delphi-Quelltext

1:
2:
3:
4:
5:
6:
7:
8:

....
Procedure myForm.Buttonxclick(Sender: TObject); // angenommen Plus
Begin
  Calcwert:=Calcwert+StrToInt(MyEdit.Text); // angenommen, Calcwert ist eine globale Integer-Variable
  MyEdit.Text:=IntToStr(Calcwert);          // Ergebnis dem Editfeld zuweisen
  MyEdit.OnKeyDown:=MyEditKeyDown;          // und die OnKeyMethode zuweisen
end;
.....

ungeprüft, aber so müßte es gehen...
Ich hoffe dir gehelft zu haben
Gruß oldmax

oldmax - Di 15.08.06 16:34
Titel: Taschenrechner

Hi
Ich nochmal ganz kurz...
Da hab ich mir solche Mühe gegeben, einen "einfachen" code zu erklären...
tse, diese Anfänger :wink:
Ok, Du mußt natürlich deiner Variablen einen Anfangswert zuweisen. Das kannst du bspw. in der FormCreate, das ist, wenn du in deine Form einen Doppelclick machst, bist du in dieser Procedure im Editor. Da schreibst du einfach

Delphi-Quelltext

1:
2:
3:
4:

....
Wert:=0; // bei Strichrechnen
Wert:=1; // bei Punktrechnen
.....

Außerdem hast du ja im Rechner eine C-Taste ( Clear oder so )
Da macht es Sinn, diese einzupflegen und beim Click darauf ebenfalls die Variable Wert vorzubesetzen.

Nun kannst du folgendes machen, um mal zu if... zu kommen. Der Unterschied bei Punkt und Strichrechnen ist im Anfangswert. Daher mußt du den Inhalt der Variablen auswerten und der Rechenfunktion entsprechend anpassen. Das gilt nur für den Anfangswert.
Also: Variable Wert auf 0 mit

Delphi-Quelltext

1:

Wert:=0;

Nun einen Wert eingegeben und eine Rechenoperation. Beim Auslösen der Rechenoperation prüfst du den Inhalt von Wert:
Also in der Ereignisroutine von der Multiplikation sowie der Division setzt du folgende Zeile an den Anfang:

Delphi-Quelltext

1:	If Wert=0 then Wert:=1;

danach führst du die Rechenoperation aus z. B.

Delphi-Quelltext

1:
2:
3:

Wert:=Wert*StrToInt(Edit1.Text); 
// oder 
Wert:=Wert/StrToInt(Edit1.Text);

Bei einer Strichrechnung brauchts keine Änderung vom Startwert der Variable Wert

Delphi-Quelltext

1:
2:
3:

Wert:=Wert+StrToInt(Edit1.Text);
// oder 
Wert:=Wert-StrToInt(Edit1.Text);

Du hattest in deinem Posting erklärt, das du verstanden hast, das der Variablen "Wert" das Rechenergebnis aus der rechten Seite zugewiesen wird.

Na ja, aller Anfang ist schwer...., du schaffst das schon.
Gruß oldmax

oldmax - Di 15.08.06 19:22
Titel: immer noch Taschenrechner

Hi

Also, klar, ich weiß schon, warum ich da die Finger von lasse, vonne Mathe. Aber da hat unser Magic87 nun wirklich ein Problem, oder ? weil, wenn Eingabe 5 und in Wert-Variable steht 0 und nun würden wir die 5 so gern mit 3 multiplizieren......

Na dann mach mal.

OK, es war vielleicht ein Schnellschuß, aber wie immer kommen dann die Fragen, wie komme ich weiter, warum stimmen die Ergebnisse nicht, wo setze ich auf's falsche Pferd. Es wär ja so schön einfach gewesen mit der Ausblenderei der Procedur KeyDown, aber er will ja da nich ran, er will's zu Fuß haben..

Also, wie wär's mit einem Kompromiß. Die Null machen wir nur bei der 1. Rechenoperation nach einem "clear" oder Neustart zu 1 für's Punktrechnen, danach nieee wieder. Also, merk dir, wenn du eine Rechnung beginnst. Vielleicht so mit einer weiteren Variable

Anfang : Boolean;

Nun mußt du die Anfangswerte setzen, zum Beipiel in einer Clearbutton-Procedur

Delphi-Quelltext

1:
2:
3:
4:
5:
6:
7:
8:

Procedure MyForm.ButtonCClick(Sender : TObject); // diese doppel"C" ist kein Schreibfehler, sondern der Name des Clear-Buttons

Begin
  Wert:=0;            // Rechenvariable auf 0 setzen
  Anfang:=True;       // Zeichen, das erste Rechenoperation folgt auf Wahr
  MyEdit.Text:='0';   // Ach ja, dem Eingabefeld einen Wert geben, natürlich 0

end;

na ja , das sagte ich ja schon, natürlich auch beim Programmstart

Delphi-Quelltext

1:
2:
3:
4:
5:
6:
7:

Procedure MyForm.FormCreate(Sender : TObject); // Hier startet dein Programm....
Begin
  Wert:=0;            // Rechenvariable auf 0 setzen
  Anfang:=True;       // Zeichen, das erste Rechenoperation folgt auf Wahr
  MyEdit.Text:='0';   // Ach ja, dem Eingabefeld einen Wert geben, natürlich 0

end;

Nun schreibst du einfach in alle deine Rechenoperationsbutten als letzte Zeile Anfang:=False;

z.B.

Delphi-Quelltext

1:
2:
3:
4:
5:
6:
7:
8:

Procedure MyForm.ButtonMulClick(Sender : TObject); 
Begin
  If Anfang and ( Wert=0) then Wert:=1;  // auch bei der Division. Das sichert die einmalige Umsetzung auf 1
   ....                                  // in diesen Zeilen steht dein weiterer Code
   ....
   Anfang:=False;                        // und nun setzt du dein Anfang-Zeichen auf falsch

end;

So, das soll's erst mal sein. Vermutlich sind deine Procedure-Köpfe anders, aber ich denke du erkennst schon, was wichtig ist. Und bei dem ganzen Spass nicht vergessen, es gibt immer den Fehler, den man logisch macht. Der taucht in keiner Fehlerroutine auf, das Ergebnis ist einfach falsch. Syntaxfehler, klar, die erkennt der Compiler, aber Denkfehler.... ??! Wie denn auch. Der Rechner macht genau das, was du ihm sagst und meistens glaubst du nur, ihm was anderes gesagt zu haben. Da isser ziemlich stur.

ok. Viel Spass

oldmax

starsurfer - Mi 16.08.06 09:40

Ich hab son Ding mal vor langer langer Zeit aus Langeweile programmiert mit Recht einfachen Befehlen.

Es ist auskommentiert, guggst dir einfach mal an.

Delphi-Quelltext

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
171:
172:
173:
174:
175:
176:
177:
178:
179:
180:
181:
182:
183:
184:
185:
186:
187:
188:
189:
190:
191:
192:
193:
194:
195:
196:
197:
198:
199:
200:
201:
202:
203:
204:
205:
206:
207:
208:
209:
210:
211:
212:
213:
214:
215:
216:
217:
218:
219:
220:
221:
222:
223:
224:
225:
226:
227:
228:
229:
230:
231:
232:
233:
234:
235:
236:
237:

...

  private
    procedure variablen_uebergabe;//selbst definierte procedure
    procedure rechenarten;//selbst definierte procedure
    procedure zahl_neu;//selbst definierte procedure

...

var
  Form1: TForm1;
  zahl1,zahl2,ergebnis:real; //3 komma zahlen
  zahl1_eingegeben,istgleich,zahl2_eingegeben,zahl_loeschen,rechenoperation_gewaehlt:bool; //5 werte die richtig udn falsch enthalten können
  rechenart:integer; //eine variable die ganze zahlen enthält
implementation

{$R *.DFM}

procedure tform1.zahl_neu;  //selbst definierte procedure : Schaut ob sich die Zahl wechselt (zB wenn man "+" geklickt hat und ne neue Zahl eingeben will)
begin
rechenoperation_gewaehlt:=false;
istgleich:=false; //istgelich wurde nich gedrückt
if zahl_loeschen=true then  //prüft ob er die zahl im feld löschen darf
   begin
   edit1.text:='';         //wenn ja lösche sie,
   zahl_loeschen:=false;   //und hebe den lösch befehl auf
   end;
end;

procedure tform1.variablen_uebergabe;  //selbst definierte procedure: Zahlen aus dem Edit Feld werden an die Variablen übergeben
begin
istgleich:=false; //istgleich wurde nicht gedrückt
if (zahl2_eingegeben=false)and(zahl1_eingegeben=true) then // wenn die erste zahl eingegeben aba die zweite nicht dann
   begin
   zahl2:=strtofloat(edit1.text);  //übernehme sie
   zahl2_eingegeben:=true;         //notiere das sie übernommen wurde
   zahl_loeschen:=true;            //kann gelöscht werden
   end;                                  //dient zur zahlen übernahme
if (zahl1_eingegeben=false) then    //wenn die erste zahl nicht eingegeben ist dann
   begin
   zahl1:=strtofloat(edit1.text);   //übernehme sie
   zahl1_eingegeben:=true;          //notiere das sie übernommen wurde
   zahl_loeschen:=true;             //kann aus dem fled nun gelöscht werden
   end;
if (zahl2_eingegeben=true)and(zahl1_eingegeben=true) then //sind beide zahlen eingegeben dann
   begin
        rechenarten;               //rechne aus; in selbst erstellter procedure
        zahl1:=strtofloat(edit1.text);  //übernehme ergebnis als erste zahl
        zahl2_eingegeben:=false;     //zweite zahl muss noch eingegeben werden also, 2.zahl ist nicht eingegeben
   end;
end;


procedure TForm1.Button1Click(Sender: TObject);// Taste für 7
begin
zahl_neu;//aufruf eigene procedure, schaut ob er die zahl löschen darf
edit1.text:=edit1.text+'7'; //fügt dem edit feld die 7 zu
end;

procedure TForm1.Button2Click(Sender: TObject);// Taste für 8
begin
zahl_neu; //aufruf eigene procedure, schaut ob er die zahl löschen darf
edit1.text:=edit1.text+'8';  //fügt dem edit feld die 8 zu
end;

procedure TForm1.Button3Click(Sender: TObject); // Taste für 9
begin
zahl_neu;//aufruf eigene procedure, schaut ob er die zahl löschen darf
edit1.text:=edit1.text+'9';  //fügt dem edit feld die 9 zu
end;

procedure TForm1.Button4Click(Sender: TObject); // Taste für 4
begin
zahl_neu;//aufruf eigene procedure, schaut ob er die zahl löschen darf
edit1.text:=edit1.text+'4';   //fügt dem edit feld die 4 zu
end;

procedure TForm1.Button5Click(Sender: TObject); // Taste für 5
begin
zahl_neu;//aufruf eigene procedure, schaut ob er die zahl löschen darf
edit1.text:=edit1.text+'5';   //fügt dem edit feld die 5 zu
end;

procedure TForm1.Button6Click(Sender: TObject); // Taste für 6
begin
zahl_neu;//aufruf eigene procedure, schaut ob er die zahl löschen darf
edit1.text:=edit1.text+'6';   //fügt dem edit feld die 6 zu
end;

procedure TForm1.Button7Click(Sender: TObject);   // Taste für 1
begin
zahl_neu;//aufruf eigene procedure, schaut ob er die zahl löschen darf
edit1.text:=edit1.text+'1';   //fügt dem edit feld die 1 zu
end;

procedure TForm1.Button8Click(Sender: TObject);   // Taste für 2
begin
zahl_neu;//aufruf eigene procedure, schaut ob er die zahl löschen darf
edit1.text:=edit1.text+'2';   //fügt dem edit feld die 2 zu
end;

procedure TForm1.Button9Click(Sender: TObject);  // Taste für 3
begin
zahl_neu;//aufruf eigene procedure, schaut ob er die zahl löschen darf
edit1.text:=edit1.text+'3';   //fügt dem edit feld die 3 zu
end;

procedure TForm1.Button10Click(Sender: TObject);   // Taste für 0
begin
zahl_neu;//aufruf eigene procedure, schaut ob er die zahl löschen darf
edit1.text:=edit1.text+'0';   //fügt dem edit feld die 0 zu
end;

procedure TForm1.Button11Click(Sender: TObject);  // Taste für +/-, damit kann man die Zahl im Edit Feld negativ machen (- davorsetzen)
var zeile:string;   // Eine Variable die nur für diese Procedure
                    // existiert und text aufnehmen kann
begin
zeile:=edit1.text; // inhalt des edit´s feldes an die variable übergeben
if zeile='' then exit;  //testen ob variable leer ist, wenn ja Procedure beenden
if zeile[1]='-' then delete(zeile,1,1) else insert('-',zeile,1); //testen ob das erste Zeichen ein '-' ist, wenn ja lösche es, wenn nein setze es
edit1.text:=zeile; // der inhalt der Variable wird dem edit feld übergeben
end;

procedure TForm1.Button12Click(Sender: TObject); //Komma einfügen
var zeile:string; // Eine Variable die nur für diese Procedure
                    // existiert und text aufnehmen kann
begin
zeile:=edit1.text; // inhalt des edit´s feldes an die variable übergeben
if pos(',',zeile)=0 then zeile:=zeile+','; //suchen ob es schon ein komma gibt, pos() liefert 0 wenn keins da is
edit1.text:=zeile; // der inhalt der Variable wird dem edit feld übergeben
end;

procedure TForm1.Button18Click(Sender: TObject);  //Taste um eine Stelle zurückzusetzen
var zeile:string; // Eine Variable die nur für diese Procedure
                    // existiert und text aufnehmen kann
begin
zeile:=edit1.text; // inhalt des edit´s feldes an die variable übergeben
delete(zeile,length(zeile),1); //letztes zeichen der variablen löschen
edit1.text:=zeile; // der inhalt der Variable wird dem edit feld übergeben
end;


procedure TForm1.Button19Click(Sender: TObject); //voller reset
begin
edit1.text:='';//edit feld leeren
zahl1:=0;   //zahl1 0 setzten
zahl2:=0;   //zahl2 0 setzen
zahl1_eingegeben:=false;  //zahl1 ist nicht eingegeben
zahl2_eingegeben:=false;  //zahl2 ist nicht eingegeben
rechenart:=0;   //rechenart ist 0
end;

procedure TForm1.Button15Click(Sender: TObject);// Taste * gedrückt
begin
if rechenoperation_gewaehlt=true then   //ist schon eine rechenoperation gewählt dann:
   begin
   rechenart:=1; //übernehme zwar die garde gewählte rechnart aba
   exit;         //rechnet nicht gleich damit sondern springt aus der schleife
   end;
rechenoperation_gewaehlt:=true;
variablen_uebergabe; //übernehme zahl aus edit feld in eigener procedure
rechenart:=1;        //stellvertettend für "*"
end;

procedure TForm1.Button16Click(Sender: TObject); // Taste / gedrückt
begin
if rechenoperation_gewaehlt=true then //ist schon eine rechenoperation gewählt dann:
   begin
   rechenart:=2; ///übernehme zwar die garde gewählte rechnart aba
   exit;         //rechnet nicht gleich damit sondern springt aus der schleife
   end;
rechenoperation_gewaehlt:=true;
variablen_uebergabe; //übernehme zahl aus edit feld in eigener procedure
rechenart:=2;        //stellvertettend für "/"
end;

procedure TForm1.Button14Click(Sender: TObject); // Taste + gedrückt
begin
if rechenoperation_gewaehlt=true then //ist schon eine rechenoperation gewählt dann:
   begin
   rechenart:=3;//übernehme zwar die garde gewählte rechnart aba
   exit;         //rechnet nicht gleich damit sondern springt aus der schleife
   end;
rechenoperation_gewaehlt:=true;
variablen_uebergabe;   //übernehme zahl aus edit feld in eigener procedure
rechenart:=3;          //stellvertettend für "+"
end;

procedure TForm1.Button13Click(Sender: TObject); // Taste - gedrückt
begin
if rechenoperation_gewaehlt=true then //ist schon eine rechenoperation gewählt dann:
   begin
   rechenart:=4;//übernehme zwar die garde gewählte rechnart aba
   exit;         //rechnet nicht gleich damit sondern springt aus der schleife
   end;
rechenoperation_gewaehlt:=true;
variablen_uebergabe;  //übernehme zahl aus edit feld in eigener procedure
rechenart:=4;         //stellvertettend für "-"
end;

procedure TForm1.FormCreate(Sender: TObject);//Werten den Variablen zuweisen
begin
zahl1_eingegeben:=false; //zahl 1is nicht eingegeben
zahl2_eingegeben:=false; //zahl2 au nich
zahl_loeschen:=false;  //und es wird auch keine zahl gelöscht
istgleich:=false; // istgleich wurde noch nich gedrückt
rechenoperation_gewaehlt:=false;// es wurde noch keine gewählt
end;

procedure tform1.rechenarten; //selbst definierte Prozedure: sorgt für die Berechnung der Werte+Ausgabe
begin
case rechenart of    //case..of..end isses gleiche wie mehrere if..then..else
        1:edit1.text:=floattostr(zahl1*zahl2);  //rechne mal wenn rechenart=1 und gibs gleich aus
        2:edit1.text:=floattostr(zahl1/zahl2);  //rechne durch wenn rechenart=2 und gibs gleich aus; hier muss ev noch ne Fehlerbehandlung hin... da zZ er ne Fehlermedlung ausgibt und nur mit Reset es weiter geht 
        3:edit1.text:=floattostr(zahl1+zahl2);  //rechne plus wenn rechenart=3 und gibs gleich aus
        4:edit1.text:=floattostr(zahl1-zahl2);  //rechne minus wenn rechenart=4 und gibs gleich aus
        end;
end;

procedure TForm1.Button17Click(Sender: TObject); // Taste fürs "="
begin
if istgleich=true then    //sollte "=" vorher schon gedrückt worden sein, dann:
   begin
   zahl1:=strtofloat(edit1.text);//edit1 inhalt wird zur zahl 1
   rechenarten;                  //und wird mit zahl 2 verrechnet
   end;
if zahl1_eingegeben=true then   //wenn zahl1 schon eingegegeben ist dann
   begin
   zahl2:=strtofloat(edit1.text); //wird edit inhalt zur zahl 2
   rechenarten;                   //es wird gerechnet
   zahl1_eingegeben:=false;       //zahl1 ist nun nicht mehr vorhanden
   zahl2_eingegeben:=false;       //zahl2 mus auch neu eingegegeben werden
   zahl_loeschen:=true;           //zahl darf gelöscht werden
   istgleich:=true;               //es wurde auf "=" geklickt
   end;

end;

Funktionsweise:

-1te Zahl eingeben
-Rechenart wählen
-Programm merkt sich das erste Zahl eingebenen ist UND welcher Wert
-2te Zahl eingeben
-"=" oder Rechnenart wählen
-Programm merkt sich das zweite Zahl eingebenen ist UND welcher Wert
-gibt Ergebnis aus und löscht Zahl1 und Zahl2 und die Rechnart, notiert sie als NICHT eingebenen
- sollte jetzt direkt eine neue Zahl eingegeben werden wird die alte Zahl(das Ergebnis im edit Feld) gelöscht
-sollte ne Rechenart gewählt werden dann wird das Ergbnis wieder übernommen
-sollte eine Aufgabe berechnet sein (Z.B. 5+4=9 ) und dann weiter aufs "=" geklickt werden rechnet er weiter "4" zum Eregbnis dazu

Und das Ding rechnet richtig :D

oldmax - Do 17.08.06 10:01
Titel: Versuch, den Booleantyp zu erklären

Hi
Ich denke, er meint Boolean im allgemeinen. Wofür man eine boolean z.B. braucht.
Also, ein Beispiel:
nehmen wir an, du hast Variablen definiert namens MyFlag1 und MyFlag2 vom Typ Boolean. Auf einen Variablennamen "kleiner" oder "wahr" hab ich absichtlich verzichtet, um zu zeigen, es ist die x-beliebige Variable vom Typ boolean.
Klar ist: 3 ist kleiner 5 also lautet z.B. eine If-Abfrage

Delphi-Quelltext

1:
2:
3:
4:

If 3 < 5 then // keine Klammer nötig
begin
  ....
end;

Eigentlich ist nicht wichtig 3<5 sondern das logische Erggebnis daraus, um der If -Abfrage Sinn zu geben. Also, If "true" then ...
Soweit sollte es klar sein.

Normalerweise stehen für die Zahlen 3 und 5 Variablen mit x-beliebigen Werten und du willst nur Werte erwischen, die kleiner der 2ten Variable sind.
Nehmen wir weiter an, du möchtest Zahlen in einem Bereich von bis haben, dann ist's schon etwas komplizierter.
Also nehmen wir KleinerWert und GrosserWert sowie Wert als Integervariablen auf.
Wenn Wert grösser KleinerWert und kleiner GrosserWert ist, ist unsere Bedingung erfüllt.
In der If Abfrage sieht das wie folgt aus:

Delphi-Quelltext

1:
2:
3:
4:
5:

If (Wert>KleinerWert) and (Wert<GrosserWert) then 
// Klammern erforderlich, sonst Mecker vom Compiler
begin
...
end;

Manchmal hat man aber wesentlich mehr Bedingungen zu betrachten und da helfen schon mal Boolean-Variable, um den Code lesbar zu halten.

Ein wenig Umständlich, aber um es deutlich zu machen:

Delphi-Quelltext

1:
2:
3:
4:
5:
6:

if Wert>KleinerWert then MyFlag1:=True else MyFlag1:=False;
if Wert<GrosserWert then MyFlag2:=True else MyFlag2:=False;
If MyFlag1 and Myflag2 then // keine Klammern nötig, weil schon Boolean
begin
....
end;

es geht natürlich auch einfacher

Delphi-Quelltext

1:
2:
3:
4:
5:
6:

.....
MyFlag1:=Wert>KleinerWert;  // denn Ergebnis ist entweder Wahr oder Falsch
MyFlag2:=Wert<GrosserWert ;
.....

end;

Ich hoffe, diese Erklärung hilft dir ein wenig. Natürlich ist eine Boolean auch für andere Zwecke nützlich, um sich z. B. bestimmte Bearbeitungsschritte zu merken, aber fast immer ist diese Variable mit If, Repeat oder While in Verbindung zu bringen, nur um die wichtigsten zu nennen.
Natürlich ist auch eine Zuweisung an andere Boolsche Variablen zulässig, sowie Visible, Checked, Enabled etc.
Du kannst mal folgendes machen, das geht schnell und ist auch leicht verständlich:
Auf eine Form 3 Editfelder und 2 Panel darunter, so in der größe der Editfelder. und noch ein Button dazu.
Editfeld 1 hat den kleinen Wert, Editfeld 2 ist der Prüfwert und Editfeld 3 ist der obere Wert.
nun der Code, den du in die Ereignisprocedure des Buttons schreibst:

Delphi-Quelltext

1:
2:
3:
4:
5:
6:
7:
8:

Procedure Form1.Button1click(Sender : TObject);
Begin
  if Edit2.Text>Edit1.Text then MyFlag1:=True else MyFlag1:=False;
  if Edit2.Text>Edit3.Text then MyFlag2:=True else MyFlag2:=False;
  Panel1.Visible:=MyFlag1;
  Panel1.Visible:=MyFlag1;

end;

Probier's aus und ich denke, es wird dir etwas klarer, wofür Boolean-Variablen brauchbar sind....
Gruß oldmax

magic87 - Mi 23.08.06 10:30

Sollte meinen Taschenrechner jetzt übersichtlicher mit typisierten Variablen programmieren. Habe ich auch schon bis hier gemacht. Aber irgendwie rechnet der noch nicht richtig. Kann mir da noch jemand ein Tipp geben vll? die Zahlen lassen sich so eintippen wie sie sollten. Auch wenn ich das erste mal plus gedrückt habe, und die zweite Zahl eingeben will. Klappt alles super. nur beim zweiten mal plus drücken sollte er ja das Ergebnis anzeigen. Aber wie mache ich das in meinem Fall? Bin wirklich dankbar für jeden Tipp..
..Dennis

Delphi-Quelltext

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:

//Selbstdefinierter Typen

type {für Ausgabe, ZahlLöschen und eine Zahleingabe}
  TEingabemodus = (emAusgabe,emLoeschen,emZahleneingabe);

type {für die Rechenarten}
  TRechenmodus = (rmAdd,rmSub,rmMult,rmDiv);


type
  TForm1 = class(TForm)
    Edit1: TEdit;
    bt1: TButton;
    bt2: TButton;
    BtPlus: TButton;
    bt3: TButton;
    btgleich: TButton;
    btMinus: TButton;
    BtClear: TButton;
    Button1: TButton;
    Button3: TButton;
    Button2: TButton;
    Button4: TButton;
    Button5: TButton;
    Button6: TButton;
    Button7: TButton;
    Button8: TButton;
    Button9: TButton;
    MainMenu1: TMainMenu;
    Datei1: TMenuItem;
    Beenden1: TMenuItem;
    procedure bt1Click(Sender: TObject);
    procedure bt2Click(Sender: TObject);
    procedure bt3Click(Sender: TObject);
    procedure BtPlusClick(Sender: TObject);
    procedure btMinusClick(Sender: TObject);
    procedure Button1Click(Sender: TObject);
    procedure Button3Click(Sender: TObject);
    procedure btgleichClick(Sender: TObject);
    procedure Beenden1Click(Sender: TObject);
    procedure Button4Click(Sender: TObject);
    procedure Button2Click(Sender: TObject);
    procedure Button5Click(Sender: TObject);
    procedure Button8Click(Sender: TObject);
    procedure Button6Click(Sender: TObject);
    procedure Button9Click(Sender: TObject);
    procedure Button7Click(Sender: TObject);
    procedure FormCreate(Sender: TObject);
  private
    { Private-Deklarationen }

    EingabeModus : TEingabeModus; {Die selbsterstellten Variablen}
    RechenModus  : TRechenModus;

    //Meine Proceduren
    procedure ZahlNeu;
    Procedure Rechenarten;
    procedure Zahlenmerken;

  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;
  Zahl1, Zahl2: integer;


  implementation

{$R *.dfm}

procedure TForm1.ZahlNeu;
begin
If Eingabemodus = (emLoeschen) then
  begin
  edit1.text := '';  {Bei EmLöschen wird Edit leer}
  end;
  Eingabemodus := emZahleneingabe;  {wieder normaler Eingabemodus}
end;


procedure TForm1.Zahlenmerken;  //Soll sich die Beiden Zahlen merken
begin
    if Eingabemodus = emZahleneingabe then
    Zahl1 := strToInt(Edit1.text);
    Eingabemodus := emLoeschen;

    if Eingabemodus = emZahleneingabe then
    Zahl2 := strToInt(Edit1.text);
    Eingabemodus := emLoeschen;

end;


//Zahlentasten
procedure TForm1.bt1Click(Sender: TObject);
begin
  ZahlNeu;
  edit1.text:= edit1.text + '1';
end;

procedure TForm1.bt2Click(Sender: TObject);
begin
  ZahlNeu;
  edit1.text:= edit1.text + '2';
end;

procedure TForm1.bt3Click(Sender: TObject);
begin
  ZahlNeu;
  edit1.text:= edit1.text + '3';
end;

procedure TForm1.Button4Click(Sender: TObject);
begin
  ZahlNeu;
  edit1.text:= edit1.text + '4';
end;

procedure TForm1.Button2Click(Sender: TObject);
begin
  ZahlNeu;
  edit1.text:= edit1.text + '5';
end;

procedure TForm1.Button5Click(Sender: TObject);
begin
  ZahlNeu;
  edit1.text:= edit1.text + '6';
end;

procedure TForm1.Button8Click(Sender: TObject);
begin
  ZahlNeu;
  edit1.text:= edit1.text + '7';
end;

procedure TForm1.Button6Click(Sender: TObject);
begin
  ZahlNeu;
  edit1.text:= edit1.text + '8';
end;

procedure TForm1.Button9Click(Sender: TObject);
begin
ZahlNeu;
edit1.text:= edit1.text + '9';
end;

procedure TForm1.Button7Click(Sender: TObject);
begin
ZahlNeu;
edit1.text:= edit1.text + '0';
end;
//Ende der Zahlentasten



//Plustaste
procedure TForm1.BtPlusClick(Sender: TObject);
begin
  Zahlenmerken;
  edit1.text:= IntToStr(Zahl1 + Zahl2);
end;



end.

Entwickler-Ecke.de based on phpBB
Copyright 2002 - 2011 by Tino Teuber, Copyright 2011 - 2025 by Christian Stelzmann Alle Rechte vorbehalten.
Alle Beiträge stammen von dritten Personen und dürfen geltendes Recht nicht verletzen.
Entwickler-Ecke und die zugehörigen Webseiten distanzieren sich ausdrücklich von Fremdinhalten jeglicher Art!