Initialer ImportHEADmaster

19 files changed, 665 insertions, 0 deletions

diff --git a/README.txt b/README.txt
new file mode 100644
index 0000000..1343ac6
--- /dev/null
+++ b/README.txt
@@ -0,0 +1,12 @@
+In diesem Bereich soll Grundwissen gesammelt werden,
+um einen Einstieg in die Programmiersprache C++ (C) zu ermöglichen.
+Dabei wird es jeweils eine info.txt geben, die einen Überblick bereitstellt,
+und eine Reihe von Unterverzeichnissen, in denen Code(-Elemente) erklärt und demonstriert werden.
+Desweiteren wird es Aufgaben geben, die die neu erlernten Kentnisse fördern sollen.
+
+Vorausgesetzt wird dabei im Moment folgendes:
+-Kenntniss grundlegender Consolenbefehle
+-Kenntniss darüber, den erstellten Code mit make oder g++ oder anders zu compilieren
+-Grundlegende Kenntnisse über etwas weitergehende Themen bei Computern, die evtl. aufgegriffen werden.
+
+->Schwierige Stellen sollen Adressen zu Hilfeseiten im Internet enthalten.
diff --git a/fortgeschritten/01_Klassen/01_Klassen.cpp b/fortgeschritten/01_Klassen/01_Klassen.cpp
new file mode 100644
index 0000000..b1fa6cb
--- /dev/null
+++ b/fortgeschritten/01_Klassen/01_Klassen.cpp
@@ -0,0 +1,23 @@
+#include <iostream>
+#include "Person.h"
+
+
+int main() {
+  Person p;
+  
+  Person p2("Hans", 20);
+  
+  p.printName();
+  p.printAlter();
+  
+  p2.printName();
+  p2.printAlter();
+  
+  p.setName("Horst");
+  p.setAlter(19);
+  p.printName();
+  p.printAlter();
+  
+  return 0;
+}
+
diff --git a/fortgeschritten/01_Klassen/Makefile b/fortgeschritten/01_Klassen/Makefile
new file mode 100644
index 0000000..4fc43c4
--- /dev/null
+++ b/fortgeschritten/01_Klassen/Makefile
@@ -0,0 +1,2 @@
+01_Klassen: 01_Klassen.o Person.o
+	g++ -o $@ $^
diff --git a/fortgeschritten/01_Klassen/Person.cpp b/fortgeschritten/01_Klassen/Person.cpp
new file mode 100644
index 0000000..4beede7
--- /dev/null
+++ b/fortgeschritten/01_Klassen/Person.cpp
@@ -0,0 +1,32 @@
+#include "Person.h"
+#include <iostream>
+
+
+Person::Person() {
+  name = "Unbekannt";
+  // -1 bedeutet bei uns jetzt, dass wir das Alter nicht wissen
+  alter = -1;
+}
+
+Person::Person(const std::string &n, int a) {
+  name = n;
+  alter = a;
+}
+
+void Person::printName() {
+  std::cout << "Der Name ist: " << name << std::endl;
+}
+
+void Person::setName(const std::string &n) {
+  name = n;
+}
+
+void Person::printAlter() {
+  if(alter < 0) std::cout << "Das Alter ist unbekannt." << std::endl;
+  else std::cout << "Das Alter ist: " << alter << std::endl;
+}
+
+void Person::setAlter(int a) {
+  alter = a;
+}
+
diff --git a/fortgeschritten/01_Klassen/Person.h b/fortgeschritten/01_Klassen/Person.h
new file mode 100644
index 0000000..9109ac6
--- /dev/null
+++ b/fortgeschritten/01_Klassen/Person.h
@@ -0,0 +1,38 @@
+// Dies sind Präprozessorkommandos, die dafür sorgen, dass Person.h nur einmal eingebunden werden kann
+#ifndef _PERSON_H_
+#define _PERSON_H_
+
+#include <string>
+
+
+class Person {
+  private:
+    std::string name;
+    int alter;
+    
+  public:
+    Person();
+    
+    // Das & sorgt dafür, dass der String direkt übergeben und nicht kopiert wird, das macht das Programm schneller
+    // const heißt, dass n nicht verändert wird in der Methode
+    Person(const std::string &n, int a);
+    
+    void printName();
+    void setName(const std::string &n);
+    
+    // Einfache Methoden können direkt in die Klassendefinition geschrieben werden
+    // Normalerweise gibt es in einer Klasse zu jeder Eigenschaft eine get- und eine set-Methode
+    std::string getName() {
+      return name;
+    }
+    
+    void printAlter();
+    void setAlter(int a);
+    
+    int getAlter() {
+      return alter;
+    }
+};
+
+#endif //_PERSON_H_
+
diff --git a/fortgeschritten/01_Klassen/README b/fortgeschritten/01_Klassen/README
new file mode 100644
index 0000000..2bc9921
--- /dev/null
+++ b/fortgeschritten/01_Klassen/README
@@ -0,0 +1,3 @@
+Normalerweise wird jede Klasse in eigenen Dateien definiert, die Definition in einer .h-Datei, die Methoden in einer .cpp-Datei, das hält die einzelnen Dateien überschaubar.
+
+In der Datei Makefile ist angegeben, wie das Programm dann aus den einzelnen Dateien erzeugt wird. 'make Klassen_01' wird hier also ein Programm aus Klassen_01 und Person erzeugen, man kann aber auch einfach 'make' eingeben, dann wird die erste Zeile des Makefiles ausgeführt, hier also Klassen_01.
diff --git a/fortgeschritten/02_Zeiger/02_Zeiger.cpp b/fortgeschritten/02_Zeiger/02_Zeiger.cpp
new file mode 100644
index 0000000..5c0a066
--- /dev/null
+++ b/fortgeschritten/02_Zeiger/02_Zeiger.cpp
@@ -0,0 +1,33 @@
+#include <iostream>
+
+
+int main() {
+  /* Zeiger sind eine besondere Art von Variablen, die nicht direkt einen Wert enthalten, sondern eine Adresse im 
+   * Arbeitsspeicher, sie zeigen auf eine andere Variable, die im Arbeitsspeicher liegt.
+   */
+  
+  // Normale Variable
+  int i = 4;
+  
+  // Zeigervariable wird mit * deklariert, int * bedeutet "Zeiger auf einen int";
+  // &i bedeutet "Speicheradresse von i", somit zeigt p jetzt auf i.
+  int *p = &i;
+  
+  std::cout << "i: " << i << std::endl;
+  
+  // Gibt die Speicheradresse in p aus
+  std::cout << "p: " << p << std::endl;
+  
+  // *p löst den Zeiger p auf, also das, worauf p zeigt
+  std::cout << "*p: " << *p << std::endl;
+  
+
+  i = 5;
+  
+  // Wenn i sich ändert, bleibt zwar die Speicheradresse gleich, aber der neue Wert ist auch durch p verfügbar
+  std::cout << "i: " << i << std::endl;
+  std::cout << "p: " << p << std::endl;
+  std::cout << "*p: " << *p << std::endl;
+  
+  return 0;
+}
diff --git a/fortgeschritten/03_Zeiger_als_Parameter/03_Zeiger_als_Parameter.cpp b/fortgeschritten/03_Zeiger_als_Parameter/03_Zeiger_als_Parameter.cpp
new file mode 100644
index 0000000..dbfcdc9
--- /dev/null
+++ b/fortgeschritten/03_Zeiger_als_Parameter/03_Zeiger_als_Parameter.cpp
@@ -0,0 +1,32 @@
+#include <iostream>
+
+
+void erhoehe(int x) {
+  x++;
+}
+
+void erhoeheZeiger(int *x) {
+  (*x)++;
+}
+
+
+int main() {
+  int i = 5;
+  
+  std::cout << i << std::endl;
+  
+  /* Wird der int einfach so übergeben, ändert sich nuer x-er Wert innerhalb der erhoehe-Funktion,
+   * das urspüngliche i wird nicht beeinflusst
+   */
+  erhoehe(i);
+  std::cout << i << std::endl;
+  
+  /* Wird ein Zeiger übergeben, kann die Funktion über den Zeiger auf die ursprüngliche Variable
+   * zugreifen und sie so erhöhen. Will man, dass eine Funktion einen Parameterwert verändert,
+   * muss sie also einen Zeiger übergeben.
+   */
+  erhoeheZeiger(&i);
+  std::cout << i << std::endl;
+  
+  return 0;
+}
diff --git a/grundelemente/01_Hello_World/01_Hello_World.cpp b/grundelemente/01_Hello_World/01_Hello_World.cpp
new file mode 100644
index 0000000..4e7dec7
--- /dev/null
+++ b/grundelemente/01_Hello_World/01_Hello_World.cpp
@@ -0,0 +1,32 @@
+// Dies ist ein Kommentar.
+/* Dies ist auch ein Kommentar,
+nur ist er mehrzeilig. */
+
+/* In dieser Zeile binden wir die Datei iostream ein. Diese stellt uns die später benutzten Objekte std::cout und 
+ * std::endl zur Verfügung.
+ */
+#include <iostream>
+
+/* main ist der Name der Eintrittsfunktion. Das Programm beginnt mit der Ausführung der main-Funktion.
+ * Die geschweiften Klammern { und } begrenzen den Block, der den Code, der zur main-Funktion gehört, darstellt.
+ */
+int main()
+{
+  /* std::cout ist der Name der Standard-Ausgabe. Mit << werden Objekte an die Standardausgabe geschickt, hier z. B.
+   * der Text "Hello World!". Texte, die keine Programmbefehle sind, werden in C++ im Allgemein mit "" begrenzt. 
+   * std::endl ist ein besonderes Objekt, dass einen Zeilenumbruch erzeugt. Wie jeder Befehl ist dieser mit einem
+   * Semikolon begrenzt, man kann einen sehr langen Befehl also auf mehrere Zeilen aufteilen.
+   */
+  std::cout << "Hello World!" << std::endl;
+  
+  /* Der Return-Befehl beendet das Programm und gibt den Rückgabewert des Programms an. Ein Wert von 0 wie hier
+   * bedeutet, dass das Prgramm fehlerfrei abgelaufen ist.
+   */
+  return 0;
+}
+
+/******************AUFGABE:***********************
+ * Erstelle selbstgeschrieben, nicht kopiert,
+ * ein eigenes helloWorld-Programm,
+ * das eine von dir festgelegte Zeichenkette ausgibt.
+ *************************************************/
diff --git a/grundelemente/02_Konsole/02_Konsole.cpp b/grundelemente/02_Konsole/02_Konsole.cpp
new file mode 100644
index 0000000..37b4bef
--- /dev/null
+++ b/grundelemente/02_Konsole/02_Konsole.cpp
@@ -0,0 +1,31 @@
+#include <iostream>
+
+int main()
+{
+  /* Dies ist eine Variable. Variablen werden benutzt, um Werte zu speichern, mit denen das Programm operieren soll.
+   * Hier handelt es sich um eine Variable vom Typ char, das steht für Character ist bedeutet Buchstabe. Eine
+   * Variable vom Typ char kann einen einzelnen Buchstaben fassen.
+   */
+  char cEingabe;
+  
+  std::cout << "Bitte geben sie ein einzelnes Zeichen ein, gefolgt von einem druck auf <Enter>" << std::endl;
+  
+  /* std::cin ist das Gegenteil von std::cout, es handelt sich um die Standardeingabe. Mit >> wird eine Eingabe
+   * in eine Variable eingelesen. Da cEingabe vom Typ char ist, muss ein einzelner Buchstabe eingeben werden.
+   */
+  std::cin >> cEingabe;
+  
+  /* Wie man sieht, kann man mit std::cout auch Variableninhalte ausgeben. Dabei wird der Variablenname nicht in
+   * "" geschrieben, sonst würde ja nur der Name der Variable als Text und nicht der Inhalt der Variable
+   * ausgegeben werden.
+   */
+  std::cout << "Ihre Eingabe war: " << cEingabe << std::endl;
+  
+  return 0;
+}
+
+
+/***************************AUFGABE:***********************
+Erstelle ein Programm, das den Benutzer mit seinen Initialien begrüßt.
+Lasse den Benutzer dabei diese Initialien selbst eingeben.
+**********************************************************/
diff --git a/grundelemente/03_Integer/03_Integer.cpp b/grundelemente/03_Integer/03_Integer.cpp
new file mode 100644
index 0000000..2c8e4cd
--- /dev/null
+++ b/grundelemente/03_Integer/03_Integer.cpp
@@ -0,0 +1,48 @@
+#include <iostream>
+
+int main()
+{
+  // int steht für Integer, das bedeutet Ganzzahl. Hier wird sie auf den Startwert 5 initialisiert.
+  int iX = 5;
+  // Man kann auch mehrere Variablen gleichzeitig deklarieren.
+  int iY, iZ;
+
+  /* Man kann int-Variablen genauso wie andere Variablen ausgeben. Dabei ist zu beachten, dass iY und iZ
+   * noch keine sinnvollen Werte haben.
+   */
+  std::cout << "Ein paar Werte: " << iX << "|" << iY << "|" << iZ << std::endl;
+
+  std::cout << "Geben sie bitte zwei Zahlen ein, bestätigen mit <Enter>" << std::endl;
+  
+  // Auch die Eingabe funktioniert bei ints wie bei chars, nur dass manjetzt Zahlen eingeben muss.
+  std::cin >> iY; std::cin >> iZ;
+  
+  // Man kann in C++ sehr einfach rechnen, hier wird iX auf das Produkt von iY und iZ gesetzt.
+  iX = iY * iZ;
+  
+  std::cout << "Das Produkt der Zahlen: " << iX << std::endl << "Die Summe der Zahlen: " << iY + iZ << std::endl;
+  
+  return 0;
+}
+
+/*
+ * Einige Grundrechenarten:
+ * iX = iY + iX; // Addition
+ * iX = iY - iX; // Subtraktion
+ * iX = iY * iZ; // Multiplikation
+ * iX = iY / iZ; // Division (bei ints wird hierbei immer abgerundet)
+ * iX = iY % iZ; // Modulo (Rest der Division, Berechnung wie der Rest einer Division in der Grundschule)
+ * iX += 5;      // Addition mit Zuweisung (iX wird um 5 erhöht)
+ * iX -= iY;     // Subtraktion mit Zuweisung (iX wird um iY erniedrigt)
+ * iX++;         // Inkrementierung (Addition von 1)
+ * iY--;         // Dekrementierung (Subtraktion von 1)
+ */
+
+/********************AUFGABE:**********************
+Probiere die im Kommentar aufgeführten Grundrechenarten aus,
+und verstehe ihre Wirkung (% ist nicht immer gleich verständlich).
+Programmiere dann einen einfachen Taschenrechner,
+der zu zwei eingegebenen Zahlen automatisch
+die 4 Grundrechenarten anwendet,
+und alle Ergebnisse ausgibt.
+**************************************************/
diff --git a/grundelemente/04_Kontrollstrukturen/04_Kontrollstrukturen.cpp b/grundelemente/04_Kontrollstrukturen/04_Kontrollstrukturen.cpp
new file mode 100644
index 0000000..6986f0c
--- /dev/null
+++ b/grundelemente/04_Kontrollstrukturen/04_Kontrollstrukturen.cpp
@@ -0,0 +1,64 @@
+#include <iostream>
+
+int main()
+{
+  int iX;
+  
+  std::cout << "Geben sie eine Zahl ein!" << std::endl;
+  std::cin >> iX;
+  
+  /* if bedeutet "wenn", der nachfolgende Block wird nur ausgeführt, wenn die Bedingung wahr ist.
+   * Die Bedinung ist, dass iX 0 ist; zum Vergleich wird == benutzt, da = ja schon der Zuweisungsoperator ist.
+   */
+  if(iX == 0)
+  {
+    std::cout << "iX ist 0!" << std::endl;
+  }
+  /* else heißt "sonst" und darf nur nach einem if-Block stehen. Er wird ausgeführt, wenn der if-Block
+   * nicht ausgeführt wird.
+   */
+  else if(iX > 0)
+  {
+    std::cout << "iX ist nicht 0!" << std::endl;
+  }
+  
+  return 0;
+}
+
+/*************Weitere Informationen:********
+ * Es gibt Variablen vom Typ bool,
+ * sie speichern die Werte true oder false,
+ * die unserem Wahr oder Falsch entsprechen.
+ * bool a = true; ist ein Beispiel dafür.
+
+ * Bei einer if-Abfrage gibt es folgende Operatoren:
+ * ==   Gleich
+ * !=   Ungleich
+ * >    Größer
+ * <    Kleiner
+ * >=   Größergleich
+ * <=	Kleinergleich
+ * !    Nicht
+ * ()   In Abfragen wie in Rechnungen kann man Klammern benutzen, um Zusammenhänge darzustellen.
+ * &&   Und
+ * ||   Oder
+ * 
+ * Beispiele:
+ * a == b                ist a gleich b?
+ * a != b                ist a ungleich b?
+ * (a == b) || (a == c)  ist a gleich b oder a gleich c?
+ *******************************************/
+
+/*****************AUFGABE:******************
+Benutze die if-Abfragen,
+um eine verbesserte Version des Taschenrechners zu schreiben,
+bei der es möglich ist, die Grundrechenart für die Berechnung
+selbst auszuwählen.
+
+Stelle fest, wie die Variablen gesetzt sein müssen, damit die Abfrage true ist:
+int a,b,c;
+bool x,y,z;
+if(!(a > (b + c) || a < (b + c)) && (x || !(y != z)))
+
+Vereinfache diese Anweisung ;)
+*******************************************/
diff --git a/grundelemente/05_Switch/05_Switch.cpp b/grundelemente/05_Switch/05_Switch.cpp
new file mode 100644
index 0000000..0884955
--- /dev/null
+++ b/grundelemente/05_Switch/05_Switch.cpp
@@ -0,0 +1,42 @@
+#include <iostream>
+
+int main()
+{
+  int iX = 0;
+  
+  std::cout << "Geben sie eine Zahl ein." << std::endl;
+  std::cin >> iX;
+  
+  // switch ist eine Art Mehrfach-if, das einen Ausdruck (hier die Variable iX) auf mehrere Werte überprüft.
+  switch(iX)
+  {
+    case 0:
+      std::cout << "Nichts kannst du dir doch selbst merken ;)" << std::endl;
+      break;
+    case 1:
+      std::cout << "Hagga !" << std::endl;
+    case 2:
+      std::cout << "Hast du 1 oder 2 eingegeben?" << std::endl;
+      break;
+    case 5:
+      std::cout << "Ein echter discordier ;)" << std::endl;
+      break;
+    default:
+      std::cout << "Was, denkst du, sollte hier stehen?" << std::endl;
+  }
+  
+  return 0;
+}
+
+/***************AUFGABE:****************
+Verstehe die Funktionsweise der switch-Anweisung,
+und stelle fest, was das fehlende break; nach case 1: bewirkt.
+
+Vieleicht magst du auch den Taschenrechner auf ein schöneres Menü umbauen,
+bei dem du nun mithilfe von switch entscheidungen fällst.
+Dazu kann der Benutzer einen char eingeben,
+Bedenke beim überprüfen aber, dass chars z. B. so abgefragt werden,
+wenn du ein Zeichen meinst:
+char c = 'a';
+if(c == 'b')
+***************************************/
diff --git a/grundelemente/06_Schleifen/06_Schleifen.cpp b/grundelemente/06_Schleifen/06_Schleifen.cpp
new file mode 100644
index 0000000..553f861
--- /dev/null
+++ b/grundelemente/06_Schleifen/06_Schleifen.cpp
@@ -0,0 +1,38 @@
+#include <iostream>
+
+int main()
+{
+  int iX, iY;
+  iX = 0;
+  
+  /* Dies ist eine einfache while-Schleife. Sie wird so lange ausgeführt, wie die Bedingung wahr ist,
+   * in diesem Fall also solange iX ungleich 5 ist.
+   */
+  while(iX != 5)
+  {
+    std::cout << "Geben sie eine diskordische Zahl ein!" << std::endl;
+    std::cin >> iX;
+  }
+  
+  /* Nun die for-Schleife. Sie folgt folgendem Schema:
+   * for(Variable; Bedingung; Inkrementor)
+   * Am Anfang wird einmal der Befehl <Variable> ausgeführt, nach jedem Durchlauf wird einmal <Inkrementor>
+   * ausgeführt, und die Schleife läuft, solange die Bedinung wahr ist.
+   */
+  for(int i = 0; i < 25; i++)
+  {
+    std::cout << "iX * " << i << ": " << i * iX << std::endl;
+  }
+  
+  return 0;
+}
+
+/***************AUFGABE:*******************
+ * Erstelle ein Programm, das mit Hilfe einer
+ * Funktion eine beliebige Potenz einer Zahl berechnen kann.
+ * Baue diese Funktion in einen Taschenrechner ein,
+ * der sich nur beendet, wenn der Benutzer es wünscht,
+ * sodass mehrere Rechnungen hintereinander möglich sind.
+ * 
+ * Dies ist der letzte Taschenrechner, versprochen ;)
+******************************************/
diff --git a/grundelemente/07_Funktionen/07_Funktionen.cpp b/grundelemente/07_Funktionen/07_Funktionen.cpp
new file mode 100644
index 0000000..fbd1e34
--- /dev/null
+++ b/grundelemente/07_Funktionen/07_Funktionen.cpp
@@ -0,0 +1,32 @@
+#include <iostream>
+
+// In diesem Programm werden erstmal eigene Funktionen benutzt.
+
+/* Der Name unserer ersten Funktion ist summe.
+ * int ist dabei der Rückgabewert, d. h., beim Aufruf der Funktion gibt die Funktion eine Ganzzahl
+ * an den Aufrufer zurück. iX und iY ist Parameter, d. h., dies sind Variablen, die vom Aufrufer
+ * übergeben werden.
+ */
+int summe(int iX, int iY)
+{
+  // Hier wird die Summe von iX und iY zurückgegeben.
+  return iX + iY;
+}
+
+int main()
+{
+  int x,y;
+  
+  std::cout << "Geben sie bitte zwei Zahlen ein." << std::endl;
+  std::cin >> x;
+  std::cin >> y;
+  std::cout << "Die Summe ihrer Zahlen ist: " << summe(x, y) << std::endl;
+  
+  return 0;
+}
+
+/**************AUFGABE:*************
+ * Erstelle ein Programm, das mit Hilfe einer
+ * Funktion überprüft, ob eine Zahl ohne Rest
+ * durch 2 teilbar ist.
+***********************************/
diff --git a/grundelemente/08_Arrays/08_Arrays.cpp b/grundelemente/08_Arrays/08_Arrays.cpp
new file mode 100644
index 0000000..c28c1ff
--- /dev/null
+++ b/grundelemente/08_Arrays/08_Arrays.cpp
@@ -0,0 +1,50 @@
+#include <iostream>
+
+int main()
+{
+  /* Ein Array ist eine Variable, die nicht nur einen Wert, sondern mehrere speichern kann.
+   * Man kann sich ein Array als eine Art Regal mit einer bestimmten Anzahl von Fächern vorstellen.
+   * Hier wird ein Array vom Typ int mit 5 Fächern deklariert, d. h., er kann 5 Ganzzahlen speichern.
+   */
+  int iX[5];
+  
+  /* Arrays können wie andere Variablen angesprochen werden, nur dass man nach dem Namen immer noch
+   * den Index des anzusprechenden Feldes in [] schreibt, also z. B.:
+   * iX[2] = 4;
+   * std::cout << iX[2];
+   * Die Indizes beginnen mit 0, d. h., hier wären die 5 Felder mit den Zahlen 0 bis 4, also iX[0] bis iX[4]
+   * bezeichnet.
+   *
+   * Eine besonders mächtige Eigenschaft von Arrays ist es,
+   * dass man beim Zugriff Variablen als Index benutzen kann,
+   * und so z. B. mit for-Schleifen ganze Array verarbeiten kann.
+   *
+   * Arrays können auch mehrere Dimensionen haben:
+   * int iY[5][5]; deklariert ein Array mit 5 * 5 Feldern.
+   */
+  
+  std::cout << "Geben sie bitte einen Wert ein." << std::endl;
+  int a = 0;
+  std::cin >> a;
+  
+  // Füllen des Arrays
+  for(int i = 0; i < 5; i++)
+    iX[i] = a + i;
+  
+  // Ausgabe des Arrays
+  for(int i = 0; i < 5; i++)
+    std::cout << iX[i] << std::endl;
+  
+  return 0;
+}
+
+/**************AUFGABE:********************
+ * Erstelle ein Tic-Tac-Toe-Spiel
+ * und benutze ein Array für dein Spielfeld.
+ * Versuche zuerst, ein Spielfeld mit Testwerten auszugeben.
+ * Danach baue die möglichkeit ein, Felder zu besetzen.
+ * Zum Schluss kannst du eine Gewinnüberprüfung einbauen,
+ * sodass 2 Spieler an der Konsole gegeneinander spielen können.
+ * Ob und wie du Funktionen und andere Elemente sinnvoll benutzt,
+ * findest du im Weiterem besser selbst heraus.
+******************************************/
diff --git a/grundelemente/09_Strings/09_Strings.cpp b/grundelemente/09_Strings/09_Strings.cpp
new file mode 100644
index 0000000..9596fb8
--- /dev/null
+++ b/grundelemente/09_Strings/09_Strings.cpp
@@ -0,0 +1,41 @@
+#include <iostream>
+// Jetzt müssen wir auch die Datei string einbinden, da wir den String nutzen wollen
+#include <string>
+
+
+int main() {
+  // Strings sind Zeichenketten, also Texte
+  std::string s;
+  
+  // Mit Klammern kann man sie mit einem Text initialisieren
+  std::string s2("Text");
+  
+  // Ausgabe
+  std::cout << s2 << std::endl;
+  
+  // Eingabe
+  std::cout << "Gib einen Text ein." << std::endl;
+  std::cin >> s;
+  
+  std::cout << "Das war dein Text: " << s << std::endl;
+  
+  // Man kann wie in Arrays auf einzelne Buchstaben zugreifen:
+  std::cout << "1. Buchstabe: " << s[0] << std::endl;
+  
+  /* Man darf dabeinatürlich nicht über das Ende des Strings hinaus, daher kann man die Länge
+   * mit der length()-Methode bestimmen
+   */
+  std::cout << "Dein Text ist so lang: " << s.length() << std::endl;
+  
+  // Hier wird ein Buchstabe geändert
+  s2[2] = 's';
+  std::cout << s2 << std::endl;
+  
+  // Und hier einer angefügt
+  s2 += "s";
+  std::cout << s2 << std::endl;
+}
+
+/* Aufgabe:
+ * Schreibe ein Programm, das Strings verwendet!
+ */
diff --git a/grundelemente/10_Klassen/10_Klassen.cpp b/grundelemente/10_Klassen/10_Klassen.cpp
new file mode 100644
index 0000000..6aba0f1
--- /dev/null
+++ b/grundelemente/10_Klassen/10_Klassen.cpp
@@ -0,0 +1,84 @@
+#include <iostream>
+#include <string>
+
+
+/* Im letzten Teil haben wir std::string kennengelernt. Dieser Typ ist eine sogenannte Klasse. In diesem Teil lernen
+ * wir nun, wie wir selbst solche Typen definieren.
+ */
+
+// Wir wollen nun eine Klasse erstellen, die einen Eintrag einer Personen-Kartei darstellt
+
+// Person ist der Name des Typs
+class Person {
+  // Hier stehen Einträge, die nur innerhalb der Klasse verfügbar sind
+  private:
+    // Man kann in einer Klasse sowohl Variablen, als auch Funktionen, sogenannte Methoden, definieren
+    std::string name;
+    int alter;
+    
+  // Dies sind Einträge, die von außen aufrufbar sind
+  public:
+    /* Dies sind sogenannte Konstruktoren, sie haben keinen Rückgabewert und den gleichen Namen wie die Klasse;
+     * sie werden beim erstellen einer neuen Variable vom Typ der Klasse benutzt
+     */
+    Person();
+    Person(std::string n, int a);
+    
+    void printName();
+    void setName(std::string n);
+    
+    void printAlter();
+    void setAlter(int a);
+};
+
+/* Außerhalb der Klasse werden die Methoden dann mit Inhalt gefüllt; mit :: beschreibt man, zu welcher Klasse
+ * die Methoden gehören. Die Variablen der Klasse können dabei genauso benutzt werden wie die Variablen der Funktion
+ */
+Person::Person() {
+  name = "Unbekannt";
+  // -1 bedeutet bei uns jetzt, dass wir das Alter nicht wissen
+  alter = -1;
+}
+
+Person::Person(std::string n, int a) {
+  name = n;
+  alter = a;
+}
+
+void Person::printName() {
+  std::cout << "Der Name ist: " << name << std::endl;
+}
+
+void Person::setName(std::string n) {
+  name = n;
+}
+
+void Person::printAlter() {
+  if(alter < 0) std::cout << "Das Alter ist unbekannt." << std::endl;
+  else std::cout << "Das Alter ist: " << alter << std::endl;
+}
+
+void Person::setAlter(int a) {
+  alter = a;
+}
+
+int main() {
+  // Hier wird der Konstruktor Person() benutzt
+  Person p;
+  
+  // Hier wird der Konstruktor Person(std::string n, int a) benutzt
+  Person p2("Hans", 20);
+  
+  p.printName();
+  p.printAlter();
+  
+  p2.printName();
+  p2.printAlter();
+  
+  p.setName(std::string("Horst"));
+  p.setAlter(19);
+  p.printName();
+  p.printAlter();
+  
+  return 0;
+}
diff --git a/grundelemente/info.txt b/grundelemente/info.txt
new file mode 100644
index 0000000..c5107ed
--- /dev/null
+++ b/grundelemente/info.txt
@@ -0,0 +1,28 @@
+Wenn eine Übung zum lernen benutzt wurde, sollte eine Musterlösung eingefügt werden,
+	im Unterverzeichniss example
+
+In diesem Bereich werden folgende Befehle behandelt:	Im Verzeichnis:		Fertiggestellt:
+1.:Grundgerüst eines Programms im Verzeichniss:		helloWorld		Fertig, aber noch nicht zum lernen benutzt.
+2.:Ein und Ausgabe für Console				console			Fertig, aber noch nicht zum lernen benutzt.
+3.:Benutzen von Ganzzahlen und Grundrechenarten:	integer			Fertig, aber noch nicht zum lernen benutzt.
+4.:Die If-Anweisung					if			Fertig, aber noch nicht zum lernen benutzt.
+5.:Dies switch-Anweisung				switch			Fertig, aber noch nicht zum lernen benutzt.
+6.:Funktionen						function		Fertig, aber noch nicht zum lernen benutzt.
+7.:Schleifen						loops			Fertig, aber noch nicht zum lernen benutzt.
+8.:Arrays						array			Fertig, aber noch nicht zum lernen benutzt.
+
+Wichtig:
+# Was ist C++ ?, Linker Compiler,etc.
+# Variablen
+# Arrays
+# XXO, Vier Gewinnt
+# Klassen und OoP
+# Knobeln / Schiffeversenken
+# Zeiger
+# Verkettete Listen
+# Adressbuch-Programm mit verketteter Liste
+# Dateien speichern/lesen
+# Adressbuchprogramm mit speichern
+# Vererbung
+# Templates
+# Eigene Projekte / Gui ?