SHARE
TWEET

arminobrateohh

a guest Jan 22nd, 2020 142 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. Folie1:
  2. -algorithmus: endlich viele schritte zum lösen eines problems
  3. Integrated Development Environment (IDE) z.b Visual studio
  4.  
  5. folie2:
  6. -Kommentare: // o. /* bis */
  7. -cout = std ausgabe << stream operator
  8. -rückgabewert von Main ist int
  9. -int begrenzter wertebereich
  10. -add:+ / sub:- / multi: * / division:/ / rest:%
  11. -variable: speichert wert / hat typ / hat namen / belegt speicher
  12. -schreibweise: int var = 0 /int var{0} / int var(0)
  13. -namen müssen mit buchstabe oder _ beginnen dannach egal
  14. -namen müssen != c++ befehlen sein
  15.  
  16. folie3:
  17. -cin >> fließt in var
  18. -wertzuweisung per =
  19. -double kann zu ungenauigkeiten führen
  20. -char in 'x'
  21.  
  22. folie4:
  23. -inkrementieren = += / dekrementieren = -=
  24. -präfix ++ vor var erhöht // postfix ++ nach var erhöht nach aufrufen
  25. -aufbau: editor > compiler > linker > lader > debugger
  26. -compiler übersetzt c++ befehle in einfache prozessorbefehle
  27. -syntax definiert sprachelemte wie die verwendet dürfen
  28. -libaries haben funcs die im prog verwendet werden können
  29. -lader läd das programm in den arbeitspeicher und startet
  30. -debugger = werkzeug zum auffinden von fehlern
  31. -semantikfehler = logische fehler die erst beim ausführen sichtbar sind
  32.  
  33. folie5:
  34. -bool = true/false
  35. -operatoren: == gleich // < kleiner // > größer // != ungleich // <= kleinergleich
  36. -boolsche op: && = und // || = oder // ! = nicht
  37. -in c++ 0 = false und alles über 0 = true
  38. -if/else klar
  39. -geschweifte klammern sonst nur eine ausführung
  40. -else if
  41. -switch case
  42.  -- switch(variable)
  43.  {
  44.    case x:
  45.    anweisung
  46.    break; // läuft sonst weiter
  47.    default: //falls keins zutrifft
  48.    }
  49. -string = zeichenketten
  50.  
  51. folie6:
  52. -"" keine echten string abhilfe mit string("")
  53. -.lenght() o .size() für länge von string
  54. -.at() um stelle anzusprechen
  55. -string mit getline(cin, var)
  56. -unsigned int umfasst positive werte    
  57. -while(bedingung) {anweisung}
  58. -for(initialisierung; bedingung; aktion) {anweisung}
  59. -was mit for kann, kann auch mit while
  60.  
  61. folie7: 29.10
  62. -break verlässt schleife
  63. -continue geht zum ende und führt die schleife von anfang weiter
  64. -array: komb. vieler daten gleichen typs in einer Datenstruktur zählung ab 0
  65. --def: int name[g. des arrays] = {werte,}; // kann nur const werte nehmen
  66. -nach definition nurnoch einzelne wertzuweisung möglich
  67. -c++ prüft nicht ob einträge im gültigen wertebereich liegen
  68. -arrays können mehrdimensional definiert werden z.b int x[2][2];
  69.  
  70. folie8:
  71. -variablen nur im definierten rumpf sichtbar
  72. -variablen leben auf einem stapel(Stack)
  73. -Wenn das programm einen neuen anweisungsblock betritt wird ein neuer Frame auf den
  74. Stack plaziert(Anhang1) // wenn der block verlassen wird, wird auch der Frame
  75. abgebaut
  76. -Beim betreten eines blocks sind im Stack alle variablen bekannt aber die
  77. werte erst bei zuweisung
  78. -bei verschachtelten blöcken überdeckt die innere var immer die äüßere aber hat keinen
  79. zusammenhang also können beide z.b int a = 0; lauten
  80. -verlässt man den inneren block so hört die variable auf zu existieren
  81. -während der Lebensdauer ist eine var. gültig (innerhalb des blocks)
  82. -eine var. ist sichtbar solange die nicht von einer weiter innen ligenden
  83. gleichnamigen variable überdeckt wird
  84. -ausserhalb jeden blocks definierte variablen sind Globale var.
  85. -Globale variablen sind fehleranfällig da sie von vielen stellen des codes verändert
  86. werden können //globale const sind hingegen sinnvoll
  87. -globale variablen werden gesondert ausserhalb des Stacks gespeichert
  88. -wenn man eine var sucht wird vom obersten stack runtergesucht falls da diese var
  89. nicht ist sucht c++ im globalen var. bereich
  90. -mit dem start eines anweisungsblocks wird der stack angelegt mit allen vars ggf.
  91. ohne werte die kommen erst bei der wertzuweisung mit rein
  92. -am ende von einem anweisungsblock wird der frame vom stack gelöscht
  93. -funktionen verwenden parameterwerte und geben wert zurück(nicht immer)
  94.  
  95. Folie9: 08.11
  96. -main vs funcs.: main wird aus dem betriebssystem(konsole) aufgerufen funcs
  97. aber vom c++ code
  98. -main hat festen rückgabewert-datentyp int //bei main kann man return weglassen
  99. -funcaufbau: Rückgabetyp name (paramater) {anweisung/en}
  100. -Falls func nichts returnen soll Void //soll die vorzeitig beendet werden return
  101. -kann keine / eine /mehrere parameter enthalten man muss datentyp und name eintragen
  102. -Formalparameter bei definition // aktualparameter beim aufrufen
  103. -beim compilen muss der compiler die defintion der func schon bearbeitet haben bevor
  104. der aufruf übersetzt wird
  105. -funktionsprototypen geben dem compiler die nötigen infos zur prüfung : ruückgabetyp : funktionsname : anzahl und typen
  106. der parameter so wirds möglich dass die defintion nach dem aufruf kommt
  107. -def: rückgabetyp funktionsname (parametertypen); die namen der parametertypen können weggelassen oder geändert werden
  108. -diese infos nennt man schnittstelle der c++ func ein funcprototyp spezifiziert also die schnittstelle der func
  109. -variablen die in der funktion definiert werden gelten nur in der func
  110. -lokale variablen im rumpf wo die func aufgerufen wird sind in der func nicht gültig
  111. -beim aufruf einer func werden die werte an die parameter übergeben //bekommen also nur eine kopie des werts
  112. -funktionen können auf die werte der globalen variablen zugreifen und diese verändert wenn diese vor der func def. wurden sind
  113. -wird ein glob. var. durch eine lokale var. überdeckt kann man diese via :: trz. aufrufen z.b ::summe
  114. -ändernde auswirkungen von func. auf globale variablen sind der func schnittstelle nicht anzusehen sogenannte seiteneffekte
  115. hohes fehler potential am besten keine glob. variablen usen aber globale konstante sind gut.
  116. -bei der def. einer func können wertvorbelegungen für parameter angegeben werden z.b a(int a, int x = 20)
  117. bei den aktualparametern kann dann die vorbelegte var weggelassen werden
  118. parameter mit defaultwert müssen am ende stehen und dürfen nicht gemischt werden
  119. -gibt es zu einer func eine schnittstellenbeschreibung also 1 prototyp so werden defaultparameter nur dort defininiert
  120.  
  121. folie10: 12.11
  122. -func verwendete var können nicht verändert werden ausser es wird als referenzparameter angegeben also mit einem
  123. & vor der var z.b void change(int &i)
  124. -ein referenzparameter ist ein alias einer variable also zweiter name also speichert keinen eigenen wert sonder direkt
  125. in die mitgegebene var.
  126. -änderungen des referenzparameters innerhalb der func ändert die variable selber auch
  127. -anhang2: voller stack mit reservierung für funcs und main
  128. -vorteil: normalerweise kann eine func nur einen wert zurückgeben doch mit referenzparametern mehrere
  129. wertparameter vs referenzparameter: wertparameter: kein & bei definition // call by value der wert wird also nur kopiert
  130.                                     referenzparameter: & bei definition // call by reference referenz der ori. variable
  131. -arrays als funktionsparameter immer wie referenzparameter
  132. -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)
  133. -beim aufruf einer func mit arrayparametern wird nur der array name angegeben ohne eckige klammern
  134. -möchte man die änderung am array verhinder so muss man diesen also const in der func definieren
  135. -in c++ sind funcs mit gleichen namen erlaubt aber unterschiedlichen parametern oder typen
  136. -inline funktion gut für gesamtlaufzeit des programms dadurch wird die func beim compilen beim aufrufen reingepastet statt immer den sprung
  137. zur func zu machen // werden definiert mittels inline
  138. -moderne compiler brauchen kein inlining mehr da diese selber inlining betreiben wenn dies sinnvoll erscheint
  139. -inlining macht das programm größer (d.h zur laufzeit wird mehr speicher benötigt) aber das programm läuft schneller
  140.  
  141. folie11:
  142. -rekursion bezeichnet den aufruf einer funktion durch sich selbst
  143. -wichtig bei rekursion ist dass die Problemzerlegung und selbstaufrufe irgendwann enden
  144. -endrekursion bezeichnet den spezialfall bei der jeder nächste rekursive aufruf die letzte aktion des vorherigen rek. aufrufs ist
  145. -endrekursionen lassen sich unmittelbar durch for bzw. while schleifen ersetzen
  146. -modularisierung von software gründe: der hersteller bietet seine software dritten an möchte aber keine blicke in die interne realisierung gewähren
  147. -der compiler möchte nicht die ganze def. (rumpf) einer func. analysieren nur um einen funcaufruf zu übersetzen führt zu effizienzgewinn
  148. -es soll nicht notwenig sein ein ganzes softwaresystem neu zu compilieren nur weil es eine kleine änderung gab
  149. -c++ programme können über mehrere Quelltextdateien verteilt sein
  150. -mit header dateien weil includen von cpp kopiert es nur rein und verteile entwicklung wird unterstützt z.b in teams
  151. -header per #include
  152. -includeverzeichnisse bezeichnet man die verzeichnisse wo der compiler nach headerdateien sucht dabei stoppt der compiler beim ersten treffer
  153. der dateiname ist das einzige kriterium
  154. -eine initiale liste von includeverzeichnissen ist von c++ gegeben man kann diese aber ändern und ggf. weitere hinzufügen
  155. -#include <xx> sucht nur in den c++ verzeichnissen nach der headerdatei gedacht für standart bibliotheken
  156. -#inlcude "xx" sucht zuerst im aktuellen verzeichnis nach dem header dannach sucht c++ in den anderen bisher benutzen headerverzeichnissen
  157. und zum schluss in den c++ std. bib verzeichnissen
  158. -optional können relative oder absolute dateipfade innerhalb "" angegeben werden dann wird aber nurnoch dort gesucht nachteil auf fremden rechnern
  159. -headerdatei enthalten Schnittstellenbeschreibungen also z.b Prototypen von funcs. mehr kommt später in gip
  160. -cpp dateien nennt man implementierungsdateien sie enthalten realisierungen vieler code erzeugender c++ konstrukte  wie funcs.
  161. -die one defintion rule besagt dass jede sichtbare func. var. etc. genau eine definition im gesamten c++ programm haben muss
  162. -defaultparameter werden nur im prototyp angegeben also ein weiterer grund die headerdatei zu includieren
  163. -inline funktionen werden komplett in einer headerdatei programmiert
  164. -globale variablen müssen in einer cpp definiert werden
  165.  
  166. folie12:
  167. -präprozessor bindet die headerdatein in die cpp dateien ein
  168. -befehle an den präprozessor nennt man präprozessor direktiven beginnen mit einem # z.b #include ist also keine c++ anweisung deshalb auch kein ;
  169. -durch #pragma once am anfang der headerdatei stellt der präprozessor sicher dass die headerdatei nicht mehrfach eingefügt werden
  170. -mit der modularisierung kann es passieren dass in vers. cpp dateien gleichnamige funktionen definiert werden dann namespace
  171. -bestimmte bereiche können dann mittels namspace name {] in einen namespace gesetzt werden
  172. -die klammerung vom namespace wird in der cpp und in der header datei gesetzt
  173. -anstatt der klammerung kann in einer cpp auch :: benutzt werden
  174. -4 geltungsbereiche in c++: 1. lokaler geltungsbereich im block definiert // 2.klassen geltungsbereich // 3.namespace geltungsbereich
  175. 4.datei geltungsbereich der nicht in einen der 3 vorherhigen definiert wurde gilt überall und kann durch extern überall geused werden
  176.  
  177. folie13:
  178. -streams sind datenströme im system bis jetzt << >> von cout
  179. -falsche eingaben bei cin verbleiben in der eingabe diese muss man clearen mit: cin.clear() löscht das Error-flag
  180. cin.ignore(länge der zeichen, \n) \n bis zur newline
  181. -ebenso notwendig beim wechsel von der eingabe in einen elementaren Datentyp einfach nach eingabe cin.ignore()
  182. -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
  183. -für dateioperation #include <fstream> abfolge des zugriffs 1.anlegen eines fstreams zu einer datei // 2.öffnen der datei
  184. 3.lese u schreibeoperationen // 4.schließen der datei.
  185. -anlegen eines fstreams mittels variable z.b fstream datei dabei werden dateiname sowie der zugriffsmodus als Parameter übergeben z.b
  186. fstream datei1("file.txt", ios::out); // ios::in zum lesen ios::out zum schreiben  oder beides dann mit | trennen
  187. weitere befehle ios::trunc leert die datei beim öffnen ios::app hängt die neuen geschriebenen sachen ans ende der datei
  188. -dateien können mittels absoluter oder relativer dateipfade angegeben werden ohne pfad wird die datei im arbeitsverzeichnis angelegt
  189. -ö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
  190. -schließen durch .close()
  191. -dateien die nur zum lesen sind ifstream
  192. -dateien die nur zum schreiben sind ofstream
  193. -schreiben funktioniert wie bei cin mittels streamoperator z.b datei1 << "hallo";
  194. -lesen mittels >>
  195. -liest bis zum zeilenende bzw. bis zum eof endoffile deshalb per while(datei1 >> x)
  196. -ende prüfen durch datei1.eof() z.b in if
  197. -fehler beim öffnen prüfen durch if(!datei1) oder durch fail() oder good()
  198. -binärdateien öffnen durch ios::binary
  199. -ein strukturierter Datentyp fasst mehrere elemente ggfs. versch. datentypen zu einem strukturierteren Datentyp zusammen
  200. mittels struct name {]komponent; falls nötig
  201. komponent.inhalt()
  202. -sollten in headerdatei stehen
  203.  
  204. folie14:
  205. -aufzählungsdatentypen werden verwendet für daten wertebereich aus konstanten werten besteht z.b rot/blau/gelb o. montag/dienstag/usw.
  206. -in c++ mittels enum name {rot,blau,gelb};
  207. -c++ verwendet intern int für diese aufzählungen
  208. -man kann die internen int werte auch selber definieren enum wochentag {sonntag = 0; montag = 1 usw.};
  209. -datentyp definitionen sollten in headerdatei definiert werden
  210. -referenzen sind ein allgemeines konstrukt welches überall wo variablen sind verwendet werden kann
  211. -referenzen können nicht verändert werden sobald diese auf eine variable zeigen
  212. -referenzen garantieren dass mit dem original wert gearbeitet wird
  213. -Computer speichern ihre daten im RAM
  214. -jeder speicherzelle hat eine eindeutige adresse
  215. -der & operator liefert die adresse in der eine variable gespeichert ist
  216. -bei variablen die in mehreren speicherzellen gespeichert ist liefert & die erste zurück
  217. -ein pointer ist eine variable deren wert eine speicheradresse im hauptspeicher ist
  218. -pointer dienen dazu auf einen anderen variableninhalt bzw. speicherinhalt zu verweisen
  219. -der datentyp der pointervariable beschreibt welchen datentyp der wert an der aufgezeigten speicheradresse hat
  220. -definition durch datentyp *name; also int *ptr; dann nur definiert zuweisung durch z.b int *ptr = %x;
  221. -der stern ist nur bei der defintion nötig dannach kann der pointer mit namen normal verwendet werden
  222. -pointer lassen sich nicht auf ganze zahlen setzen also z.b = 1000
  223. -pointer sind getypet also können nur auf werte mit dem selben datentyp zeigen
  224. -deferenzieren einer pointervariable bezeichnet die operation bei der auf den datenwert auf welchen ein pointer zeigt zugegriffen wird
  225. -bei benutzung des inderktionsoperator * kann man wertzuweisungen auf den "originalwert" durchführen
  226. -nullpointer: bezeichnet einen speziellen pointerwert der noch keinen wert hat entweder per 0 oder per nullptr;
  227. -pointer auf lokale variablen fehleranfällig weil wenn die variable weg ist dann zeigt der ptr immernoch auf den speicherort
  228. -egal welcher datentyp pointer belegen immer gleich viel speicher
  229. -referenzen können nicht umgeleitet werden verhalten sich also wie konstanten pointer hingegen können umgeleitet werden
  230. -das pointer & steht für adresse von und referenz & für eine definition einer referenz
  231.  
  232. folie15: 29.11
  233. -pointer sind verweise ohne eingebaute automatik wie referenzen
  234. -dynamische datenstrukturen new teilt speicher zu aus einem speziellen bereich des hauptspeichers dem heap die zuteilung nennt man allokation von heap speicher
  235. -der new befehl liefert die adresse des neu allozierten speicherbereichs zurück z.b int *ptr = new int;
  236. -wird mit new speicherplatz angefordert so kann man auch direkt den datenwert angeben z.b int *ptr = new int{0};
  237. -über den befehl delete kann zur laufzeit des programms speicherplatz der mit new gefordert wurde wieder freigegeben werden
  238. -delete ändert nichts an dem wert der dem pointer zugewiesen wurde aber pointer die drauf zeigten sind dann dangling pointer diese sollte man
  239. mit nullptr auf nichts mehr zeigen lassen
  240. -datenobjekte mittels new verbleiben auch nach ihrer gültigkeit in einem rumpf also am besten mit delete löschen
  241. -werden mittels new allozierte speicherbereiche nicht mehr verwendet und nicht mit delete gelöscht so verbraucht das programm zu seiner laufzeit
  242. mehr und mehr speicher das nennt man memory leak
  243. -in dynamischen datenstrukturen nennt man die einzelnen einträge knoten
  244. -verkettungen mittels pointern. letzter eintrag enthält den nullpointer um zu zeigen dass nichts mehr folgt
  245. -um den xten eintrag zu lesen muss man durch die ganze liste gehen nicht möglich wie bei arrays eine bestimmte stellen sofort anzusprechen
  246. -um den anfang einer liste zu lesen gibt es eine variable die einen pointer auf den ersten listeneintrag speichert solch einen verweis auf das
  247. erste element nennt man anker zeigt der anker auf nullptr so ist die liste noch leer
  248. -für die kombination pointer dereferenzieren und dann member einer struct auslesen gibt es den auswahloperator ->
  249. -merken: arrays haben eine feste größe also muss man sich explizit merken welcher teil auch werte trägt
  250.  
  251. folie16:
  252. -Speicher der mittels New freigegeben wurde wird nicht am ende eines rumpfs oder am ende einer funktion freigegeben bzw. gelöscht
  253. -gucken in praktiukumsaufgabe mit pointern ggf. wiederholen vorl. 03.12
  254.  
  255. folie17: 10.12
  256. -pointer können auch auf pointer zeigen durch **
  257. -anker->next->next z.b
  258. -bei mehrfacher indirektion über struct daten bezeichnet der letzte eintrag in der "-> kette" die komponente struct alles davor nur den weg dahin
  259. -array können auch mit new[] erstellt und delete[] gelöscht werden
  260. -auto für automatische typermittlung in GIP nicht erlaubt
  261. -wird eine var. als static innerhalb einer func oder block definiert so behält diese zwischen den aufrufen ihren aktuellen wert
  262. -main darf nicht von anderen funktionen aufgerufen werden
  263. -compiler unterstützen main in 2 varianten : int main() bzw. int main(int argc,  char *argv[])
  264. -der int parameter argc mit wievielen parametern das Programm aus der IDE aufgerufen wurde der programmname zählt mit
  265. -der parameter argv ist ein array von pointern auf char verweist auf ein cstring in welchem die mitgegebenen Programmparameter festgehalten sind
  266. -typedef erlaubt es einen neuen namen für einen datentyp zu definieren
  267. -der ? operator für abfrage also: bedingung ? wahrausdruck : falschausdruck z.b a<b ? a : b;
  268. -goto anweisung: label wird erstellt  name: und dann mit goto name; direkter sprung
  269. -das konzept von goto wiederspricht den regeln der strukturierteren programmierung da der kontrollfluss unübersichtlich wird
  270. -unsigned int umfasst die positiven ganzzahligen werte inklusive der 0
  271. -short int umfasst pos. und neg. ganzahlige werte aber mit kleinerem bereich als int
  272. -long int umfasst pos. und neg. ganzzahlige werte aber mit einem größeren wertebereich als int
  273. -float umfasst fließkommazahlen aber mit geringerer genauigkeit als double
  274. -assertions auf deutsch = zusicherung // mittels assert() kann man prüfen ob die in klammern gegebene bedingung erfüllt ist wenn ja
  275. läuft das programm weiter falls nein bricht es mit einem error ab // benötigt <cassert> includiert
  276. -sind nur sinnvoll während der programmierung
  277. -unit test cases sind fälle die die funktion genau so wiedergeben muss
  278.  
  279. folie18: //noch nicht fertig geht weiter....
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
Top