Sie sind auf Seite 1von 6

Variablentypen

int = ganze Zahlen double / float = Kommazahlen bool = true / false


string = Text char = Einzelzeichen void = Keine Rückgabe
const int = Globale Variable int

Operatoren
+,-,*,/,% ==, !=, <=, >=, <, > && , ||, !

Verzweigungen
Switch switch (betrachteter typ) { switch (v.Status) {
case wert1: Aktion 1; break; case offen: cout << „offen“; break;
case wert2: Aktion 2; break; case geschlossen: cout << „geschlossen; break;
default: Aktiondefault; break; } default: cout << „Unbekannt“; break;

if-Verzweigung if(Bedingung){Aktion} if(Filmliste[1].Laenge >120) {cout << „Lang“;}


else {Aktion} else {cout << „Normale Länge“;}
Eingabeabfrage if (input == "q")

Felder
Deklaration Feldtyp Feldname[Laenge] int Handynummern[100];
Film Filmliste[20];
Zugriff Feldname[Wert] Filmliste [12]
ganzes Feld Feldname Filmliste
oder *(Feldname+Wert) *(Filmliste + 12)
Deklaration Feldname[Wert] = Inhalt Filmliste[10].Regisseur = „Quentin Tarantino“;
oder feldname[länge] = Filmliste[10] = {{BangBoomBang, 144}, {Pulp Fiction
{ {att 1, att 2},{att 1, att 2}, {obj3}} , 201}, {….. , …..}}

Pointer
Pointer erstellen: pointertyp* pointername; Kunde* kp;
Pointer zeigen: pointername = &Variablenname kp = &Hans; (Adresse)
pointername = *Vvariablenname kp = *Hans; (Name)
Über Pointer pointername->wertename = wert kp->Alter = 13;
Werte definieren:

Enum
Datentyp erstellen enum Enumname{wert1, wert2}; enum Status {offen, geschlossen};

Strukturen
Deklaration struct Structname{ struct Film{
typ1 Name1; string Regisseur;
typ2 Name2; int Laenge;
typ3 Name3; }; Genre Genre; }; (Genre Enum)
Erstellen Variable Structname Variablenname; Film PulpFiction;
Werte zuweisen Variablenname.typ = Wert; PulpFiction.Laenge = 124;

Funktionen
Deklaration F-Typ Funktionname(abh.1, abh.2); double minPreis(Film f[], int n);
Definition F-Typ Funktionname(abh.1, abh.2){Aktion} double minPreis(Film f[],int n){cout << „Bsp“;}
Ausführen Funktionsname(var. 1, var. 2); minPreis(Filmliste[5], 5);
OOP

Klassen
Erstellen class KlassenName{public:KlassenName();~KlassenName();private:};
Standard Konstruktor KlassenName::KlassenName(){}
Standard Destruktor KlassenName::~KlassenName(){}
Erweiterter Konstruktor KlassenName::Klassenname(int j, string m, double sum){}

Methoden
getMethoden double getpreis();
double KlassenName::getpreis() {return this->preis;}
setMethoden void setPreis(double p);
void Produkt::setPreis(double p){this->preis = p;}

Instanz anlegen KlassenName Instanzname(2019, „November“, 6518.50);


m. Standartkonstruktor KlassenName Instanzname;
Methode durchführen Instanzname.hinzufuegen(waggon1);

String #include <string>


Standartkonstruktor string s1;
s2 als Kopie v. S1 string s2(s1); string s2 = s1;
String mit Zeichenkette string s3("Text"); string s3 = "Text";
String mit fünf Sternen string s4(5, '*');
Ein- / Ausgabe cin >> s1; cout << s2;
Speichert kompleette Textzeile in s3 ein: getline(cin, s3);
Inhalt von s2 an s1 anhängen s1 += s2;
Gibt das n-te Zeichen d. String als Referenz name[n];
Liefert länge des Strings name.size();
True wenn string leer, sonst false name.empty();

Vektoren #include <vector>


Standartkonstruktor Vec. V1 Typ T vector<T> v1;
Erzeugt V2 als Kopie von V1 vector<T> v2(v1); vector<T> v2 = v1;
Erzeugt V3 mit n(3) Elementen vector<T> v3(3);
Erzeugt V3 mit n(3) Elementen mit Wert mno vector<T> v4(3, mno);
Rückgabe n-tes Element (Beginn 0) v1[n];
Hängt Element mno am Ende an. v1.push_back(mno);
Ändert Gr. auf n(2). Elmte:gelöscht/angehängt v1.resize(n);
Liefert Größe d. Vektors v1.size();

Fstream #include <fstream>


Standartkonstruktor fstream myDatei;
Öffnen zum lesen myDatei.open(DateiNameVar, ios::in);
(vorher: in main:) string DateiNameVar("daten.dat");
Datei wird geschlossen myDatei.close();
Prüfung, ob datei korrekt geöffnet wurde myDatei.is_open();
Prüfung ob End of File erreicht ist myDatei.eof();
Öffnen zum schreiben: (überschreiben) myDatei.open(DateiNameVar, ios::out);
(Ausgabe an geöffnete Datei anhängen) myDatei.open(DateiNameVar, ios::app);
Dateiinformationen einer Variable zuweisen myDatei >> eingelesenebetraege;
Information in die Datei schreiben myDatei << betraege;
Liest ganze Zeile und speichert in String string getline(myFile, filmName);
Dynamische Objekte
Erstellen Film *f = new Film(filmName, preis, dauer);

Vererbung
Header (Klasse) class OnlineSpiel : public Spiel
CPP (Deklaration) OnlineSpiel::OnlineSpiel(int s, string n, double p) : Spiel(s, n)
Methode „Ausgabe“ der Untersten Klasse virtual void ausgabe();

Überladen von Funktionen


Header (Klasse) friend ostream& operator <<(ostream& out, OnlineSpiel& o);
void operator ++ ();

→ Durch friend wird der Zugriff


auf private Attribute gewährleistet

CPP (Deklaration) ostream & operator<<(ostream & out, OnlineSpiel & o)


{out << "Spieler: " << o.spieler << endl;
out << "Name: " << o.name << endl; return out;}
void Bruch::operator ++ (){zaehler = zaehler + nenner;}

#include <map>
map<string, double> preise;
preise.insert(make_pair("ELEMENT" , 54.99));
cout << "Preis von 'GIRL' Boards wird generiert: " << endl;
cout << preise["GIRL"] << endl;
preise.find("GIRL");

#include <Windows.h>
Beep(f,t); Beep(4000, 100);
Sleep(t); Sleep(100);

#include <thread>
cout << endl << "ERSTENS" << endl;
thread t1(funktion1);
t1.join();
Sleep(2000);

cout << endl << "ZWEITENS" << endl;


thread t2(funktion2);
t2.join();
Sleep(2000);

#include <chrono>
void Videothek::Lesen(string Dateiname)
{
string invnr;
bool stat;
int ersch;
fstream myDatei;
myDatei.open("schallplatten.txt", ios::in);
if (myDatei.is_open())
{
while (! myDatei.eof())
{
myDatei >> invnr >> stat >> ersch;
Schallplatte s(invnr, stat, ersch);
PlattenKiste.push_back(s);
}
}
else
{
cout << "Fehler beim lesen der Datei. " << endl;
}
}

void Abrechnung::calculateSumme()
{
double sum = 0;
for (int i = 0; i < this->Produkte.size(); i++)
{
sum = sum + this->Produkte[i].getPreis();
}
this->summe = sum;
}

Bruch Bruch::addiere(Bruch b2)


{
Bruch bReturn;
bReturn.nenner = b2.nenner * this->nenner;
bReturn.zaehler = b2.zaehler * this->nenner + this->zaehler * b2.nenner;
bReturn.kuerzen();
return bReturn;