update info 3

src/informatik_3.typ

@@ -160,7 +160,7 @@ fill: (x, y) => if y == 0 {gray.lighten(40%)},
 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; ```],
+[Vektor initialisieren], [```cpp std::vector<bool> states; ``` \ ```cpp std::vector<int> numbers{1, 2, 3}; ``` \ ```cpp std::vector<int> v(4); ``` $arrow$ vector mit 4 Elemente und mit 0 initialisiert \ ```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(); ```],
@@ -212,7 +212,142 @@ fill: (x, y) => if y == 0 {gray.lighten(40%)},
 })
 
 ==== std::array
+Zum verwenden eines arrays: ```cpp #include <array> ``` \
+Der Array hat eine fixe grösse. Der grosse vorteil von den cpp arrays ist das man die grösse vom array mit: ```cpp var.size()``` die grösse bekommt. So kann man mittels for Schleife durch ein array gehen ohne die grösse seperat als Variable mitzugeben. \
+Beispiel:
+```cpp
+#include <array>
+#include <iostream>
+int main() {
+  std::array<int, 3> a{ 1, 2, 3 };
+  for (size_t i = 0; i < a.size(); i++)
+  std::cout << a[i] << " ";  // Output: 1 2 3
+  return 0;
+}```
+
 ==== std::map
+Mapps sind wie Dictenarys von Python. Sie können mit: ```cpp #include <map> ``` eingebunden werden.
+#table(columns: (0.4fr, 1fr),
+[Map erstellen],[```cpp std::map<int, int> squares{{1, 1}, {2, 4}, {3, 9}};``` \ in dem "<>" werden die Datentypen festelegt. z.B. \ ```cpp map<int, bool>, map<std::string, Book>``` (Book -> Struct)],
+[Auf Element zugreifen],[```cpp squares.at(2)  // -> 4```],
+[Element hinzufügen und falls forhanden alte Werte überschreiben],[```cpp
+std::map<char, int> mymap;
+mymap['a'] = 200;
+mymap['b'] = 100;
+mymap['c'] = 300;
+```],
+[#strike[Element hinzufügen falls es nicht existiert gibt true oder false zurück] *veraltet*],[```cpp ret = mymap.insert(std::pair<char, int>('a', 500)); ``` \ Hier wird "a" nicht überschrieben und false zurückgegeben.],
+[Element hinzufügen falls es nicht existiert gibt true oder false zurück],[```cpp ret = mymap.emplace('a', 500); ``` \ Hier wird "a" nicht überschrieben und false zurückgegeben.],
+[Element suchen],[```cpp squares.find(4);``` \ z.B. ```cpp if (squares.find(num) != squares.end()){/*some code*/} ```],
+[For schleife],[```cpp
+for (std::map<int, int>::iterator it = squares.begin(); it != squares.end(); it++){
+  std::cout << it->first << " -> " << it->second << "\n";
+}
+```],
+[Iterator vom ersten Element],[```cpp squares.beginn()```],
+[Iterator vom letzten Element],[```cpp squares.end()```],
+[Element löschen],[```cpp squares.erase(1)``` ("1" ist das das par und nicht der index -> {1, 1})],
+)
+Möchte man Elemente mit z.B. .inset() anfügen braucht es ein eine par funktion.
+#table(columns:  (1fr, 1fr),
+fill: (x, y) => if y == 0 {gray.lighten(40%)},
+[std::pair()],[std::make_pair()],
+[std::pair\<T1, T2>(arg1, arg2) (Direkter Konstruktor)],[std::make_pair(arg1, arg2) (Hilfsfunktion)],
+[```cpp mymap.insert(std::pair<char, int>('z', 500)); ```], [```cpp mymap.insert(std::make_pair('z', 500)); ```],
+[Mit dem: Class Template Argument Deduction (CTAD) \ ```cpp mymap.insert(std::pair('z', 500)); ```], [],
+)
+Die variante mit "make_pair" kommt von früher und ist nicht mehr gebreuchlich.
+
+=== Algorithmus
+==== std::fill
+Der fill befehl ersetzt in einem bereich von iteratoren einen anderen wert.
+#table(columns: (1fr, 0.8fr), [```cpp
+#include <iostream>
+#include <vector>
+int main(){
+    std::vector<int> v{4, -2, 5, 8, 6, 9};
+    // std::fill(v.begin(), v.end(), 0);
+    std::fill(v.begin() + 2, v.end() - 1, 3);
+    return 0;
+}
+```], [Output: #grid(columns: (0.9fr, 1fr), gutter: 10pt,
+[v vor dem fill:], [`4, -2, 5, 8, 6, 9`],
+[v nach dem fill: ], [`4, -2, 3, 3, 3, 9`],) Die 5, 8 und 6 wurden durch 3 ausgetauscht.
+])
+
+==== std::copy
+Mit dem copy befehl können bereiche eines conteiner an einen anderer ort kopiert werden. \
+Kopie inerhalb des gleichen conteiners:
+#table(columns: (1fr, 0.8fr), [```cpp
+std::vector<int> v{1, 2, 0, 0, 0, 0};
+std::copy(v.begin(), v.begin() + 2, v.begin() + 4);
+```], [Output: #grid(columns: (0.9fr, 1fr), gutter: 10pt,
+[v vor dem copy:], [`1, 2, 0, 0, 0, 0`],
+[v nach dem copy: ], [`1, 2, 0, 0, 1, 2`],)
+]
+)
+Kopie in einen anderen conteiners:
+#table(columns: (1fr, 0.8fr), [```cpp
+std::vector<int> v{1, 2, 0, 0, 0, 0};
+std::copy(v.begin(), v.begin() + 2, v.begin() + 4);
+
+std::vector<int> w(4);
+std::copy(v.begin(), v.begin() + 2, w.begin() + 2);
+```], [Output: #grid(columns: (0.9fr, 1fr), gutter: 10pt,
+[w vor dem copy:], [`0, 0, 0, 0`],
+[w nach dem copy: ], [`0, 0, 1, 2`],)
+]
+)
+
+==== std::reverse
+Elemente eines Conteiner umkehern.
+#table(columns: (1fr, 0.8fr), [```cpp
+#include <algorithm>
+std::vector<int> v{1, 2, 0, 8, 0, 0};
+std::reverse(v.begin(), v.end());
+```], [Output: #grid(columns: (0.9fr, 1fr), gutter: 10pt,
+[v vor dem reverse:], [`1, 2, 0, 8, 0, 0,`],
+[v nach dem reverse: ], [`0, 0, 8, 0, 2, 1`],)
+]
+)
+
+==== std::sort
+==== std::shuffle
+==== std::find
+==== std::equal
+
+=== Runtime complexity
+==== Binary search tree
+==== std::set
+==== std::unordered_set
+==== Hash table
+==== Big O notation
+==== Performance übersicht
+
+=== References
+In cpp gib es Referenzen. Diese sind einfacher zu handhaben und sicherer als "call by References".
+#table(columns: (0.4fr, 1fr),
+[Call by References], [```cpp
+void func_with_ptr_param(int *param) {
+  *param = 43; // Dereference pointer
+}
+int x = 42;
+// x is 42
+func_with_ptr_param(&x);
+// x is 43
+```],
+[References], [```cpp
+void func_with_ref_param(int &param) {
+  param = 44;
+}
+int x = 43;
+// x is 43
+func_with_ref_param(x);
+// x is 44
+```],
+)
+Zudem gibt es bei Referenzen keine null pointer und es können keine Referenzen auf Referenzen gemacht werden.
+
 
 === testing
 ```cpp