add info 3

photonics.typ

@@ -1,3 +1,6 @@
+// fill: (x, y) => if y == 0 {gray.lighten(40%)},
+//
+
 // {{{
 #set text(lang: "de", hyphenate: true)
 #set par(justify: true)  // Blocksatz
@@ -237,11 +240,12 @@ Definition
 // }}}
 = Lineare Algebra
 // {{{
-== linalg 3
 
 
 #pagebreak()
-= Mathematik 3
+// }}}
+= Mathematik 3 (Analysis 3)
+// {{{
 == Differentialgleichungen
 === Abkürzungen
 #table(columns: (0.5fr, 1fr, 1fr),
@@ -283,6 +287,10 @@ fill: (x, y) => if y == 0 {gray.lighten(40%)},
 ],
 )
 
+// }}}
+= Mathematik 3 (Lineare Algebra 3)
+// {{{
+
 
 #pagebreak()
 // }}}
@@ -628,7 +636,7 @@ class Vec3 {
   public:
     ...
     double x;
-    private:
+  private:
     double y;
     double z;
 };
@@ -676,7 +684,119 @@ class Foo {
 };
 ```]
 
+==== constructor
 
+==== decounstructor
+
+=== overloading
+
+=== std -> Namespace
+
+=== std::string
+Für Strings: ```cpp #include <string> ```
+#table(columns: (1fr, 1fr),
+[String einer Variable Zuweisen], [```cpp std::string str = "Hello"; ```],
+[Auf ein Element zugreifen \ (Nicht empfohlen da zugriff auch ausserhalb des str möglich)!], [```cpp str[0]; ```],
+[Auf ein Element zugreifen \ empfohlen option], [```cpp str.at(0); ```],
+[Anzahl Zeichen im str], [```cpp str.length(); ```],
+[Grösse von vom String], [```cpp str.size(); ```],
+[Erstes Zeichen ausgeben], [```cpp str.font(); ```],
+[Letztes Zeichen ausgeben], [```cpp str.back(); ```],
+[Vom start eine bestimmte länge ausgeben], [```cpp str.substr(start, anzahl_zeichen); ```],
+[Strings zusammensetzen], [```cpp
+str = "Hello";
+str += "world";
+str = str + "!";
+```],
+[Bereich löschen], [```cpp  str.erase(start, anzahl_zeichen) ```],
+[Text einfügen], [```cpp  str.inset(start, "Hello") ```],
+[find], [```cpp  size_t pos = str.find("de"); ``` \ ```cpp if (pos == std::string::npos){} ```],
+[Strings vergleichen], [```cpp (str1 == str2) ```],
+)
+=== container
+container sind arrays welche daten enthalten und nicht selbst mit array handeling (malloc, speicher freigeben) zu tun haben.
+==== std::vector
+Beim vector wird im hintergrund ein Speicherbereich reserviert. Falls der user etwas ergenzen möchte wird noch etwas mehr reserviert als benötigt wird. Sollte viel mehr ergäntz werden, so muss ein neuer Speicherbereich reserviert werden die daten rüber kopiert werden und der alte Speicherbereich wieder freigeben werden.
+#table(columns: (1fr, 1fr),
+fill: (x, y) => if y == 0 {gray.lighten(40%)},
+[Vorteile], [Nachteile],
+[Schnelle zugriffszeit], [Wird der vector um viele elemente erweitert so muss der speicher neu zugewiessen werden.],
+[Geringerer Speicher-Overhead pro Element.], [Langsame Einfüge- und Löschvorgänge in der Mitte]
+)
+#cetz.canvas({
+  import cetz.draw: *
+  rect((0, 0), (8, 1), fill: rgb(0, 0, 255, 60))
+  grid((0, 0), (8, 1), step: 1)
+  content((0.5, 0.5), [1])
+  content((1.5, 0.5), [2])
+  content((2.5, 0.5), [3])
+  content((3.5, 0.5), [4])
+  content((4.5, 0.5), [5])
+})
+Zum verwenden eines Vectors: ```cpp #include <vector> ``` \
+Vektoren können verschieden Datentypen haben.
+#table(columns: (0.6fr, 1fr),
+[Vektor initialisieren], [```cpp std::vector<bool> states; ``` \ ```cpp std::vector<int> numbers{1, 2, 3}; ``` \ ```cpp std::vector<std::string> strings; ``` \ ```cpp std::vector<eigene_class> players; ```],
+[Auf ein Element zugreifen], [```cpp v[0]; ```],
+[Grösse von vom vector], [```cpp v.size(); ```],
+[Erstes Zeichen ausgeben], [```cpp v.font(); ```],
+[Letztes Zeichen ausgeben], [```cpp v.back(); ```],
+[Element am Ende anhängen], [```cpp v.push_back(number); ```],
+[Element am Anfang einfügen], [```cpp v.inset(v.begin(), number); ```],
+[Element en stelle X einfügen], [```cpp v.inset(pos, number); ```],
+[Zwei Vektoren Zusammenhang], [```cpp v1.inset(v1.end(), v2.begin(), v2.end()); ```],
+[Element löschen], [```cpp v.erase(pos); ```],
+[Bereich löschen], [```cpp v.erase(start, stop); ```],
+[Bereich extrahieren \ v1 ist der ursprüngliche vektor. v2 ist der auschnit von v1. im Beispiel rechts ist: \ v2 = {2, 3, 4}], [```cpp
+std::vector<int> v1{ 1, 2, 3, 4, 5 };
+std::vector<int>::iterator first = v1.begin() + 1;
+std::vector<int>::iterator last = v1.begin() + 4;
+std::vector<int> v2(first, last);
+```],
+[Conteiner ineinander packen \ (Nesting) \ können normal wie 2D array's behandelt werden: v[i][j]], [```cpp
+std::vector<std::vector<int>> v{{ 0, 1 },
+                                { -1, 0, 2 }}; ```],
+)
+==== std::list
+Listen sind verkettete Daten. Listen sollten verwendet werden wenn häufig elemente in der mitte hinzugefügt oder enternt werden.
+#table(columns: (1fr, 1fr),
+fill: (x, y) => if y == 0 {gray.lighten(40%)},
+[Vorteile], [Nachteile],
+[Schnelles Einfügen und Löschen an jeder Position], [Kein schneller Direktzugriff],
+[], [Hoher Speicher-Overhead durch die Zeiger],
+[], [Schlechte Cache-Performance aufgrund des nicht-kontinuierlichen Speichers.]
+)
+#cetz.canvas({
+  import cetz.draw: *
+  content((-2, 1.5), [node\*])
+  line((-1.5, 1.5), (0, 1.5), mark: (end: ">"), fill: blue, stroke: blue)
+  for i in range(0, 4){
+    rect((i * 3, 0), (i * 3 + 1, 2), fill: rgb(0, 0, 255, 60))
+    line((i * 3, 1), (i * 3 + 1, 1))
+  }
+  for i in range(0, 3){
+    line((i * 3 + 1, 0.5), (i * 3 + 3, 1.5), mark: (end: ">"), fill: blue, stroke: blue)
+  }
+  content((0.5, 1.5), [1])
+  content((0.5, 0.5), [0x80])
+  content((3.5, 1.5), [3])
+  content((3.5, 0.5), [0x84])
+  content((6.5, 1.5), [5])
+  content((6.5, 0.5), [0x66])
+  content((9.5, 1.5), [13])
+  content((9.5, 0.5), [0x49])
+})
+
+==== std::array
+==== std::map
+
+=== testing
+```cpp
+#include <cassert>
+
+assert(funktion_1 == "hello");
+assert("hell" == "hello");
+```
 
 
 #pagebreak()