[SIZE="5"][COLOR="Red"]C++ Befehle Teil 1[/COLOR][/SIZE]


Hallo zusammen,

ich hab mal alles zusammengesucht was ich so noch an befehlen für c++ ausgegraben konnte. hoffe es hilft dem einen oder anderm ^^



[SIZE="4"][COLOR="Red"]Textausgabe[/COLOR][/SIZE]

[COLOR="MediumTurquoise"]cout<<”text”;[/COLOR] [COLOR="Magenta"](iostream.h)[/COLOR] Textausgabe an den Bildschirm
[COLOR="MediumTurquoise"]cout<< variable;[/COLOR][COLOR="Magenta"] (iostream.h)[/COLOR] Ausgabe einer Zahl an den Bildschirm
[COLOR="MediumTurquoise"]cout.width(x);[/COLOR] [COLOR="Magenta"] (iostream.h)[/COLOR] Angabe bis wohin der nächste Text gehen wird
[COLOR="MediumTurquoise"]clrscr();[/COLOR] [COLOR="Magenta"] (conio.h)[/COLOR] Löscht 50 Zeilen Text im Fenster (cls)
[COLOR="MediumTurquoise"]system(cls);;[/COLOR] Löscht den Bildschirm
[COLOR="MediumTurquoise"]_settextposition (y,x);[/COLOR] [COLOR="Magenta"][/COLOR] (conio.h) Sprung im Text zu der angegebenen Stelle, oben ist (1,1)
[COLOR="MediumTurquoise"]clreol();[/COLOR] [COLOR="Magenta"] (conio.h)[/COLOR] Löscht Zeile ab Cursor (bis zum Ende der Zeile)
[COLOR="MediumTurquoise"]cout << sizeof(12.f),sizeof[/COLOR] [COLOR="Magenta"] (iostream.h)[/COLOR] Gibt die Speichergrösse von 12(float), dem Wort XXX, ... an (”XXX”),
[COLOR="MediumTurquoise"]textcolor (10);[/COLOR] [COLOR="Magenta"] (conio ,iostream.h)[/COLOR] Legt Textfarbe fest
[COLOR="MediumTurquoise"]textbackground (3);[/COLOR] [COLOR="Magenta"] (conio, iostream.h)[/COLOR] Legt Texthintergrundfarbe fest
[COLOR="MediumTurquoise"]_settextposition( 10, 40 );[/COLOR] [COLOR="Magenta"] (iostream.h)[/COLOR] Setzt Cursor an die angegebene Stelle ((1,1) ist ganz oben)


[COLOR="Red"][SIZE="4"]Eingabe und Ausgabe
[/SIZE][/COLOR]

[COLOR="MediumTurquoise"]cerr << ”Fehlermeldung”;[/COLOR] [COLOR="Magenta"] (iostream.h)[/COLOR] Auf cerr werden Fehlermeldungen geschickt. (auf den Bildschirm normalerweise, das kann man aber ändern)
[COLOR="MediumTurquoise"]clog << ”andere Fehler”;[/COLOR] [COLOR="Magenta"] (iostream.h)[/COLOR] Fast das selbe wie cerr. Einziger Unterschied: Pufferung.
[COLOR="MediumTurquoise"]cout << flush [/COLOR] [COLOR="Magenta"](iostream.h)[/COLOR] Bewirkt dass der Puffer geleert wird
[COLOR="MediumTurquoise"]cout.width (42) [/COLOR] [COLOR="Magenta"](iomanip.h)[/COLOR] Bewirkt dass über <<eingegebenen Daten in Breite 42 Zeichen ausgegeben werden. Rest wird mit Leerstellen links ausgefüllt.
[COLOR="MediumTurquoise"]cout << setw(10) << ”...” [/COLOR] [COLOR="Magenta"](iomanip.h)[/COLOR] Links wird mit Leerzeichen aufgefüllt um Breite 10 zu erreichen
[COLOR="MediumTurquoise"]cout.fill('.'); [/COLOR] [COLOR="Magenta"](iomanip.h)[/COLOR] Anstatt mit Leerzeichen wird (hier) mit . aufgefüllt. Mit cout.fill(' '); stellt man wieder auf Leerzeichen zurück.
[COLOR="MediumTurquoise"]cout << setfill ('.') << ... [/COLOR] [COLOR="Magenta"](iomanip.h)[/COLOR] Wie cout.fill: Füllzeichen wird hier der Punkt
[COLOR="MediumTurquoise"]setiosflags(ios::left) [/COLOR] [COLOR="Magenta"](iomanip.h)[/COLOR] Ausrichtung der Daten wird auf linksbündig geändert.
[COLOR="MediumTurquoise"]resetiosflags(ios::left) [/COLOR] [COLOR="Magenta"](iomanip.h)[/COLOR] setiosflags rückgängig machen
[COLOR="MediumTurquoise"]cout.setf(ios::fixed); [/COLOR] [COLOR="Magenta"](iomanip.h)[/COLOR] Jede Zahl wird mit gleich viel Nachkommazahlen angezeigt (nicht Exponentialdarstellung).cout.precision vorher benutzen
[COLOR="MediumTurquoise"]cout<<setiosflags(ios::showpos)[/COLOR] [COLOR="Magenta"] (iomanip.h)[/COLOR] Auch bei positiven Zahlen wird das Vorzeichen angezeigt
[COLOR="MediumTurquoise"]cout<<setiosflags(ios::internal)[/COLOR] [COLOR="Magenta"] (iomanip.h)[/COLOR] Füllzeichen werden zwischen Vorzeichen und Zahl eingeschoben
[COLOR="MediumTurquoise"]cout<<resetiosflags [/COLOR] [COLOR="Magenta"](iomanip.h)[/COLOR] Mit resetiosflags können mehrere Dings gleichzeitig ein- bzw (ios::... | ios: ...) ausgeschaltet werden.
[COLOR="MediumTurquoise"]cout << dec oder hex oder oct[/COLOR] [COLOR="Magenta"] (iomanip.h)[/COLOR] Zahlen werden ins entsprechende Zahlensystem umgewandelt
[COLOR="MediumTurquoise"]cout<<setiosflags(ios::upperc[/COLOR] [COLOR="Magenta"] (iomanip.h)[/COLOR] Zahlen werden in Grossbuchstaben ausgegeben (keine aus ase); dem Dezimalsystem!)
[COLOR="MediumTurquoise"]cout<<setiosflags(ios::showbase)[/COLOR] [COLOR="Magenta"] (iomanip.h)[/COLOR] Zahlen werden in Programmierernotation ausgegeben
[COLOR="MediumTurquoise"]if(cin.fail()){...} oder if(!cin)[/COLOR] [COLOR="Magenta"] (iostream.h)[/COLOR] Testet auf schwere oder behebbare Fehler. Schliesst bad() ein.
[COLOR="MediumTurquoise"]if(!cin.fail()) oder if(cin)[/COLOR] [COLOR="Magenta"] (iostream.h)[/COLOR] Das Gegenteil von if(!cin), schliesst EOF nicht aus.
[COLOR="MediumTurquoise"]cin.bad()[/COLOR] [COLOR="Magenta"] (iostream.h)[/COLOR] Testet auf schwere, nicht behebbare Fehler.
[COLOR="MediumTurquoise"]cin.eof()[/COLOR] [COLOR="Magenta"] (iostream.h)[/COLOR] Testet auf Dateiende bzw. 0x1A im Datenstrom.
[COLOR="MediumTurquoise"]cin.good()[/COLOR] [COLOR="Magenta"] (iostream.h)[/COLOR] Testet auf Fehlerlosigkeit
[COLOR="MediumTurquoise"]clear()[/COLOR] [COLOR="Magenta"] (iostream.h)[/COLOR] Fehlerinformation zurücksetzen. Zur Fehlersimulation)kann in den Klammern ios::failbit, ios::badbit oder ios::eofbit stehen
[COLOR="MediumTurquoise"]cin.seekg (0L,ios::end)[/COLOR] [COLOR="Magenta"] (iostream.h) [/COLOR]Restdaten werden übersprungen (Zeiger wird zum Stromende verschoben). 0(long) ist die Distanz zu end.
[COLOR="MediumTurquoise"]cin.seekg (0L,ios::cur)[/COLOR] [COLOR="Magenta"] (iostream.h)[/COLOR] Nichts ändert sich (cur=current)
[COLOR="MediumTurquoise"]cin.seekg (0L,ios::beg)[/COLOR] [COLOR="Magenta"] (iostream.h)[/COLOR] Zeiger wird zum Stromanfang verschoben (beg=begin)
[COLOR="MediumTurquoise"]while((cin.peek())>57 || cin.peek()<48) cin.ignore(); [/COLOR] [COLOR="Magenta"] (iostream.h)[/COLOR] Untersucht eingegebene Zeichen (ASCII); falls es keine Zahlen sind werden sie erbarmungslos ausgemerzt.
[COLOR="MediumTurquoise"]cin.getline(text,127);[/COLOR] [COLOR="Magenta"] (fstream.h)[/COLOR] Das Eingegebene wird in text kopiert bis zum nächsten Return (mitsamt Abständen). (?) Der dritte Parameter ist standardmässig ‘\n’
[COLOR="MediumTurquoise"]cin.get(text,127);[/COLOR] [COLOR="Magenta"] (fstream.h)[/COLOR] Das Eingegebene wird in text kopiert bis zum nächsten Return.


[COLOR="Red"][SIZE="4"]Dateien
[/SIZE][/COLOR]

[COLOR="MediumTurquoise"]ofstream Ausgabe;[/COLOR] [COLOR="Magenta"] (iomanip, fstream.h) [/COLOR] Der argumentlose Konstruktor erzeugt das Objekt Ausgabe
[COLOR="MediumTurquoise"]Ausgabe.open(datei1,ios::app)[/COLOR] [COLOR="Magenta"] (iomanip, fstream.h)[/COLOR] datei1 (= Name der Datei) wird geöffnet, Zeiger wird an Dateiende gesetzt (damit man anhängen kann)
[COLOR="MediumTurquoise"]Ausgabe.close();[/COLOR] [COLOR="Magenta"] (iomanip, fstream.h)[/COLOR] Ausgabe wird wieder freigemacht. (und Datei geschlossen)
[COLOR="MediumTurquoise"]ofstream Ausgabe2(datei2,ios::ate) (iomanip, fstream.h)[/COLOR] Konstruktor wird sofort mit 2 Argumenten aufgerufen, Zeiger wird an den Anfang der Datei gesetzt.

[COLOR="MediumTurquoise"]Dateimodus[/COLOR] [COLOR="Magenta"] Beschreibung[/COLOR]

[COLOR="MediumTurquoise"]ios::in[/COLOR] [COLOR="Magenta"] Lesen, verhindert bei Ausgabedateien Löschen[/COLOR]
[COLOR="MediumTurquoise"]ios::nocreate[/COLOR] [COLOR="Magenta"] Kein Anlegen fehlender Dateien[/COLOR]
[COLOR="MediumTurquoise"]ios::Out[/COLOR] [COLOR="Magenta"] Schreiben; ohne Angabe weiterer Modi werden vorhandene Dateien gelöscht[/COLOR]
[COLOR="MediumTurquoise"]ios::app[/COLOR] [COLOR="Magenta"] Ausgabe an Datei anhängen[/COLOR]
[COLOR="MediumTurquoise"]ios::ate[/COLOR] [COLOR="Magenta"] Ausgabe an Datei anhängen, erlaubt nach erster Schreibanweisung Verschieben des Dateipointers[/COLOR]
[COLOR="MediumTurquoise"]ios:noreplace[/COLOR] [COLOR="Magenta"] Keine vorhandene Datei überschreiben[/COLOR]
[COLOR="MediumTurquoise"]ios::trunc[/COLOR] [COLOR="Magenta"] Vorhandenen Dateiinhalt löschen[/COLOR]

[COLOR="MediumTurquoise"]ifstream test; ¿ test.open(text,ios::in|ios:nocreate);[/COLOR] [COLOR="Magenta"] (iomanip, fstream.h)[/COLOR] Testet ob eine Datei existiert (löscht oder ändert nichts und legt auch keine neue Datei an falls nicht vorhanden)
[COLOR="MediumTurquoise"]if (test.good()) ¿ cout ... [/COLOR] [COLOR="Magenta"] (iomanip, fstream.h)[/COLOR] Falls der Test in der vorigen Zeile gut ausgefallen war, tue ...
[COLOR="MediumTurquoise"]eingabe.seekg (0L,ios::end)[/COLOR] [COLOR="Magenta"] (iomanip, fstream.h)[/COLOR] Pointer wird an das Ende gesetzt (-5L,ios::cur) würde Pointer um 5 Bytes Richtung Anfang versetzen)
[COLOR="MediumTurquoise"]cout << eingabe.tellg()[/COLOR] [COLOR="Magenta"] (iomanip, fstream.h)[/COLOR] Gibt hier die Dateigrösse aus (Position des Zeigers ab Start)
[COLOR="MediumTurquoise"]streampos pos1,pos2[/COLOR] [COLOR="Magenta"] (iomanip, fstream.h)[/COLOR] Deklaration von Variablen des Typs streampos
[COLOR="MediumTurquoise"]ofstream Drucker(”PRN”,ios::o ut|ios::app);cout=Drucker;[/COLOR] [COLOR="Magenta"][/COLOR] (iomanip, fstream.h) Alles was auf cout geschickt wird kommt zum Drucker raus
[COLOR="MediumTurquoise"]ofstream drucken(”PRN”,ios::out|ios::app)[/COLOR] [COLOR="Magenta"] (iomanip, fstream.h)[/COLOR] Alles was auf drucken geschickt wird wird gedruckt


[COLOR="MediumTurquoise"]Methode[/COLOR] [COLOR="Magenta"] Beschreibung[/COLOR]

[COLOR="MediumTurquoise"]close[/COLOR] [COLOR="Magenta"] Schliesst eine Datei[/COLOR]
[COLOR="MediumTurquoise"]get[/COLOR] [COLOR="Magenta"] Liest Zeichen und lässt Stoppzeichen im Datenstrom[/COLOR]
[COLOR="MediumTurquoise"]getline[/COLOR] [COLOR="Magenta"] Liest Zeichen und entfernt Stoppzeichen aus Datei[/COLOR]
[COLOR="MediumTurquoise"]ignore[/COLOR] [COLOR="Magenta"] Entfernt Zeichen aus dem Datenstrom[/COLOR]
[COLOR="MediumTurquoise"]open[/COLOR] [COLOR="Magenta"] Initialisiert das Objekt und öffnet eine Datei[/COLOR]
[COLOR="MediumTurquoise"]peek[/COLOR] [COLOR="Magenta"] Prüft nächstes Zeichen im Datenstrom, ohne zu lesen[/COLOR]
[COLOR="MediumTurquoise"]put[/COLOR] [COLOR="Magenta"] Schreibt ein einzelnes Zeichen[/COLOR]
[COLOR="MediumTurquoise"]read[/COLOR] [COLOR="Magenta"] Liest Datenblock in einen Speicherbereich[/COLOR]
[COLOR="MediumTurquoise"]seekg,seekp[/COLOR] [COLOR="Magenta"] Bewegt Dateizeiger[/COLOR]
[COLOR="MediumTurquoise"]tellg,tellp[/COLOR] [COLOR="Magenta"] Ermittelt Dateizeigerposition[/COLOR]
[COLOR="MediumTurquoise"]write[/COLOR] [COLOR="Magenta"] Schreibt einen Speicherbereich als Datenblock[/COLOR]



[COLOR="Red"][SIZE="4"]Escape - Sequenzen[/SIZE][/COLOR]

[COLOR="MediumTurquoise"]cout<<endl;oder cout<<”\n”; [/COLOR] [COLOR="Magenta"](iostream.h)[/COLOR] Zeilensprung bei Textausgabe;endl leert ausserdem den Puffer
[COLOR="MediumTurquoise"]cout<<”\t”[/COLOR] [COLOR="Magenta"] (iostream.h)[/COLOR] Tab, springt zu Position 9, 17, 25, 33, ...
[COLOR="MediumTurquoise"]cout<<”\r” [/COLOR] [COLOR="Magenta"](iostream.h)[/COLOR] Wagenrücklauf, Cursor kommt an Anfang der Zeile
[COLOR="MediumTurquoise"]cout<<”\v”[/COLOR] [COLOR="Magenta"] (iostream.h)[/COLOR] Vertikaler Tabulator (?)
[COLOR="MediumTurquoise"]cout<<”\b” [/COLOR] [COLOR="Magenta"](iostream.h)[/COLOR] Backspace, ein Zeichen wird gelöscht
[COLOR="MediumTurquoise"]cout<<”\f” [/COLOR] [COLOR="Magenta"](iostream.h) [/COLOR]Formfeed, neue Seite (?)
[COLOR="MediumTurquoise"]cout<<”\\...\’...\”...”[/COLOR] [COLOR="Magenta"] (iostream.h)[/COLOR] Schreibt ein \,ein ",ein '
[COLOR="MediumTurquoise"]cout<<”\a”; oder cout<<”\007”;[/COLOR] [COLOR="Magenta"] (iostream.h)[/COLOR] Gibt Alarm (ein sehr kurzer Piepser)



[COLOR="Red"][SIZE="4"]Textverarbeitung[/SIZE][/COLOR]

[COLOR="MediumTurquoise"]char x=65, y='B';[/COLOR] [COLOR="Magenta"] (iostream.h)[/COLOR] x ist 65, also das ASCII-Zeichen A, und y ist 66, B.
[COLOR="MediumTurquoise"]char datei1 [] =”abc.xyz” [/COLOR] [COLOR="Magenta"](iostream.h)[/COLOR] datei1 mit Text füllen
[COLOR="MediumTurquoise"]class string xxx; ¿ xxx=”...”[/COLOR] [COLOR="Magenta"] (cstring.h)[/COLOR] einen String festlegen, und ihn dann mit Text füllen

[COLOR="MediumTurquoise"]text2=text3; [/COLOR] [COLOR="Magenta"](cstring.h)[/COLOR] text3 in text2 kopieren (strings)

[COLOR="MediumTurquoise"]size_t x; ¿ x=text.find(”i”); [/COLOR] [COLOR="Magenta"](cstring.h)[/COLOR] x erhält die Zahl der Position -1 wo sich i im string text befindet, falls n.v. 65535 (Trick: x++, dann ist x 0 falls n.v.)
[COLOR="MediumTurquoise"]strcat (text,fcvt(Zahl,0, &dec,&sign));[/COLOR] [COLOR="Magenta"] (string.h)[/COLOR] Hänge eine Zahl an einen Text an, die Zahl wird in Textverwandelt (vorherige Initialisierung nötig) 0 ist die Anzahl der Nachkommastellen. (vorher: int dec,sign;)



[COLOR="Red"][SIZE="4"]Interface[/SIZE][/COLOR]

[COLOR="MediumTurquoise"]cin >> variable;[/COLOR] [COLOR="Magenta"] (iostream.h)[/COLOR] Gabe des eingetippten Wertes an die Variable
[COLOR="MediumTurquoise"]char wort [20]; ¿ cin >>wort;[/COLOR] [COLOR="Magenta"] (string.h)[/COLOR] Gabe des eingetippten Wortes an den char
[COLOR="MediumTurquoise"]getch();[/COLOR] [COLOR="Magenta"] (conio.h)[/COLOR] Pause bis Taste gedrückt wird
[COLOR="MediumTurquoise"]if (kbhit()){break;}[/COLOR] [COLOR="Magenta"] (stdio.h, conio.h)[/COLOR] Abbruch sobald eine Taste gedrückt wird; im Gegensatz zu getch wird Computer bei Kontrolle nicht angehalten Anschliessend kann getch die Taste ermitteln.
[COLOR="MediumTurquoise"]char tast; ¿ tast=cin.get();[/COLOR] [COLOR="Magenta"] (iostream.h)[/COLOR] Nimmt die nächste Taste die der User drückt in tast auf (?)
[COLOR="MediumTurquoise"]var=getch()-48; [/COLOR] [COLOR="Magenta"](conio.h)[/COLOR] var erhält den Wert der nächsten Ziffer die gedrückt wird

C++ Syntax Teil 2

[SIZE="5"][COLOR="Red"]C++ Befehle Teil 2 [/COLOR][/SIZE]



[COLOR="Red"][SIZE="4"]Arrays[/SIZE][/COLOR]

[COLOR="MediumTurquoise"]int/float/... test [3] [5] [5]; [/COLOR] [COLOR="Magenta"](iostream.h) [/COLOR]Festlegen eines (mehr)dimensionalen Arrays (Feldes). Die Arrays hier im Beispiel heissen von[0] [0] [0] bis[2] [4] [4]
[COLOR="MediumTurquoise"]test [2][4][4] = 17 [/COLOR] [COLOR="Magenta"](iostream.h) [/COLOR]Wertzuweisung an ein Array
[COLOR="MediumTurquoise"]int test [][2]={{1},{3,4}}; [/COLOR] [COLOR="Magenta"](iostream.h)[/COLOR] test[0][0] erhält den Wert 1, [0][1] 0 (nicht definiert), [1][0] 3 und [1][1] 4. Diese Arrays werden automatisch erschaffen.
[COLOR="MediumTurquoise"]char t[6]¿t[0]=’x’¿...t[4]=’\o’[/COLOR] [COLOR="Magenta"] (iostream.h)[/COLOR] Festlegen des Arrays(für Text). ‘\0’ ist die Endemarkierung.
[COLOR="MediumTurquoise"]xxx=text1.compare(text2); [/COLOR] [COLOR="Magenta"](cstring.h) [/COLOR]beide strings werden alphabetisch verglichen; falls beide gleich sind wird xxx 0, sonst einen anderen Wert
[COLOR="MediumTurquoise"]strcpy(test,”Hallo”); [/COLOR] [COLOR="Magenta"](string.h) [/COLOR]Ein vorher definiertes leeres String wird mit Hallo\0 gefüllt.
[COLOR="MediumTurquoise"]strcat(test,” Welt!”); [/COLOR] [COLOR="Magenta"](string.h) [/COLOR]An ein bestehendes Array wird angehängt, \0 wird verschoben
[COLOR="MediumTurquoise"]strncat (test, ”Hallo”,3); [/COLOR] [COLOR="Magenta"](stdio.h, string.h)[/COLOR] Ans Array werden die ersten 3 Zeichen von Hallo angehängt
[COLOR="MediumTurquoise"]cout << strlen(test); [/COLOR] [COLOR="Magenta"](string.h) [/COLOR]Ermittelt die Länge des Textes im Array, ohne die binäre Null
[COLOR="MediumTurquoise"]char test[]=”text”; [/COLOR] [COLOR="Magenta"](iostream.h) [/COLOR]Füllt das Array mit “text”, und setzt seine Grösse fest (hier 5!)
[COLOR="MediumTurquoise"]int * pFeld = new int [zahl]; [/COLOR] [COLOR="Magenta"](iostream.h) [/COLOR]Kreiert das Array pFeld mit der Grösse [zahl]
[COLOR="MediumTurquoise"]const int a=50 ¿ int arra[a];[/COLOR] [COLOR="Magenta"] (iostream.h)[/COLOR] Ohne const ist es nicht möglich arra mit der Grösse a festzulegen


[COLOR="Red"][SIZE="4"]Strukturen und Verbunde[/SIZE][/COLOR]

[COLOR="MediumTurquoise"]struct artikel{int ArtNr; double Umsatz ...;}; [/COLOR] [COLOR="Magenta"](iostream.h)[/COLOR] Festlegen der Struktur artikel
[COLOR="MediumTurquoise"]artikel xyz; ¿ xyz.ArtNr=20; xyz.Umsatz=234573.98; [/COLOR] [COLOR="Magenta"](iostream.h)[/COLOR] Eingabe der Werte für die Struktur artikel
[COLOR="MediumTurquoise"]union ... (siehe struct) [/COLOR] [COLOR="Magenta"](iostream.h)[/COLOR] Wie struct, bloss dass alle Werte ineinander liegen (man braucht nicht allen Komponenten einen Wert zuzuweisen)


[COLOR="Red"][SIZE="4"]Kontrollstrukturen[/SIZE][/COLOR]

[COLOR="MediumTurquoise"]if(a==b){1.;}else{2.;}[/COLOR] [COLOR="Magenta"] (iostream.h)[/COLOR] Falls Bedingung zutrifft, tue 1., sonst 2.
[COLOR="MediumTurquoise"]if (text1==”Michel”) {... ;}[/COLOR] [COLOR="Magenta"] (cstring.h)[/COLOR] Falls string text1 Michel ist, dann …
[COLOR="MediumTurquoise"]if ((a)||(b)), ((a)&&(b)) {;}[/COLOR] [COLOR="Magenta"] (iostream.h)[/COLOR] ||: oder, es genügt dass eine von zwei, drei,…zutrifft, &&: und
[COLOR="MediumTurquoise"]or(i=a;i<=b;i++){...} [/COLOR] [COLOR="Magenta"](iostream.h)[/COLOR] Beginne bei a, zähle jedesmal 1 hinzu und höre bei b auf die {} auszuführen
[COLOR="MediumTurquoise"]while(bedingung){anweisung;}[/COLOR] [COLOR="Magenta"] (iostream.h)[/COLOR] Solange Bedingung zutrifft, führe Anweisung aus
[COLOR="MediumTurquoise"]do{anweisung;}while(bedingu);[/COLOR] [COLOR="Magenta"] (iostream.h)[/COLOR] Wie while, bloss dass anweisung einmal mehr ausgeführt wird
[COLOR="MediumTurquoise"]a=bedingung?wert1:wert2; [/COLOR] [COLOR="Magenta"](iostream.h)[/COLOR] Falls Bedingung zutrifft erhält a den Wert1, sonst den Wert2.
[COLOR="MediumTurquoise"]marke: ... ¿ goto marke;[/COLOR] [COLOR="Magenta"] (iostream.h)[/COLOR] Zur Markierung springen, nur innerhalb einer Funktion
[COLOR="MediumTurquoise"]longjmp [/COLOR] [COLOR="Magenta"](setjmp.h)[/COLOR] Wie goto, jedoch auch ausserhalb einer Funktion
[COLOR="MediumTurquoise"]switch(x) ¿ {case 1: case 4: ¿ ... ¿ ...}[/COLOR] [COLOR="Magenta"] (iostream.h)[/COLOR] x hat einen vorher eingegebenen Wert, falls x 1oder 4 ist wird ab case 2: case 1 ausgeführt, ist x 2 ab case 2 usw…(geht auch mit char) innerhalb der switch keine Variablen initialisieren (vorher!!!)
[COLOR="MediumTurquoise"]break;[/COLOR] [COLOR="Magenta"] (iostream.h)[/COLOR] Ausstieg aus einer switch-, for-, do-, oder while-Schleife
[COLOR="MediumTurquoise"]for (...){ ¿ if(x==2)continue cout << x;}[/COLOR] [COLOR="Magenta"] (iostream.h)[/COLOR] Beim continue wird was in der Schleife folgt nicht ausgeführt, und sofort zum for zurückgekehrt (kein Schleifenabbruch)



[COLOR="Red"][SIZE="4"]Funktionen und Pointer[/SIZE][/COLOR]

[COLOR="MediumTurquoise"]void funktion(int) [/COLOR] [COLOR="Magenta"] (iostream.h)[/COLOR] Funktion liefert keinen Wert zurück
[COLOR="MediumTurquoise"]void funktion(void)[/COLOR] [COLOR="Magenta"] (iostream.h)[/COLOR] Funktion wird ohne Wertangabe aufgerufen
[COLOR="MediumTurquoise"]return x [/COLOR] [COLOR="Magenta" ](iostream.h) [/COLOR]Funktion gibt den Wert x zurück
[COLOR="MediumTurquoise"]return [/COLOR] [COLOR="Magenta"](iostream.h) [/COLOR]Markiert das Ende der Funktion
[COLOR="MediumTurquoise"]void Linie(char x, int zahl=9) [/COLOR] [COLOR="Magenta"](iostream.h)[/COLOR] Falls Funktion ohne Zahl aufgerufen wird, wird diese 9
[COLOR="MediumTurquoise"]void...(...) ¿¿ void...(...){ [/COLOR] [COLOR="Magenta"](iostream.h) [/COLOR]Prototyp, jede Funktion muss einmal im Voraus definiert werden
[COLOR="MediumTurquoise"]static wert=999 [/COLOR] [COLOR="Magenta"](iostream.h)[/COLOR] Globale Variable (innerhalb Funktion) deklarieren. Innerhalb einer Klasse: nur eine Instanz für alle Klasseninstanzen (->Zählvariable)
[COLOR="MediumTurquoise"]cout << &zahl [/COLOR] [COLOR="Magenta"](iostream.h) [/COLOR]Adressoperator, gibt Adresse von Zahl raus statt deren Wert
[COLOR="MediumTurquoise"]sizeof(xxx) [/COLOR] [COLOR="Magenta"](iostream.h)[/COLOR] Gibt die Grösse von xxx an (kann eine Variable, Pointer,...sein)
[COLOR="MediumTurquoise"]char*Zeiger , double*Zeiger[/COLOR] [COLOR="Magenta"] (iostream.h)[/COLOR] Pointer, zeigt auf eine Variable, einen char,... . Nimmt 2 Bytes
[COLOR="MediumTurquoise"]cout << int (*text) [/COLOR] [COLOR="Magenta"](iostream.h) [/COLOR]Inhalts- oder Indirection-Operator: mit Hilfe des Pointers auf den Wert der Variable zugreifen, deren Adresse man hat.
[COLOR="MediumTurquoise"]while(*text) ¿ {... text++) [/COLOR] [COLOR="Magenta"](iostream.h)[/COLOR] Solange du auf einen Buchstaben stössts, ...
[COLOR="MediumTurquoise"]hilf=werte->xk; [/COLOR] [COLOR="Magenta"](iostream.h) [/COLOR]Struktur-Operator, Übergabe von Pointern auf Strukturen
[COLOR="MediumTurquoise"]int xyz; ¿ int & neuer=xzy; [/COLOR] [COLOR="Magenta"](iostream.h) [/COLOR]Referenzvariable, neuer hat die selbe Speicheradresse wie xyz
[COLOR="MediumTurquoise"]void funktion () const [/COLOR] [COLOR="Magenta"](iostream.h) [/COLOR]Funktion ist read-only, kann keine Daten ändern und auch nichts aufrufen was dies könnte
[COLOR="MediumTurquoise"]void Kl::fk(){cout << this;} [/COLOR] [COLOR="Magenta"](iostream.h) [/COLOR]Pointer auf Klasseninstanz (gibt 0x85955ec8 oder sowas aus)


[COLOR="Red"][SIZE="4"]Klassen[/SIZE][/COLOR]

[COLOR="MediumTurquoise"]class xx{private:public:...}; [/COLOR] [COLOR="Magenta"](iostream.h)[/COLOR] Form einer Klasse
[COLOR="MediumTurquoise"]double funkt(void){return y;}[/COLOR] [COLOR="Magenta"] (iostream.h[/COLOR]) Schnittstellenfunktion, im Private-Bereich einer Klasse
[COLOR="MediumTurquoise"]void tem::sp(void) [/COLOR] [COLOR="Magenta"](iostream.h) [/COLOR](Ausserhalb der Klasse)Die Funktion sp gehört zur Klasse tem
[COLOR="MediumTurquoise"]temperatur temp1; [/COLOR] [COLOR="Magenta"](iostream.h)[/COLOR] (in main). Instanz, per temp1 kann man auf die Werte der Klasse temperatur zugreifen
[COLOR="MediumTurquoise"]private: ¿ static int wert; [/COLOR] [COLOR="Magenta"](iostream.h)[/COLOR] Es gibt nur eine Version von wert, egal wie viele Objekte erzeugt werden (alle Objekte können gemeinsam auf wert zugreifen)
[COLOR="MediumTurquoise"]public:¿tex(char*s)...¿~tex()[/COLOR] [COLOR="Magenta"]; (iostream.h)[/COLOR] Destruktor, hat selben Namen wie Klasse tex::~tex(){cout<<"tot";} Bei Destruktion einer Instanz von tex wird "tot" ausgegeben
[COLOR="MediumTurquoise"]int statisch::wert=0; [/COLOR] [COLOR="Magenta"](iostream.h)[/COLOR] (ausserhalb der Klasse:) statische Werte werden extra initialisiert
[COLOR="MediumTurquoise"]delete text; [/COLOR] [COLOR="Magenta"](iostream.h)[/COLOR] etwas löschen um diesen Speicherplatz wieder freizumachen
[COLOR="MediumTurquoise"]friend int freund(kla1,kla2) [/COLOR] [COLOR="Magenta"](iostream.h)[/COLOR] Deklaration der friend-Funktion freund, welche Zugrif auf private Daten der Klassen kla1 und kla2 hat(Deklar.in kla1 und kla2)
[COLOR="MediumTurquoise"]double freund(kla1 x,kla2 y)[/COLOR] [COLOR="Magenta"] (iostream.h)[/COLOR] (ausserhalb der Klassen:) Friend-Funktion freund. kla1 und kla2 sind die Namen der Klassen, k1 und k2 die private-Zahlen
[COLOR="MediumTurquoise"] {return x.k1+y.k2;}[/COLOR]
[COLOR="MediumTurquoise"]public: friend class zwei;Abl::Abl(int a, float b):Bas(a) [/COLOR] [COLOR="Magenta"](iostream.h)[/COLOR] Klasse deklariert Kla. zwei als freund(gibt ihr Zugrif auf private) Konstruktor der Basisklasse Bas benötigt einen Parameter; dies muss man beim Konstruktor der abgeleiteten Klasse angeben
.


[COLOR="Red"][SIZE="4"]Vererbung[/SIZE][/COLOR]

[COLOR="MediumTurquoise"]class schueler:public mensch[/COLOR] [COLOR="Magenta"](iostream.h)[/COLOR] schueler erbt alles von der Klasse mensch (Zugang auf alles)
[COLOR="MediumTurquoise"]class sch:public k1,k2,... [/COLOR] [COLOR="Magenta"](iostream.h) [/COLOR]sch erbt alles von k1, k2, ...
[COLOR="MediumTurquoise"]protected: ¿ float sachwert; [/COLOR] [COLOR="Magenta"](iostream.h)[/COLOR] auch abgeleitete Klassen können sachwert benutzen + verändern


[COLOR="Red"][SIZE="4"]Rechnen[/SIZE][/COLOR]

[COLOR="MediumTurquoise"]a*=-1, a/=2, a+=1, a-=1 [/COLOR] [COLOR="Magenta"](iostream.h)[/COLOR] Multipliziere a mit -1, dividiere a durch 2, addiere, …
[COLOR="MediumTurquoise"]a++, a-- [/COLOR] [COLOR="Magenta"](iostream.h)[/COLOR] Addiere 1 zu a, substrahiere 1 von a
[COLOR="MediumTurquoise"]b=a++, b=++a [/COLOR] [COLOR="Magenta"](iostream.h) [/COLOR]1) b wird a, und dann erhöht (a bleibt), 2) zuerst wird a erhöht
[COLOR="MediumTurquoise"]<, >, <=, >=, ==, != [/COLOR] [COLOR="Magenta"](iostream.h) [/COLOR]grösser/kleiner oder gleich, gleich, verschieden
[COLOR="MediumTurquoise"]c=a%b [/COLOR] [COLOR="Magenta"](iostream.h)[/COLOR] c erhält den Rest von a/b(kann nicht mit float benutzt werden)
[COLOR="MediumTurquoise"]sin, cos, tan, sqrt,... [/COLOR] [COLOR="Magenta"](math..h)[/COLOR] diverse mathematische Funktionen
[COLOR="MediumTurquoise"]exp (log (8.5) * 2) [/COLOR] [COLOR="Magenta"](math.h)[/COLOR] 8,5 hoch 2 rechnen (Exposant)
[COLOR="MediumTurquoise"]abs(-20), fabs(-20), labs(20) [/COLOR] [COLOR="Magenta"](math.h,stdlib.h)[/COLOR] Die Valeur Absolue, von int/float/long
[COLOR="MediumTurquoise"]ow (10,2) [/COLOR] [COLOR="Magenta"](math.h)[/COLOR] Errechne 10 hoch 2
[COLOR="MediumTurquoise"]0x1A9F / 015237[/COLOR] hexadezimale Zahl (beginnt mit 0x) /oktale (beginnt mit 0)




[COLOR="Red"][SIZE="4"]Zahlen.[/SIZE][/COLOR]

[COLOR="Red"] bool:t/f,
char:127,
int:32767,
long:2,14Mrd,
float:3.4e38,
double:1.7e308,
long double:3.4e4932[/COLOR]
[COLOR="MediumTurquoise"]Diese Werte sind signed und gehen vom Minus-in den Plusbereich. Unsigned... sind nur positiv und gehen daher doppelt so weit ins +[/COLOR]

[COLOR="MediumTurquoise"]cout.precision(x); [/COLOR] [COLOR="Magenta"](iostream.h)[/COLOR] Angabe der Präzision wie eine Zahl ausgegeben wird (Stellen vor dem Komma zählen auch)
[COLOR="MediumTurquoise"]cout.precision(int(log10(Zahl)+1)); [/COLOR] [COLOR="Magenta"][/COLOR](math.h) Bewirkt dass keine Nachkommastellen angezeigt werden (“Zahl” ist die Zahl die abgeschnitten angezeigt werden soll)
[COLOR="MediumTurquoise"]const long PI=3.1 (float,...) [/COLOR] [COLOR="Magenta"](iostream.h)[/COLOR] Festlegen von Konstanten
[COLOR="MediumTurquoise"]2.7F [/COLOR] [COLOR="Magenta"](iostream.h)[/COLOR] 2.7 wird als float deklariert (statt standardmässig double)
[COLOR="MediumTurquoise"]Zahl=atof/atoi/atol (wort) [/COLOR] [COLOR="Magenta"](stdlib, stdio, math)[/COLOR] Zahl erhält den Zahlenwert den (falls) das Wort enthält, als float, int, resp. long, Enthält Wort Buchstaben wird abgebrochen




[COLOR="Red"][SIZE="4"]Präprozessor-Direktiven[/SIZE][/COLOR]

[COLOR="MediumTurquoise"]#include”my_h.h”[/COLOR] Datei wird zuerst im aktuellen Verzeichnis gesucht (und nicht im vordefinierten wie bei < >)
[COLOR="MediumTurquoise"]#define WERT 12 [/COLOR] Festlegen von unveränderbaren Variablen oder const Wert=12
[COLOR="MediumTurquoise"]#if A==1 ... #elif ... #elif ... #else ... #endif [/COLOR] Ifs (die Präprozessor-Direktiven stehen vor main und haben kein ;)
[COLOR="MediumTurquoise"]#ifdef XXX ¿ #... [/COLOR] Untersucht ob XXX existiert (nicht welchen Wert er hat!)


[COLOR="Red"][SIZE="4"]Divers[/SIZE][/COLOR]

[COLOR="MediumTurquoise"]randomize ();[/COLOR] [COLOR="Magenta"] (stdlib, stdio, time)[/COLOR] aktiviert den Zufallsgenerator
[COLOR="MediumTurquoise"]srand(getpid());[/COLOR] [COLOR="Magenta"] (stdlib, process) [/COLOR]aktiviert einen besseren Zufallsgenerator
[COLOR="MediumTurquoise"]time_t t; [/COLOR] [COLOR="Magenta"](time.h, stdlib.h,process.h)[/COLOR] Zufallsgenerator wird mit neuen zufälligen Zahlen initialisiert
[COLOR="MediumTurquoise"]srand((unsigned)time(&t)); [/COLOR] sehr nützlich!)
[COLOR="MediumTurquoise"]b=rand()%100; [/COLOR] [COLOR="Magenta"] (stdlib, stdio, time)[/COLOR] b erhält einen Wert zwischen 0 inclus und 100 exclus (int)
[COLOR="MediumTurquoise"]while (time(NULL)<jetzt+10);[/COLOR] [COLOR="Magenta"] (time.h, dos.h) [/COLOR]Eine Pause von 10 Sekunden (10 Sek. Schleife die nichts tut)
[COLOR="MediumTurquoise"]delay (25); [/COLOR] [COLOR="Magenta"](time.h)[/COLOR] Eine Pause von 25 ms.
[COLOR="MediumTurquoise"]Void ton (f,z){ [/COLOR] [COLOR="Magenta"](time.h, dos.h) [/COLOR]Mit dem Aufruf ton(100,1000) erzeugt man einen Ton von
[COLOR="MediumTurquoise"]sound(f);delay(z);nosound();} [/COLOR]Frequenz 100 Hz und Dauer 1000 ms.(f=frequenz, z=zeit)
[COLOR="MediumTurquoise"]system(”picem /v:l xyz.pcx”); [/COLOR] [COLOR="Magenta"](stdlib.h, stdio.h)[/COLOR] Ein anderes Programm aufrufen, nachher wird zum C++ Programm zurückgekehrt