arminobrateohh

Folie1:
-algorithmus: endlich viele schritte zum lösen eines problems
Integrated Development Environment (IDE) z.b Visual studio

folie2:
-Kommentare: // o. /* bis */
-cout = std ausgabe << stream operator
-rückgabewert von Main ist int
-int begrenzter wertebereich
-add:+ / sub:- / multi: * / division:/ / rest:%
-variable: speichert wert / hat typ / hat namen / belegt speicher
-schreibweise: int var = 0 /int var{0} / int var(0)
-namen müssen mit buchstabe oder _ beginnen dannach egal
-namen müssen != c++ befehlen sein

folie3:
-cin >> fließt in var
-wertzuweisung per =
-double kann zu ungenauigkeiten führen
-char in 'x'

folie4:
-inkrementieren = += / dekrementieren = -=
-präfix ++ vor var erhöht // postfix ++ nach var erhöht nach aufrufen
-aufbau: editor > compiler > linker > lader > debugger
-compiler übersetzt c++ befehle in einfache prozessorbefehle
-syntax definiert sprachelemte wie die verwendet dürfen
-libaries haben funcs die im prog verwendet werden können
-lader läd das programm in den arbeitspeicher und startet
-debugger = werkzeug zum auffinden von fehlern
-semantikfehler = logische fehler die erst beim ausführen sichtbar sind

folie5:
-bool = true/false
-operatoren: == gleich // < kleiner // > größer // != ungleich // <= kleinergleich
-boolsche op: && = und // || = oder // ! = nicht
-in c++ 0 = false und alles über 0 = true
-if/else klar
-geschweifte klammern sonst nur eine ausführung
-else if
-switch case
 -- switch(variable)
 {
   case x:
   anweisung
   break; // läuft sonst weiter
   default: //falls keins zutrifft
   }
-string = zeichenketten

folie6:
-"" keine echten string abhilfe mit string("")
-.lenght() o .size() für länge von string
-.at() um stelle anzusprechen
-string mit getline(cin, var)
-unsigned int umfasst positive werte
-while(bedingung) {anweisung}
-for(initialisierung; bedingung; aktion) {anweisung}
-was mit for kann, kann auch mit while

folie7: 29.10
-break verlässt schleife
-continue geht zum ende und führt die schleife von anfang weiter
-array: komb. vieler daten gleichen typs in einer Datenstruktur zählung ab 0
--def: int name[g. des arrays] = {werte,}; // kann nur const werte nehmen
-nach definition nurnoch einzelne wertzuweisung möglich
-c++ prüft nicht ob einträge im gültigen wertebereich liegen
-arrays können mehrdimensional definiert werden z.b int x[2][2];

folie8:
-variablen nur im definierten rumpf sichtbar
-variablen leben auf einem stapel(Stack)
-Wenn das programm einen neuen anweisungsblock betritt wird ein neuer Frame auf den
Stack plaziert(Anhang1) // wenn der block verlassen wird, wird auch der Frame
abgebaut
-Beim betreten eines blocks sind im Stack alle variablen bekannt aber die
werte erst bei zuweisung
-bei verschachtelten blöcken überdeckt die innere var immer die äüßere aber hat keinen
zusammenhang also können beide z.b int a = 0; lauten
-verlässt man den inneren block so hört die variable auf zu existieren
-während der Lebensdauer ist eine var. gültig (innerhalb des blocks)
-eine var. ist sichtbar solange die nicht von einer weiter innen ligenden
gleichnamigen variable überdeckt wird
-ausserhalb jeden blocks definierte variablen sind Globale var.
-Globale variablen sind fehleranfällig da sie von vielen stellen des codes verändert
werden können //globale const sind hingegen sinnvoll
-globale variablen werden gesondert ausserhalb des Stacks gespeichert
-wenn man eine var sucht wird vom obersten stack runtergesucht falls da diese var
nicht ist sucht c++ im globalen var. bereich
-mit dem start eines anweisungsblocks wird der stack angelegt mit allen vars ggf.
ohne werte die kommen erst bei der wertzuweisung mit rein
-am ende von einem anweisungsblock wird der frame vom stack gelöscht
-funktionen verwenden parameterwerte und geben wert zurück(nicht immer)

Folie9: 08.11
-main vs funcs.: main wird aus dem betriebssystem(konsole) aufgerufen funcs
aber vom c++ code
-main hat festen rückgabewert-datentyp int //bei main kann man return weglassen
-funcaufbau: Rückgabetyp name (paramater) {anweisung/en}
-Falls func nichts returnen soll Void //soll die vorzeitig beendet werden return
-kann keine / eine /mehrere parameter enthalten man muss datentyp und name eintragen
-Formalparameter bei definition // aktualparameter beim aufrufen
-beim compilen muss der compiler die defintion der func schon bearbeitet haben bevor
der aufruf übersetzt wird
-funktionsprototypen geben dem compiler die nötigen infos zur prüfung : ruückgabetyp : funktionsname : anzahl und typen
der parameter so wirds möglich dass die defintion nach dem aufruf kommt
-def: rückgabetyp funktionsname (parametertypen); die namen der parametertypen können weggelassen oder geändert werden
-diese infos nennt man schnittstelle der c++ func ein funcprototyp spezifiziert also die schnittstelle der func
-variablen die in der funktion definiert werden gelten nur in der func
-lokale variablen im rumpf wo die func aufgerufen wird sind in der func nicht gültig
-beim aufruf einer func werden die werte an die parameter übergeben //bekommen also nur eine kopie des werts
-funktionen können auf die werte der globalen variablen zugreifen und diese verändert wenn diese vor der func def. wurden sind
-wird ein glob. var. durch eine lokale var. überdeckt kann man diese via :: trz. aufrufen z.b ::summe
-ändernde auswirkungen von func. auf globale variablen sind der func schnittstelle nicht anzusehen sogenannte seiteneffekte
hohes fehler potential am besten keine glob. variablen usen aber globale konstante sind gut.
-bei der def. einer func können wertvorbelegungen für parameter angegeben werden z.b a(int a, int x = 20)
bei den aktualparametern kann dann die vorbelegte var weggelassen werden
parameter mit defaultwert müssen am ende stehen und dürfen nicht gemischt werden
-gibt es zu einer func eine schnittstellenbeschreibung also 1 prototyp so werden defaultparameter nur dort defininiert

folie10: 12.11
-func verwendete var können nicht verändert werden ausser es wird als referenzparameter angegeben also mit einem
& vor der var z.b void change(int &i)
-ein referenzparameter ist ein alias einer variable also zweiter name also speichert keinen eigenen wert sonder direkt
in die mitgegebene var.
-änderungen des referenzparameters innerhalb der func ändert die variable selber auch
-anhang2: voller stack mit reservierung für funcs und main
-vorteil: normalerweise kann eine func nur einen wert zurückgeben doch mit referenzparametern mehrere
wertparameter vs referenzparameter: wertparameter: kein & bei definition // call by value der wert wird also nur kopiert
									referenzparameter: & bei definition // call by reference referenz der ori. variable
-arrays als funktionsparameter immer wie referenzparameter
-bei der defintion wird die größe nicht mitgegeben aber man kann eine zusatzvariable mit der größe dazu geben z.b void f (int my_array[], int size)
-beim aufruf einer func mit arrayparametern wird nur der array name angegeben ohne eckige klammern
-möchte man die änderung am array verhinder so muss man diesen also const in der func definieren
-in c++ sind funcs mit gleichen namen erlaubt aber unterschiedlichen parametern oder typen
-inline funktion gut für gesamtlaufzeit des programms dadurch wird die func beim compilen beim aufrufen reingepastet statt immer den sprung
zur func zu machen // werden definiert mittels inline
-moderne compiler brauchen kein inlining mehr da diese selber inlining betreiben wenn dies sinnvoll erscheint
-inlining macht das programm größer (d.h zur laufzeit wird mehr speicher benötigt) aber das programm läuft schneller

folie11:
-rekursion bezeichnet den aufruf einer funktion durch sich selbst
-wichtig bei rekursion ist dass die Problemzerlegung und selbstaufrufe irgendwann enden
-endrekursion bezeichnet den spezialfall bei der jeder nächste rekursive aufruf die letzte aktion des vorherigen rek. aufrufs ist
-endrekursionen lassen sich unmittelbar durch for bzw. while schleifen ersetzen
-modularisierung von software gründe: der hersteller bietet seine software dritten an möchte aber keine blicke in die interne realisierung gewähren
-der compiler möchte nicht die ganze def. (rumpf) einer func. analysieren nur um einen funcaufruf zu übersetzen führt zu effizienzgewinn
-es soll nicht notwenig sein ein ganzes softwaresystem neu zu compilieren nur weil es eine kleine änderung gab
-c++ programme können über mehrere Quelltextdateien verteilt sein
-mit header dateien weil includen von cpp kopiert es nur rein und verteile entwicklung wird unterstützt z.b in teams
-header per #include
-includeverzeichnisse bezeichnet man die verzeichnisse wo der compiler nach headerdateien sucht dabei stoppt der compiler beim ersten treffer
der dateiname ist das einzige kriterium
-eine initiale liste von includeverzeichnissen ist von c++ gegeben man kann diese aber ändern und ggf. weitere hinzufügen
-#include <xx> sucht nur in den c++ verzeichnissen nach der headerdatei gedacht für standart bibliotheken
-#inlcude "xx" sucht zuerst im aktuellen verzeichnis nach dem header dannach sucht c++ in den anderen bisher benutzen headerverzeichnissen
und zum schluss in den c++ std. bib verzeichnissen
-optional können relative oder absolute dateipfade innerhalb "" angegeben werden dann wird aber nurnoch dort gesucht nachteil auf fremden rechnern
-headerdatei enthalten Schnittstellenbeschreibungen also z.b Prototypen von funcs. mehr kommt später in gip
-cpp dateien nennt man implementierungsdateien sie enthalten realisierungen vieler code erzeugender c++ konstrukte  wie funcs.
-die one defintion rule besagt dass jede sichtbare func. var. etc. genau eine definition im gesamten c++ programm haben muss
-defaultparameter werden nur im prototyp angegeben also ein weiterer grund die headerdatei zu includieren
-inline funktionen werden komplett in einer headerdatei programmiert
-globale variablen müssen in einer cpp definiert werden

folie12:
-präprozessor bindet die headerdatein in die cpp dateien ein
-befehle an den präprozessor nennt man präprozessor direktiven beginnen mit einem # z.b #include ist also keine c++ anweisung deshalb auch kein ;
-durch #pragma once am anfang der headerdatei stellt der präprozessor sicher dass die headerdatei nicht mehrfach eingefügt werden
-mit der modularisierung kann es passieren dass in vers. cpp dateien gleichnamige funktionen definiert werden dann namespace
-bestimmte bereiche können dann mittels namspace name {] in einen namespace gesetzt werden
-die klammerung vom namespace wird in der cpp und in der header datei gesetzt
-anstatt der klammerung kann in einer cpp auch :: benutzt werden
-4 geltungsbereiche in c++: 1. lokaler geltungsbereich im block definiert // 2.klassen geltungsbereich // 3.namespace geltungsbereich
4.datei geltungsbereich der nicht in einen der 3 vorherhigen definiert wurde gilt überall und kann durch extern überall geused werden

folie13:
-streams sind datenströme im system bis jetzt << >> von cout
-falsche eingaben bei cin verbleiben in der eingabe diese muss man clearen mit: cin.clear() löscht das Error-flag
cin.ignore(länge der zeichen, \n) \n bis zur newline
-ebenso notwendig beim wechsel von der eingabe in einen elementaren Datentyp einfach nach eingabe cin.ignore()
-formatierung der std ausgabe mittels #include <iomanip> cout << setfill('0') mittels setw(x) länge dann wird die länge gefüllt z.b 001
-für dateioperation #include <fstream> abfolge des zugriffs 1.anlegen eines fstreams zu einer datei // 2.öffnen der datei
3.lese u schreibeoperationen // 4.schließen der datei.
-anlegen eines fstreams mittels variable z.b fstream datei dabei werden dateiname sowie der zugriffsmodus als Parameter übergeben z.b
fstream datei1("file.txt", ios::out); // ios::in zum lesen ios::out zum schreiben  oder beides dann mit | trennen
weitere befehle ios::trunc leert die datei beim öffnen ios::app hängt die neuen geschriebenen sachen ans ende der datei
-dateien können mittels absoluter oder relativer dateipfade angegeben werden ohne pfad wird die datei im arbeitsverzeichnis angelegt
-öffnen der datei mittel open() z.b datei1.open("text1.txt", ios::out); werden der datei beim fstream schon die parameter gegeben so ist open unnötig
-schließen durch .close()
-dateien die nur zum lesen sind ifstream
-dateien die nur zum schreiben sind ofstream
-schreiben funktioniert wie bei cin mittels streamoperator z.b datei1 << "hallo";
-lesen mittels >>
-liest bis zum zeilenende bzw. bis zum eof endoffile deshalb per while(datei1 >> x)
-ende prüfen durch datei1.eof() z.b in if
-fehler beim öffnen prüfen durch if(!datei1) oder durch fail() oder good()
-binärdateien öffnen durch ios::binary
-ein strukturierter Datentyp fasst mehrere elemente ggfs. versch. datentypen zu einem strukturierteren Datentyp zusammen
mittels struct name {]komponent; falls nötig
komponent.inhalt()
-sollten in headerdatei stehen

folie14:
-aufzählungsdatentypen werden verwendet für daten wertebereich aus konstanten werten besteht z.b rot/blau/gelb o. montag/dienstag/usw.
-in c++ mittels enum name {rot,blau,gelb};
-c++ verwendet intern int für diese aufzählungen
-man kann die internen int werte auch selber definieren enum wochentag {sonntag = 0; montag = 1 usw.};
-datentyp definitionen sollten in headerdatei definiert werden
-referenzen sind ein allgemeines konstrukt welches überall wo variablen sind verwendet werden kann
-referenzen können nicht verändert werden sobald diese auf eine variable zeigen
-referenzen garantieren dass mit dem original wert gearbeitet wird
-Computer speichern ihre daten im RAM
-jeder speicherzelle hat eine eindeutige adresse
-der & operator liefert die adresse in der eine variable gespeichert ist
-bei variablen die in mehreren speicherzellen gespeichert ist liefert & die erste zurück
-ein pointer ist eine variable deren wert eine speicheradresse im hauptspeicher ist
-pointer dienen dazu auf einen anderen variableninhalt bzw. speicherinhalt zu verweisen
-der datentyp der pointervariable beschreibt welchen datentyp der wert an der aufgezeigten speicheradresse hat
-definition durch datentyp *name; also int *ptr; dann nur definiert zuweisung durch z.b int *ptr = %x;
-der stern ist nur bei der defintion nötig dannach kann der pointer mit namen normal verwendet werden
-pointer lassen sich nicht auf ganze zahlen setzen also z.b = 1000
-pointer sind getypet also können nur auf werte mit dem selben datentyp zeigen
-deferenzieren einer pointervariable bezeichnet die operation bei der auf den datenwert auf welchen ein pointer zeigt zugegriffen wird
-bei benutzung des inderktionsoperator * kann man wertzuweisungen auf den "originalwert" durchführen
-nullpointer: bezeichnet einen speziellen pointerwert der noch keinen wert hat entweder per 0 oder per nullptr;
-pointer auf lokale variablen fehleranfällig weil wenn die variable weg ist dann zeigt der ptr immernoch auf den speicherort
-egal welcher datentyp pointer belegen immer gleich viel speicher
-referenzen können nicht umgeleitet werden verhalten sich also wie konstanten pointer hingegen können umgeleitet werden
-das pointer & steht für adresse von und referenz & für eine definition einer referenz

folie15: 29.11
-pointer sind verweise ohne eingebaute automatik wie referenzen
-dynamische datenstrukturen new teilt speicher zu aus einem speziellen bereich des hauptspeichers dem heap die zuteilung nennt man allokation von heap speicher
-der new befehl liefert die adresse des neu allozierten speicherbereichs zurück z.b int *ptr = new int;
-wird mit new speicherplatz angefordert so kann man auch direkt den datenwert angeben z.b int *ptr = new int{0};
-über den befehl delete kann zur laufzeit des programms speicherplatz der mit new gefordert wurde wieder freigegeben werden
-delete ändert nichts an dem wert der dem pointer zugewiesen wurde aber pointer die drauf zeigten sind dann dangling pointer diese sollte man
mit nullptr auf nichts mehr zeigen lassen
-datenobjekte mittels new verbleiben auch nach ihrer gültigkeit in einem rumpf also am besten mit delete löschen
-werden mittels new allozierte speicherbereiche nicht mehr verwendet und nicht mit delete gelöscht so verbraucht das programm zu seiner laufzeit
mehr und mehr speicher das nennt man memory leak
-in dynamischen datenstrukturen nennt man die einzelnen einträge knoten
-verkettungen mittels pointern. letzter eintrag enthält den nullpointer um zu zeigen dass nichts mehr folgt
-um den xten eintrag zu lesen muss man durch die ganze liste gehen nicht möglich wie bei arrays eine bestimmte stellen sofort anzusprechen
-um den anfang einer liste zu lesen gibt es eine variable die einen pointer auf den ersten listeneintrag speichert solch einen verweis auf das
erste element nennt man anker zeigt der anker auf nullptr so ist die liste noch leer
-für die kombination pointer dereferenzieren und dann member einer struct auslesen gibt es den auswahloperator ->
-merken: arrays haben eine feste größe also muss man sich explizit merken welcher teil auch werte trägt

folie16:
-Speicher der mittels New freigegeben wurde wird nicht am ende eines rumpfs oder am ende einer funktion freigegeben bzw. gelöscht
-gucken in praktiukumsaufgabe mit pointern ggf. wiederholen vorl. 03.12

folie17: 10.12
-pointer können auch auf pointer zeigen durch **
-anker->next->next z.b
-bei mehrfacher indirektion über struct daten bezeichnet der letzte eintrag in der "-> kette" die komponente struct alles davor nur den weg dahin
-array können auch mit new[] erstellt und delete[] gelöscht werden
-auto für automatische typermittlung in GIP nicht erlaubt
-wird eine var. als static innerhalb einer func oder block definiert so behält diese zwischen den aufrufen ihren aktuellen wert
-main darf nicht von anderen funktionen aufgerufen werden
-compiler unterstützen main in 2 varianten : int main() bzw. int main(int argc,  char *argv[])
-der int parameter argc mit wievielen parametern das Programm aus der IDE aufgerufen wurde der programmname zählt mit
-der parameter argv ist ein array von pointern auf char verweist auf ein cstring in welchem die mitgegebenen Programmparameter festgehalten sind
-typedef erlaubt es einen neuen namen für einen datentyp zu definieren
-der ? operator für abfrage also: bedingung ? wahrausdruck : falschausdruck z.b a<b ? a : b;
-goto anweisung: label wird erstellt  name: und dann mit goto name; direkter sprung
-das konzept von goto wiederspricht den regeln der strukturierteren programmierung da der kontrollfluss unübersichtlich wird
-unsigned int umfasst die positiven ganzzahligen werte inklusive der 0
-short int umfasst pos. und neg. ganzahlige werte aber mit kleinerem bereich als int
-long int umfasst pos. und neg. ganzzahlige werte aber mit einem größeren wertebereich als int
-float umfasst fließkommazahlen aber mit geringerer genauigkeit als double
-assertions auf deutsch = zusicherung // mittels assert() kann man prüfen ob die in klammern gegebene bedingung erfüllt ist wenn ja
läuft das programm weiter falls nein bricht es mit einem error ab // benötigt <cassert> includiert
-sind nur sinnvoll während der programmierung
-unit test cases sind fälle die die funktion genau so wiedergeben muss

folie18: //noch nicht fertig geht weiter....