c++ auf ubuntu über g++
also mit gcc war bei mir garnix anzurichten, g++ musst i schon explizit installieren, damit das ''Hello Titti '' wenigstens mal ging :( naja, soweit so gut, dann können wir uns ja mal der syntax widmen... cheat sheet totorial links für alle fälle tutorial schornboeck {BOX(title=>Inhaltsverzeichnis, bg=>greu, align=>left)}{BOX}
Datentypen
*ganzzahlig * ''char'' / unsigned char (8bit) * ''short'' / unsigned short (16bit) * ''int'' / unsigned int (16bit, 32bit) * ''long'' / unsigned long (32bit)
*Fließkommazahlen * ''float'' (32bit/ 1 VZ, 7exponent, 24mantisse) * ''double'' (64bit/ 1vz, 10exponent, 53mantisse) * ''long double'' (80bit)
Konstanten
*Gleitkomma-konstanten : ''double'' * ''doublef'' -> Gleitkomma-konstante vom Typ float * ''doublel ''-> Gleitkomma-konstante vom Typ long double
*Zeichenkonstanten: 'A' (in Hochkomma) * => '1' {FORMULA()} \hat={FORMULA} 49 (ASCII-zeichen)
- stringkonstante:
cout << "abc"; // liefert : abc (stringkonstanten belegen im Speicher automatisch ein Byte mehr um deren Ende zu markieren. => im Speicher steht: |a|b|c|\0|) - Strinverkettungz.B.: cout<< "abc\ def"; // liefert: abcdef
cout<< "abc" "def"; //liefert: abc def
# escape-sequenzen \ => escape-sequenzen: um ein nichtdruckbares Zeichen ausgeben zu lassen bzw. als selbiges zu verwenden, ist maskierung mit __\ __nötig => schreibe: '\"' für " (escape-sequenz \" mit Hochkommata als Zeichenkonstante erkenntlich gemacht => '\"' als eingabe bzw. \0, \a...)
*Zahlenbasis * cout << '\===053===' // "+"-Zeichen oktadezimal (stets ===dreistellig===!) * cout << '\x2B' // "+"-Zeichen hexadezimal
*nichtdruckbare Zeichen
* \, ', ", ?
* NUL (Nullzeichen) \0
* BEL (Signalton) \a
* BS (Rückschritt) \b
* HT (Horizontaler Tabulator) \t
* Zeilenvorschub \n
* vertikaler Tabulator \v
* Seitenvorschub \f
* Wagenrücklauf (=Zeilenanfang) \r
^ ::beispiel::
#include <
int main(void) { cout << 'C'; cout << '+'; cout << '-'; cout << '\a'; //signalton cout << '\b'; //cursor eine position zurück cout << '\a'; //signalton cout << '+'; // '-' durch '+' ersetzten }^
bekannte Konstanten
''const'' (schlüsselwort) => quantifier
Aufzählungstypen
symbolische Konstanten (c++ präprozessor)
Variablen
Definition: ''int a;'' //Datentyp Variablenname; Initialisierung: ''int a=1;'' // Datentyp Variablenname=Wert; *Zuweisung: ''a=5;'' //Variablenname=Wert; (nach Definition möglich)
*Adressoperator & : Anfangsadresse der Variable (im Speicher) kann mit ''&a '' verwendet werden cout << &a; // Adresse von a ausgeben; liefert z.B.: 0xC96
type quantifier
const (macht aus Def. einer Variablen eine bekannte und feste Konstante) const int a; // => a vom Typ ''const int'' volatile (macht aus Def. einer Variablen eine von außerhalb des Programmes - anderes Programm/Hardware - veränderliche variable; unterbindet optimierungsoperationen des compilers z.B. Verwenden einer kopie des variablenwertes anstatt den wert bei jedem aufruf aus dem speicher ins prozessorregister zu laden)
Daten Ein-/Ausgabe <=> in-output stream
datenstromausgabe ===cout===
#include <
Manipulatoren
cout<< ===hex===<< 123; // liefert: 7b (oct, dec, hex ohne parameter) cout << ===setprecision(int stellenzahl) === << * die Formate ===fixed=== und ===scientific=== nehmen immer die gesetzte Stellenzahl als Nachkommazahl * Manipulation kann nur duch weitere Manipulation wieder zurückgesetzt bzw. geändert werden ===setw(int mindestbreite)=== Feldbreite ===setfill(int zeichen)=== Füllzeichen *cout << hex << ===setionsflags=== (128L) <<123; //liefert: 0x7b (mit basisangabe, beeinflusst keine Fließkommazahlen, parameter vom typ ===L===ong) * ===resetionsflags(long flag)=== IO-flags zurücksetzen
datenstomeingabe ===cin===
- cin >> c; //liest zeichen ein und speichert es in c (nach def. von c)
- c = cin.get(); //liest zeichen ein und speichert es in c (nach def. von c) (unformatierte Eingabe)
- cin.get(c); //liest zeichen ein und speichert es in c (nach def. von c) (unformatierte Eingabe)
konventionelle Ein-/Ausgabe ===scanf/printf===
*#include <
unformatierte E/A * putchar(c); //gibt den Wert von c aus *
formatierte E/A => Formatangaben printf("%X %d", &i, &i); //gibt adresse von i in hex und dez aus scanf("%d", &x); //liest zahl ein und speichert sie als wert vom typ int in x
operatoren
arithmetische Operatoren(+, -, , /, %) Vergleichsoperator Logischer_Operator Bitoperatoren => bits setzen und löschen * bitweises UND &, bitweises ODER__ | (|| exclusiv) * Schiebeoperatoren (<<, >>__) Zuweisungsoperatoren Inkrement/Dekrement Bedingungsoperator__?:__(a<0 ? a=-a : a=a ) sequenz-(),, sizeof-(sizeof),Adress- (&) operator Klammern
Kontrollstrukturen
Auswahlanweisungen * (if (a>b cout << "yes";), für if (0); =>bedingung nicht erfüllt) * switch(ausdruck) {case a:[anweisungen] case b:[anweisungen]..} // {FORMULA()} \hat={FORMULA} geschachtelte if-anweisung (break;) Wiederholungsanweisungen * while(ausdruck) anweisung; * for(init ; bedingung; reinit) anweisung; * do anweisung while(ausdruck); //Anweisung wird in jedem Fall mind. einmal ausgeführt *Sprunganweisungen (verlagern Ausführungskontrolle in einem Programm) * break unterbricht switch, while, for oder do-while- schleifen + lässt auf anweisung weiterspringen * continue * goto * return
C++ Präprozessor
erhällt Instruktionen in Form von Direktiven, die mit # beginnen
#include für Dateikopien
einkopieren der Inhalte anderer Dateien
#include
#define / #undef symb.Konstanten -> Makros
für symbolische Konstanten: #define name_der_konstanten "wofür die Konstante steht" * #define PI 3.1415 * #define MAIN void main() * #define MESSAGE "PI hat den Wert:"
Makros
sind ''define''- instruktrionen, die als ''name_der_konstanten'' Coder von Operationen oder Anweisungen enthalten. Sie bieten gegenüber Funktionen einen Geschwindigkeitsvorteil wie die ''inline''-Funktionen. * #define ZEILENVORSCHUB cout << "\n" * ##-operator -Verknüpfungsoperator für die Zurücksetzung der Definition bzw Löschung eiens Makros: #undef name_der_konstanten
#if, #elif, #else, #endif, #ifdef, #ifndef -> bedingte Kompilierung
-
if konstanter_Ausdruck Programmteil
-
if defined (name_der_konstanten) programmteil // = #ifdef name_der_konstanten programmteil
#error -> Ausgabe von Fehlermeldung
#error message
#line
Zeile-Nr. XX mit Wert belegen
#pragma
Präprozessorkonstanten
- LINE
- FILE
- DATE
- TIME
- cplusplus
abgeleitete Datentypen
=> können vom Programmierer hergestellt werden
pointer
Datenobjekt, das die Adresse eines anderen Datenobjekts speichert bzw. darstellt
Adressoperator & => &a // adresse von a
Zeigervariablen: Verweisoperator __ => datentyp_des_verweisobjekts name_pointer
* int pointer; //zeiger auf int-datenobjekte
* int pointer = &a; // zeiger auf int, initialisiert mit adresse von a
* __Zuweisungen/Vergleiche nur zwischen pointern gleichem typs => notfalls konverieren: long p2 ; p2 =(int)pointer;
* Dereferenzierte Zeiger nach ''short a=2; short p=&a;'' sind '' b=a; bzw ''b=p; '' identische Anweisungen
konst.Zeiger : int const p=&a; //p ist constanter zeiger (const int a; kann nur von const int p; angefahren werden)
p Zeiger , dessen wert die Adresse des verwiesenen objekts ist (=&a)
__p__ beinhaltet das Datenojekt selbst (=a)
&p adresse des Zeigers p
Nullzeiger : zum scheitern von operationen bzw. auftreten lassen eines Fehlers, da unter der adresse 0 nie daten gespeichert werden.
generischer Zeiger (=allgemeiner Z., falls datentyp unklar): ''void p; ''
* (double)p=1.2; //void kein zugriff auf double Werte, nur auf double adressen
* keine Zuweisung von void* an andere zeigertypen (int p2; p2=p; //Fehler! )
references
sind besondere pointer, die ein andereer Name für ein bestehendes Datenobjekt darstellen. beziehen sich unveränderlich auf das Datenobjekt, mit dem sie initialisiert wurden. * datentyp &ref_name = init_ausdruck;
arrays
funktionen
klassen
Bibliotheken
ziemlich umfangreiche Übersicht über verfügbare C++-Bibliotheken bibliotheken ||für DOS|Inhalte|für Linux|Inhalte|für beide|| | | | cin/cout| iostream.h||| | | scanf/printf| stdio.h||conio.h| Konsolenfunktionen z.B. clrscr(), getch(), kbhit(), gotoxy(), sleep(), ... |?| | ||