snafu1
Anmeldungsdatum: 5. September 2007
Beiträge: 2123
Wohnort: Gelsenkirchen
|
ubuntu--anfaenger schrieb: Was mir besonders schwer fällt zu verstehen sind: class(in der Theorie verstehe ich was das ist aber umzusetzen..pfff),Operatoren Funktionen überladen,Pointer u Adressen, und das mit dem Vector selber bauen(Da wurde in dem Buch fast ein Kapitel für verwendet)
Hapert es schon daran, eine eigene Klasse zu schreiben oder bezieht sich das auf ein sinnvolles Klassendesign? Denn letzteres kann auch für Profis anspruchsvoll werden, wenn man auf unbekanntem Terrain ein Interface entwerfen soll. Operator-Überladung kann ganz praktisch sein (z.B. beim Plus), aber ist anfangs nicht wirklich nötig. Pointer brauchst du doch eigentlich kaum, sofern du echt nur C++-Konstrukte verwendest. In der Praxis hat man aber tatsächlich eher einen Mischmasch aus C-Relikten und C++ und so zeigen es auch leider viele Beispiele. Insofern braucht man das Wissen dann eigentlich doch. 😉 Ich wünsche jedenfalls noch viel Erfolg und hoffentlich auch bald wieder mehr Spaß beim Lernen. Und wenn es gar nicht geht, dann schmeißt du C++ halt weg und wendest dich einer anderen Sprache zu... ☺
|
Dakuan
Anmeldungsdatum: 2. November 2004
Beiträge: 6345
Wohnort: Hamburg
|
Erstmal vorne weg, für einfache Aufgaben benutze ich auch meist noch C, aber für größere Projekte nicht.
Des weiteren hat er mir Vorgeschlagen das Buch was ich mir zuerst gekauft hatte(Galileo Computing c/c++ Das umfassende Lehrbuch)werg zuschmeissen, ...
Tatsächlich werden die Bücher eines Autors dieses Verlags in einigen Foren in der Luft zerrissen. Es ist aber nicht so, dass man damit gar nichts anfangen könnte.
... mann sollte nur die fltk Version benutzen, die was bei dem Buch mitgeliefert war, sonst würde der Beispiel code nicht laufen...
Das klingt nach einer sehr alten Version. Das könnte Probleme mit aktuellen Libs geben. Aktuelle Version ist 1.3.5.
Ich geh mal davon aus das das Buch schon so alt ist(20Jahre)das sich mitlerweile Konventionen geändert haben ...
Möglich. Das mit den Konventionen nennt sich übrigens Application Binary Interface (ABI). Das kann sowohl FLTK als auch die Systemlibs betreffen.
... die letzte Idee was ich versucht hatte in code umzusetzen hab da 3Tage für 103 Zeilen gebraucht ...
Vor ca. 30 Jahren hat mir mal ein Kollege (wir sind beide keine Programmierer) erzählt, das eine große Firma festgestellt hatte, das ein Programmierer im Langzeitmittel nur ca. 20 Zeilen pro Tag schafft (debugging gehört dazu). Da bist du doch nahe drann.
|
ChickenLipsRfun2eat
Anmeldungsdatum: 6. Dezember 2009
Beiträge: 12067
|
Dakuan schrieb: Vor ca. 30 Jahren hat mir mal ein Kollege (wir sind beide keine Programmierer) erzählt, das eine große Firma festgestellt hatte, das ein Programmierer im Langzeitmittel nur ca. 20 Zeilen pro Tag schafft (debugging gehört dazu). Da bist du doch nahe drann.
Zu Zeiten von Netflix und Co. dürfte das noch weniger sein 😀 Also ich schreibe seit gestern an einem MPD-Clienten in Qt. Der kann eigentlich nicht viel, bin trotzdem noch nicht fertig, geschweige denn, dass ich schon angefangen hätte das zu verschlimmbessern. Und Codezeilen zählen sagt an sich nicht viel aus. Ich finde bspw. | meineBoolfunktion() ? machWeiter() : gibLaut();
|
viel übersichtlicher als | bool rwert = meineBoolfunktion();
if( rwert == true ) {
machWeiter();
}
else {
gibLaut();
}
|
Wenn mich jemand nach Zeilen bezahlt, nehme ich natürlich Version 2… Freiwillige vor 😀
|
ubuntu--anfaenger
(Themenstarter)
Anmeldungsdatum: 12. Oktober 2013
Beiträge: 1088
Wohnort: Belgien
|
snafu1 schrieb:
Hapert es schon daran, eine eigene Klasse zu schreiben oder bezieht sich das auf ein sinnvolles Klassendesign? Denn letzteres kann auch für Profis anspruchsvoll werden, wenn man auf unbekanntem Terrain ein Interface entwerfen soll.
Also eigentlich Hapert es da an allem 😬 So was einfaches hier bekomme ich hin, aber wenn das ganze komplexer wird 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 | class Fahrrad{
public:
string marke;
int lenker;
int sattel;
int reifen;
char z;
Fahrrad(string m, int l, int s, int r)
:marke(m), lenker(l), sattel(s), reifen(r){}
Fahrrad(string m, char ch, int s, int r)
:marke(m), z(ch), sattel(s), reifen(r){}
};
void out()
{
Fahrrad f1("Pinarello", 1, 1, 2);
Fahrrad f2("GIANT", '+', 1, 2);
cout << f1.marke << " " << f2.z << " " << f2.marke << '\n';
}
int main()
{
out();
return 0;
}
|
Operator-Überladung kann ganz praktisch sein (z.B. beim Plus), aber ist anfangs nicht wirklich nötig.
Ich versteh wenn ich code von anderen lese was denen ihr selbst definierter Operator tut, ich bekomm es nur nicht hin zb einen einfachen der zb 2,3 Zahlen addiert selbst zu basteln.
Pointer brauchst du doch eigentlich kaum, sofern du echt nur C++-Konstrukte verwendest. In der Praxis hat man aber tatsächlich eher einen Mischmasch aus C-Relikten und C++ und so zeigen es auch leider viele Beispiele. Insofern braucht man das Wissen dann eigentlich doch. 😉
Doch ich brauch die weil ich das lernen will ☺ Dakuan schrieb:
Tatsächlich werden die Bücher eines Autors dieses Verlags in einigen Foren in der Luft zerrissen. Es ist aber nicht so, dass man damit gar nichts anfangen könnte.
Also der Kollege der mir gesagt hat ich soll es weglegen, hat dieses Buch selber nicht gelesen, sich nur den code angeschaut.. Ich kann da nur soviel drüber sagen, auf der Rückseite steht das es Anfänger tauglich ist, wenn aber mit null Einsteige, und nach ein paar Seiten eingehämmert bekomme was eine Adjazenz Matrix ist, oder wie komplexe sort Algorithmen funktionieren..und dann den Fehlerhaften code selber berrichtigen muss, ja dann glaube ich, bin ich mit dem Buch was ich jetzt mache besser bedient(das Errata ist ja auch entsprechend lang),für mich sieht das Buch so aus als hätten da mehrere Autoren drann geschrieben und sich nicht richtig abgesprochen,aber ich will das jetzt auch nicht kompl. runter machen..nur halt für jemanden wie mich nicht so geeignet.
Vor ca. 30 Jahren hat mir mal ein Kollege (wir sind beide keine Programmierer) erzählt, das eine große Firma festgestellt hatte, das ein Programmierer im Langzeitmittel nur ca. 20 Zeilen pro Tag schafft (debugging gehört dazu). Da bist du doch nahe drann.
Bei mir ist das immer so das ich etwas länger brauche um zu verstehen, war auch damals beim Umstieg von Win auf linux so, nach der ubu install. wurde der gleiche Rechner wo vorher win drauf, fast doppelt so schnell als hätte mann die Hardware getauscht..ich hatte nichts verstanden und mir mind. 1xpro Woche den Rechner versaut, deswegen sind solche Foren hier gerade für Anfänger sowas von wichtig, auch danke an denen die ihre Freizeit dafür opfern 👍
|
Dakuan
Anmeldungsdatum: 2. November 2004
Beiträge: 6345
Wohnort: Hamburg
|
... wenn aber mit null Einsteige, und nach ein paar Seiten eingehämmert bekomme was eine Adjazenz Matrix ist
Das ist heftig. Ich musste jetzt erstmal nachsehen was das ist und glaube nicht, dass ich das in nächster Zukunft brauchen werde.
... oder wie komplexe sort Algorithmen funktionieren.
Bubblesort könnte ich ja noch verstehen. Wer mehr braucht, für den gibt es "Algorithmen in C++" oder "Introduction to Algarithms" (über 1200 Seiten, Pseudocode, schwere Kost - nichts für Anfänger).
Bei mir ist das immer so das ich etwas länger brauche um zu verstehen,...
Ich brauche auch immer etwas Anlaufzeit, besonders wenn ich bei Problemen niemanden fragen kann. Aber stehen bleiben ist auch keine Lösung. Im übrigen studiere ich auch immer wieder mal fremde Quelltexte.
|
ubuntu--anfaenger
(Themenstarter)
Anmeldungsdatum: 12. Oktober 2013
Beiträge: 1088
Wohnort: Belgien
|
Ich hab noch eine kleine Frage, möchte dafür keinen neuen tread aufmachen. Es behandelt das gleiche Theme,ich verspreche danach hör ich auf zu nerven 😬 Warum schreibt man in der Schleife [i-1]*[i+1]? Warum schreibt man nicht einfach [i]*[i]? | for (int i = 0; i<tok.size(); ++i) {
double d = tok[i-1].value*tok[i+1].value;
}
|
|
ChickenLipsRfun2eat
Anmeldungsdatum: 6. Dezember 2009
Beiträge: 12067
|
Setz doch mal eine Zahl ein:
| i=5;
double d = tok[4].value*tok[6].value;
|
|
Dakuan
Anmeldungsdatum: 2. November 2004
Beiträge: 6345
Wohnort: Hamburg
|
Warum schreibt man in der Schleife [i-1]*[i+1]?
Du multiplizierst da 2 Werte aus einem Array oder Vector und zwar den Wert vor i mit dem danach. Und wenn i mit 0 beginnt liegt der erste Wert [i-1] möglicherweise vor dem Array, falls tok nicht Teil von etwas größerem ist. Manchmal hilft es, sich das mal aufzumalen.
danach hör ich auf zu nerven
Nerven ist etwas anderes. Ich kenne ein Forum, da tauchen immer wieder mal Studenten auf, die ihre Hausaufgaben nicht machen können oder wollen. Da kam dann einmal als Antwort: "Ist denn schon wieder Freitag?"
|
ubuntu--anfaenger
(Themenstarter)
Anmeldungsdatum: 12. Oktober 2013
Beiträge: 1088
Wohnort: Belgien
|
Dakuan schrieb: Du multiplizierst da 2 Werte aus einem Array oder Vector und zwar den Wert vor i mit dem danach. Und wenn i mit 0 beginnt liegt der erste Wert [i-1] möglicherweise vor dem Array, falls tok nicht Teil von etwas größerem ist.
Hier ist der Beispielcode, Aber ich glaub ich hab verstanden was Du da erklärst..zb i-1=Zahl, i=0 '*', i+1=Zahl 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 | // Dieser Beispielcode stammt aus Kapitel 6.3.4 "Token verwenden" des Buches
// "Einf�hrung in die Programmierung mit C++" von Bjarne Stroustrup
//
// #include "std_lib_facilities.h"
//------------------------------------------------------------------------------
class Token {
public:
char kind; // welche Kategorie von Token
double value; // f�r Zahlen: ein Wert
Token(char ch) // erstelle ein Token aus einem char
:kind(ch), value(0) { }
Token(char ch, double val) // erstelle ein Token aus einem char und einem double
:kind(ch), value(val) { }
};
//------------------------------------------------------------------------------
Token get_token(); // liest ein Token aus cin
//------------------------------------------------------------------------------
vector<Token> tok; // hier legen wir die Token ab
//------------------------------------------------------------------------------
int main()
{
while (cin) {
Token t = get_token();
tok.push_back(t);
}
// ...
//Jetzt k�nnen wir mittels einer einfachen Schleife nach der Multiplikatin suchen:
for (int i = 0; i<tok.size(); ++i) {
if (tok[i].kind=='*') { // wir haben eine Multiplikation gefunden!
double d = tok[i-1].value*tok[i+1].value;
// und nun?
}
}
}
|
|
Dakuan
Anmeldungsdatum: 2. November 2004
Beiträge: 6345
Wohnort: Hamburg
|
Ja, richtig. Ich weiß zwar nicht was anhand des Beispiels erklärt werden soll und was danach noch kommt, aber offenbar wird vorausgesetzt, dass der Stern nie die erste oder letzte Eingabe ist.
|
ubuntu--anfaenger
(Themenstarter)
Anmeldungsdatum: 12. Oktober 2013
Beiträge: 1088
Wohnort: Belgien
|
Ich weiß zwar nicht was anhand des Beispiels erklärt werden soll und was danach noch kommt, aber offenbar wird vorausgesetzt, dass der Stern nie die erste oder letzte Eingabe ist.
Es geht sich darum ein Taschenrechner zu programmieren..und die token richtig einlesen. ok danke. ☺ ich hab das jetzt verstanden.
|
Dakuan
Anmeldungsdatum: 2. November 2004
Beiträge: 6345
Wohnort: Hamburg
|
ok danke. ☺ ich hab das jetzt verstanden.
Das freut mich. Und das mit dem Taschenrechner als Lernprojekt scheint ein beliebtes Beispiel zu sein. In meinem Lehrbuch "Der C++ Programmierer" gibt es so etwas auch, sogar mit Syntaxdiagramm, was aber wohl völlig anders strukturiert ist und auf eine Pascal Quelle zurückgeht. Ich habe mir da ein dickes Lesezeichen eingelegt, weil ich noch vorhabe, das mit dem legendärem 8080 Assembler Quelltext des "Tiny Basic"s aus Dr. Dobbs von 1976/5 vergleichen (ich habe nur den Nachdruck davon).
|
ubuntu--anfaenger
(Themenstarter)
Anmeldungsdatum: 12. Oktober 2013
Beiträge: 1088
Wohnort: Belgien
|
Das freut mich. Und das mit dem Taschenrechner als Lernprojekt scheint ein beliebtes Beispiel zu sein.
Ich kann Dir den mal Posten wenn Du magst, warte ich muss da nur noch was anpassen damit der bei Dir Lauffähig ist..ich hab da noch ein paar Dinge eingebaut. 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
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455 | Diese Datei heißt calculator02buggy.cpp
Ich habe 5 Fehler eingefügt, die korrigiert werden müssen, damit sich das Programm kompilieren lässt
Ich habe 3 logische Fehler eingefügt, die zu falschen Ergebnissen führen sollten
Versuchen Sie zunächst, die Fehler ohne Zuhilfenahme des Buches zu finden.
Wenn dies zu mühsam wird, vergleichen Sie den Code mit dem Code im Buch (oder der Beispielsammlung)
Fröhliche Jagd!
*/
//#include <algorithm>
//#include <cmath>
//#include <iomanip>
#include <iostream>
//#include <fstream>
//#include <stdexcept>
//#include <string>
//#include <sstream>
#include <vector>
using namespace std;
inline void error(const string& errormessage)
{
cerr << errormessage << endl;
throw runtime_error(errormessage);
}
inline void error(string s1, string s2)
{
error(s1+s2);
}
inline void keep_window_open(const string& str)
{
static int attempts = 10; // Maximale Anzahl Versuche vor Beendigung
while (--attempts)
{
cout << "Geben Sie " << str << " ein zum Beenden" << endl;
bool exit = true;
for(string::const_iterator p = str.begin(); p != str.end(); ++p)
if (*p != cin.get())
{
exit = false;
break;
}
if (exit)
break;
}
}
//------------------------------------------------------------------------------
const char quit = '#';
const char number = '8';
const char print = ';';
const string prompt = "> ";
const string result = "= ";
const char name = 'a';
const char let = 'L';
const string declkey = "let";
class Token {
public:
char kind; // welche Kategorie von Token
double value; // für Zahlen: ein Wert
string name;
Token(char ch) // erstelle ein Token aus einem char
:kind(ch), value(0) {}
Token(char ch, double val) // erstelle ein Token aus einem char und einem double
:kind(ch), value(val) {}
Token(char ch, string n)
:kind(ch), name(n){}
};
//------------------------------------------------------------------------------
class Token_stream {
public:
Token_stream(); // erstelle einen Token_stream, der aus cin liest
Token get(); // lies ein Token ein (get() ist anderswo definiert)
void putback(Token t); // lege ein Token zurück
void ignore(char c);
private:
bool full; // befindet sich ein Token im Puffer?
Token buffer; // hier legen wir ein Token ab, das mit putback()
// zurückgestellt wurde
};
//------------------------------------------------------------------------------
// Der Konstruktor setzt full auf false, um anzuzeigen, dass der Puffer leer ist:
Token_stream::Token_stream()
:full(false), buffer(0) // kein Token im Puffer
{
}
//------------------------------------------------------------------------------
// Die Memberfunktion putback() stellt ihr Argument zurück in den Puffer von Token_stream:
void Token_stream::putback(Token t)
{
if (full) error("putback(): Zurueckstellen nicht moeglich, Puffer voll");
buffer = t; // kopiere t in den Puffer
full = true; // Puffer ist jetzt voll
}
//------------------------------------------------------------------------------
Token Token_stream::get()
{
if(full){full = false;return buffer;} // gibt es bereits ein fertiges Token?
// Token aus dem Puffer entfernen
char ch;
cin >> ch;
// full=false;
// return buffer;
// char ch;
// cin >> ch; // beachten Sie, dass >> Whitespace-Zeichen wie
// Leerzeichen, Zeilenumbruch, Tabulatorzeichen, etc. überspringt
switch (ch) {
case quit:
case print:
case'(':
case')':
case'+':
case'-':
case'*':
case'/':
case'%':
case'!':
case'=':
case'_':
return Token(ch);
case'.':
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
{
cin.putback(ch); // lege die Ziffer zurück in den Eingabestream
double val;
cin >> val; // lies eine Gleitkommazahl
return Token(number,val); // '8' repräsentiert "eine Zahl"
}
default:
if(isalpha(ch)){
string s;
s += ch;
while(cin.get(ch) && (isalpha(ch) || isdigit(ch))) s+=ch;
cin.putback(ch);
if(s == declkey)return Token(let);
// if(s == quit)return Token(#);
return Token(name,s);
}
error("Ungueltiges Token");
return 0;
}
}
void Token_stream::ignore(char c)
{
if(full && c==buffer.kind){
full=false;
return;
}
full=false;
char ch = 0;
while(cin>>ch)
if(ch==c)return;
}
//------------------------------------------------------------------------------
Token_stream ts; // stellt get() und putback() zur Verfügung
//------------------------------------------------------------------------------
class Variable {
public:
string name;
double value;
Variable(string n,double v) :name(n),value(v){}
};
//-------------------------------------------------------------------
vector<Variable>var_table;
//--------------------------------------------------------------------
double get_value(string s)
{
for(int i=0;i<var_table.size();++i)
if(var_table[i].name == s)return var_table[i].value;
error("get: nicht definierte Variable",s);
return 0;
}
//---------------------------------------------------------------------
void set_value(string s,double d)
{
for(int i=0;i<var_table.size();++i)
if(var_table[i].name == s){
var_table[i].value = d;
return;
}
error("set: nicht definierte Variable ",s);
}
//---------------------------------------------------------------------
bool is_declared(string var)
{
for(int i=0; i<var_table.size(); ++i)
if(var_table[i].name == var)return true;
return false;
}
//---------------------------------------------------------------------
double define_name(string var, double val)
{
if(is_declared(var))error(var," doppelt deklariert");
var_table.push_back(Variable(var,val));
return val;
}
//---------------------------------------------------------------------
double expression(); // Deklaration, damit primary() expression() aufrufen kann
//------------------------------------------------------------------------------
// behandelt Zahlen und Klammern
double primary()
{
Token t = ts.get();
switch (t.kind) {
case '(': // behandle'(' Ausdruck ')'
{
double d = expression();
t = ts.get();
if (t.kind != ')') error("')' expected");
return d;
}
case number: // wir verwenden '8' zur Repräsentation einer Zahl
return t.value; // liefere den Wert der Zahl zurück
case name:
return get_value(t.name);
case '-':
return - primary();
case '+':
return primary();
default:
error("primary erwartet!");
return 0;
}
}
//------------------------------------------------------------------------------
double fak(double i)
{
if(i)
{
return i * fak(i-1);
}
return 1;
}
double quad(double a){
{
return a*a;
}
return 1;
}
double unary()
{
double left = primary();
Token t = ts.get();
while(true){
switch(t.kind){
case '!':
{
left = fak(left);
t = ts.get();
break;
}
case '_':
{
left = quad(left);
t = ts.get();
break;
}
default:
ts.putback(t);
return left;
}
}
}
// behandelt *, / und %
double term()
{
double left = unary();
Token t = ts.get(); // lies das nächste Token aus dem Token-Stream ein
while(true) {
switch (t.kind) {
case '*':
left *= unary();
t = ts.get();
break;
case '/':
{
double d = unary();
if (d == 0) error("Division durch null");
left /= d;
t = ts.get();
break;
}
case '%':
{
double d = unary();
int i1 = int(left);
if(i1 != left)error("linker Operand von % ist keine ganze Zahl");
int i2 = int(d);
if(i2 != d)error("rechter Operand von % ist keine ganze Zahl");
if(i2 == 0)error("%: Division durch null");
left = i1 % i2;
t = ts.get();
break;
}
default:
ts.putback(t); // stelle t wieder zurück in den Token-Stream
return left;
}
}
}
//------------------------------------------------------------------------------
// behandelt + und
double expression()
{
double left = term(); // liest einen Token ein und wertet ihn aus
Token t = ts.get(); // lies das nächste Token aus dem Token-Stream ein
while(true) {
switch(t.kind) {
case '+':
left += term(); // werte Term aus und addiere
t = ts.get();
break;
case '-':
left -= term(); // werte Term aus und subtrahiere
t = ts.get();
break;
default:
ts.putback(t); // stelle t wieder zurück in den Token-Stream
return left; // keine weiteren + oder ; Antwort zurückliefern
}
}
}
//------------------------------------------------------------------------------
double declaration()
{
Token t = ts.get();
if(t.kind != name)error("die Deklaration erwartet einen Namen");
string var_name = t.name;
Token t2 = ts.get();
if(t2.kind != '=')error("= fehlt in der Deklaration von ",var_name);
double d = expression();
define_name(var_name,d);
return d;
}
//---------------------------------------------------------------------
double statement()
{
Token t = ts.get();
switch(t.kind){
case let:
return declaration();
default:
ts.putback(t);
return expression();
}
}
//---------------------------------------------------------------------
void clean_up_mess()
{
ts.ignore(print);
}
void calculate()
{
while(cin)
try{
cout << prompt;
Token t = ts.get();
while(t.kind==print)t=ts.get();
if(t.kind==quit)return;
if(t.kind=='p')return;
ts.putback(t);
cout << result << statement() << endl;
}
catch(exception& e){
cerr << e.what() << endl;
clean_up_mess();
}
}
int main()
try
{
cout << "Willkommen beim Taschenrechnerprogramm \n";
define_name("pi", 3.1415926535);
define_name("e", 2.7182818284);
calculate();
// keep_window_open();
return 0;
}
catch (runtime_error& e){
cerr << e.what() << endl;
keep_window_open("q");
return 1;
}
catch (...) {
cerr << "Hoppla: unbekannte Ausnahme!\n";
keep_window_open("q");
return 2;
}
//------------------------------------------------------------------------------
|
|
Dakuan
Anmeldungsdatum: 2. November 2004
Beiträge: 6345
Wohnort: Hamburg
|
Nachdem ich das mit dem Schleifenzähler geschrieben hatte, kam mir schon der Verdacht, dass das Absicht war. Darum meine vorsichtige Ergänzung. Ich hoffe ich habe dadurch nicht den Lerneffekt verhindert. Danke für den Code. Den kann ich mir aber aus Zeitmangel noch nicht richtig ansehen. Kommt aber in meine Sammlung.
|
ubuntu--anfaenger
(Themenstarter)
Anmeldungsdatum: 12. Oktober 2013
Beiträge: 1088
Wohnort: Belgien
|
Nachdem ich das mit dem Schleifenzähler geschrieben hatte, kam mir schon der Verdacht, dass das Absicht war.
Ich hab das auf jedenfall jetzt kapiert.
Danke für den Code.
Bitte ist aus dem Buch, da sind auf jedenfall keine Fehler mehr drinn, die fakultät Funktion,und das quit, habe ich da eingebaut ☺
|