Initialer Import.HEADmaster

10 files changed, 775 insertions, 0 deletions

diff --git a/contents/wissen/cpp-tutorial/01-helloworld.php b/contents/wissen/cpp-tutorial/01-helloworld.php
new file mode 100644
index 0000000..3755d94
--- /dev/null
+++ b/contents/wissen/cpp-tutorial/01-helloworld.php
@@ -0,0 +1,53 @@
+<?php
+	$author = 'Jakob und Matthias';
+	$pathToRoot = '../../../';
+?>
+<?php
+	include($pathToRoot . 'includes/firstinclude.inc.php');
+	include($pathToRoot . 'includes/header.inc.php');
+	include($pathToRoot . 'includes/mainmenu.inc.php');
+	
+	include($pathToRoot . 'sidebars/wissen/cpp.inc.php');
+?>
+
+<div id="inhalt">
+	<h2>
+		1. Hello World
+	</h2>
+	<p>
+		<code style="white-space:pre">
+	// Dies ist ein Kommentar.
+	/* Dies ist auch ein Kommentar,
+	nur ist er mehrzeilig. */
+		
+#include &lt;iostream&gt;
+	
+int main()
+{
+	std::cout &lt;&lt; &quot;Hello World!&quot; &lt;&lt; std::endl;
+	return 0;
+  
+}
+	
+		</code>
+	</p>
+		<p>
+		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.
+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.
+std::cout ist der Name der Standard-Ausgabe. Mit &lt;&lt; werden Objekte an die Standardausgabe geschickt, hier z. B.der Text &quot;Hello World!&quot;. Texte, die keine Programmbefehle sind, werden in C++ im Allgemeinen mit &quot; &quot; 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.
+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.
+	</p>
+<h3>Aufgabe:</h3>
+<p>
+Erstelle selbstgeschrieben, nicht kopiert,
+ein eigenes helloWorld-Programm,
+das eine von dir festgelegte Zeichenkette ausgibt.
+</p>
+</div>
+	
+<?php
+	include($pathToRoot . 'includes/footer.inc.php');
+	include($pathToRoot . 'includes/lastinclude.inc.php');
+?>	
diff --git a/contents/wissen/cpp-tutorial/02-konsole.php b/contents/wissen/cpp-tutorial/02-konsole.php
new file mode 100644
index 0000000..4656607
--- /dev/null
+++ b/contents/wissen/cpp-tutorial/02-konsole.php
@@ -0,0 +1,59 @@
+<?php
+	$author = 'Jakob und Matthias';
+	$pathToRoot = '../../../';
+?>
+<?php
+	include($pathToRoot . 'includes/firstinclude.inc.php');
+	include($pathToRoot . 'includes/header.inc.php');
+	include($pathToRoot . 'includes/mainmenu.inc.php');
+	
+	include($pathToRoot . 'sidebars/wissen/cpp.inc.php');
+?>
+
+<div id="inhalt">
+	<h2>
+		2. Konsole
+	</h2>
+	<p>
+		<code style="white-space:pre">
+#include &lt;iostream&gt;
+	
+int main()
+{
+  char cEingabe;
+  
+  std::cout &lt;&lt; &quot;Bitte geben sie ein einzelnes Zeichen ein,&quot; &lt;&lt; std::endl;
+  std::cout &lt;&lt; gefolgt von einem Druck auf &lt;Enter&gt;&quot; &lt;&lt std::endl;
+  
+  std::cin &gt;&gt; cEingabe;
+  
+  std::cout &lt;&lt &quot;Ihre Eingabe war: &quot; &lt;&lt cEingabe &lt;&lt std::endl;
+     
+  return 0;
+}
+	
+		</code>
+	</p>
+<p>
+cEingabe 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.
+</p>
+<p>
+std::cin ist das Gegenteil von std::cout, es handelt sich um die Standardeingabe. Mit &gt;&gt; wird eine Eingabe in eine Variable eingelesen. Da cEingabe vom Typ char ist, muss ein einzelner Buchstabe eingeben werden.
+</p>
+<p>
+Wie man sieht, kann man mit std::cout auch Variableninhalte ausgeben. Dabei wird der Variablenname nicht in &quot; &quot; geschrieben, sonst würde ja nur der Name der Variable als Text und nicht der Inhalt der Variable ausgegeben werden.
+</p>
+
+<h3>Aufgabe:</h3>
+<p>
+Erstelle ein Programm, das den Benutzer mit seinen Initialien begrüßt.
+Lasse den Benutzer dabei diese Initialien selbst eingeben.
+</p>
+</div>
+	
+<?php
+	include($pathToRoot . 'includes/footer.inc.php');
+	include($pathToRoot . 'includes/lastinclude.inc.php');
+?>	
diff --git a/contents/wissen/cpp-tutorial/03-integer.php b/contents/wissen/cpp-tutorial/03-integer.php
new file mode 100644
index 0000000..ff23570
--- /dev/null
+++ b/contents/wissen/cpp-tutorial/03-integer.php
@@ -0,0 +1,79 @@
+<?php
+	$author = 'Jakob und Matthias';
+	$pathToRoot = '../../../';
+?>
+<?php
+	include($pathToRoot . 'includes/firstinclude.inc.php');
+	include($pathToRoot . 'includes/header.inc.php');
+	include($pathToRoot . 'includes/mainmenu.inc.php');
+	
+	include($pathToRoot . 'sidebars/wissen/cpp.inc.php');
+?>
+
+<div id="inhalt">
+	<h2>
+		3. Integer
+	</h2>
+	<p>
+		<code style="white-space:pre">
+#include &lt;iostream&gt;
+	
+int main()
+{
+
+  int iX = 5;
+  int iY, iZ;
+
+
+  std::cout &lt;&lt; &quot;Ein paar Werte: &quot; &lt;&lt; iX &lt;&lt; &quot;|&quot; &lt;&lt; iY &lt;&lt; &quot;|&quot; &lt;&lt; iZ &lt;&lt; std::endl;
+  std::cout &lt;&lt; &quot;Geben sie bitte zwei Zahlen ein, bestätigen mit &lt;Enter&gt;&quot; &lt;&lt; std::endl;
+  
+  std::cin &gt;&gt; iY; std::cin &gt;&gt; iZ;
+  
+  iX = iY * iZ;
+  
+  std::cout &lt;&lt; &quot;Das Produkt der Zahlen: &quot; &lt;&lt; iX &lt;&lt; std::endl;
+  std::cout &lt;&lt; &quot;Die Summe der Zahlen: &quot; &lt;&lt; iY + iZ &lt;&lt; std::endl;
+  
+  return 0;
+}
+	
+		</code>
+	</p>
+	<p>
+int steht für Integer, das bedeutet Ganzzahl. Hier wird sie auf den Startwert 5 initialisiert.		
+Man kann auch mehrere Variablen gleichzeitig deklarieren.
+Auch die Eingabe funktioniert bei ints wie bei chars, nur dass man jetzt Zahlen eingeben muss.	
+Man kann int-Variablen genauso wie andere Variablen ausgeben. Dabei ist zu beachten, dass iY und iZ noch keine sinnvollen Werte haben.	
+Man kann in C++ sehr einfach rechnen, hier wird iX auf das Produkt von iY und iZ gesetzt.
+	</p>
+	<p>
+Einige Grundrechenarten:
+	</p>
+		<table>
+<tr><td style="width:8em;">iX = iY + iX;</td><td>Addition</td></tr>
+<tr><td>iX = iY - iX;</td><td>Subtraktion</td></tr>
+<tr><td>iX = iY * iZ;</td><td>Multiplikation</td></tr>
+<tr><td>iX = iY / iZ;</td><td>Division (bei ints wird hierbei immer abgerundet)</td></tr>
+<tr><td>iX = iY % iZ;</td><td>Modulo (Rest der Division, Berechnung wie der Rest einer Division in der Grundschule)</td></tr>
+<tr><td>iX += 5;</td><td>Addition mit Zuweisung (iX wird um 5 erhöht)</td></tr>
+<tr><td>iX -= iY;</td><td>Subtraktion mit Zuweisung (iX wird um iY erniedrigt)</td></tr>
+<tr><td>iX++;</td><td>Inkrementierung (Addition von 1)</td></tr>
+<tr><td>iY--;</td><td>Dekrementierung (Subtraktion von 1)</td></tr>
+		</table>
+
+<h3>Aufgabe:</h3>
+	<p>
+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.
+	</p>
+</div>
+	
+<?php
+	include($pathToRoot . 'includes/footer.inc.php');
+	include($pathToRoot . 'includes/lastinclude.inc.php');
+?>	
diff --git a/contents/wissen/cpp-tutorial/04-kontrollstrukturen.php b/contents/wissen/cpp-tutorial/04-kontrollstrukturen.php
new file mode 100644
index 0000000..a26d85c
--- /dev/null
+++ b/contents/wissen/cpp-tutorial/04-kontrollstrukturen.php
@@ -0,0 +1,111 @@
+<?php
+	$author = 'Jakob und Matthias';
+	$pathToRoot = '../../../';
+?>
+<?php
+	include($pathToRoot . 'includes/firstinclude.inc.php');
+	include($pathToRoot . 'includes/header.inc.php');
+	include($pathToRoot . 'includes/mainmenu.inc.php');
+	
+	include($pathToRoot . 'sidebars/wissen/cpp.inc.php');
+	
+	/*$content = str_replace('/*','</code><p>',$content);*/
+?>
+
+<div id="inhalt">
+	<h2>
+		4. Kontrollstrukturen
+	</h2>
+	<p>
+		<code style="white-space:pre">
+#include &lt;iostream&gt;
+	
+int main()
+{
+  int iX;
+  
+  std::cout &lt;&lt; &quot;Geben sie eine Zahl ein!&quot; &lt;&lt; std::endl;
+  std::cin &gt;&gt; iX;
+
+  if(iX == 0)
+  {
+    std::cout &lt;&lt; &quot;iX ist 0!&quot; &lt;&lt; std::endl;
+  }
+
+
+  else if(iX &gt; 0)
+  {
+    std::cout &lt;&lt; &quot;iX ist nicht 0!&quot; &lt;&lt; std::endl;
+  }
+  
+  return 0;
+}
+	
+		</code>
+	</p>
+	<p>
+if bedeutet &quot;wenn&quot;, 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.else heißt &quot;sonst&quot; und darf nur nach einem if-Block stehen. Er wird ausgeführt, wenn der if-Block
+nicht ausgeführt wird.
+</p>
+<p>
+Weitere Informationen:
+</p>
+<p class="absatzunten">
+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.
+</p>
+<p>
+Bei einer if-Abfrage gibt es folgende Operatoren:
+</p>
+<table>
+<tr><td style="width: 3em;">==</td><td>gleich</td></tr>
+<tr><td>!=</td><td>ungleich</td></tr>
+<tr><td>&gt;</td><td>größer</td></tr>
+<tr><td>&lt;</td><td>kleiner</td></tr>
+<tr><td>&gt;=</td><td>größergleich</td></tr>
+<tr><td>&lt;=	</td><td>kleinergleich</td></tr>
+<tr><td>!</td><td>nicht</td></tr>
+<tr><td>()</td><td>In Abfragen wie in Rechnungen kann man Klammern benutzen, um Zusammenhänge darzustellen.</td></tr>
+<tr><td>&&</td><td>und</td></tr>
+<tr><td>||</td><td>oder</td></tr>
+</table>
+<p class="absatzoben">
+Beispiele:
+</p>
+<table>
+<tr><td style="width: 11em;">a == b</td><td>ist a gleich b?</td></tr>
+<tr><td>a != b</td><td>ist a ungleich b?</td></tr>
+<tr><td>(a == b) || (a == c)</td><td>ist a gleich b oder a gleich c?</td></tr>
+</table>
+
+<h3>Aufgabe:</h4>
+<p>
+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.
+</p>
+<p>
+Stelle fest, wie die Variablen gesetzt sein müssen, damit die Abfrage true ist:
+</p>
+<p>
+<code style="white-space: pre">
+	int a,b,c;
+	bool x,y,z;
+	if(!(a &gt; (b + c) || a &lt; (b + c)) && (x || !(y != z)))
+</code>
+</p>
+<p>
+Vereinfache diese Anweisung!
+</p>
+
+		</code>
+	</p>
+</div>
+	
+<?php
+	include($pathToRoot . 'includes/footer.inc.php');
+	include($pathToRoot . 'includes/lastinclude.inc.php');
+?>	
diff --git a/contents/wissen/cpp-tutorial/05-switch.php b/contents/wissen/cpp-tutorial/05-switch.php
new file mode 100644
index 0000000..89a325e
--- /dev/null
+++ b/contents/wissen/cpp-tutorial/05-switch.php
@@ -0,0 +1,76 @@
+<?php
+	$author = 'Jakob und Matthias';
+	$pathToRoot = '../../../';
+?>
+<?php
+	include($pathToRoot . 'includes/firstinclude.inc.php');
+	include($pathToRoot . 'includes/header.inc.php');
+	include($pathToRoot . 'includes/mainmenu.inc.php');
+	
+	include($pathToRoot . 'sidebars/wissen/cpp.inc.php');
+?>
+
+<div id="inhalt">
+	<h2>
+		5. Switch
+	</h2>
+	<p>
+		<code style="white-space:pre">
+#include &lt;iostream&gt;
+
+int main()
+{
+  int iX = 0;
+  
+  std::cout &lt;&lt; &quot;Geben sie eine Zahl ein.&quot; &lt;&lt; std::endl;
+  std::cin &gt;&gt; iX;
+  
+  switch(iX)
+  {
+    case 0:
+      std::cout &lt;&lt; &quot;Nichts kannst du dir doch selbst merken ;)&quot; &lt;&lt; std::endl;
+      break;
+    case 1:
+      std::cout &lt;&lt; &quot;Hagga!&quot; &lt;&lt; std::endl;
+    case 2:
+      std::cout &lt;&lt; &quot;Hast du 1 oder 2 eingegeben?&quot; &lt;&lt; std::endl;
+      break;
+    case 5:
+      std::cout &lt;&lt; &quot;Ein echter Discordier! ;)&quot; &lt;&lt; std::endl;
+      break;
+    default:
+      std::cout &lt;&lt; &quot;Was, denkst du, sollte hier stehen?&quot; &lt;&lt; std::endl;
+  }
+  
+  return 0;
+}
+	
+		</code>
+	</p>
+<p>
+switch ist eine Art Mehrfach-if, das einen Ausdruck (hier die Variable iX) auf mehrere Werte überprüft.
+</p>
+<h3>Aufgabe:</h3>
+<p>
+Verstehe die Funktionsweise der switch-Anweisung,
+und stelle fest, was das fehlende break; nach case 1: bewirkt.
+</p>
+<p>
+Vielleicht 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:
+</p>
+<p>
+<code style="white-space: pre;">
+char c = 'a';
+if(c == 'b')
+</code>
+	</p>
+</div>
+	
+<?php
+	include($pathToRoot . 'includes/footer.inc.php');
+	include($pathToRoot . 'includes/lastinclude.inc.php');
+?>	
diff --git a/contents/wissen/cpp-tutorial/06-schleifen.php b/contents/wissen/cpp-tutorial/06-schleifen.php
new file mode 100644
index 0000000..508c106
--- /dev/null
+++ b/contents/wissen/cpp-tutorial/06-schleifen.php
@@ -0,0 +1,73 @@
+<?php
+	$author = 'Jakob und Matthias';
+	$pathToRoot = '../../../';
+?>
+<?php
+	include($pathToRoot . 'includes/firstinclude.inc.php');
+	include($pathToRoot . 'includes/header.inc.php');
+	include($pathToRoot . 'includes/mainmenu.inc.php');
+	
+	include($pathToRoot . 'sidebars/wissen/cpp.inc.php');
+?>
+
+<div id="inhalt";>
+	<h2>
+		6. Schleifen
+	</h2>
+	<p>
+		<code style="white-space:pre">
+#include &lt;iostream&gt;
+	
+int main()
+{
+  int iX, iY;
+  iX = 0;
+
+  while(iX != 5)
+  {
+    std::cout &lt;&lt; &quot;Geben sie eine diskordische Zahl ein!&quot; &lt;&lt; std::endl;
+    std::cin &gt;&gt; iX;
+  }
+
+
+  for(int i = 0; i < 25; i++)
+  {
+    std::cout &lt;&lt; &quot;iX * &quot; &lt;&lt; i &lt;&lt; &quot;: &quot; &lt;&lt; i * iX &lt;&lt; std::endl;
+  }
+  
+  return 0;
+}
+	
+		</code>
+	</p>
+	<p>
+Das erste ist eine while-Schleife. Sie wird so lange ausgeführt, wie die Bedingung wahr ist,
+in diesem Fall also solange iX ungleich 5 ist.
+	</p>
+  <p>
+Die for-Schleife folgt folgendem Schema:
+	</p>
+	<p>
+for(Variable; Bedingung; Inkrementor)
+	</p>
+	<p>
+Am Anfang wird einmal der Befehl &lt;Variable&gt; ausgeführt, nach jedem Durchlauf wird einmal &lt;Inkrementor&gt;
+ausgeführt, und die Schleife läuft, solange die Bedinung wahr ist.
+	</p>
+<h3>Aufgabe:</h3>
+<p>
+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.
+</p>
+<p>
+Dies ist der letzte Taschenrechner, versprochen! ;)
+</p>
+</div>
+	
+<?php
+	include($pathToRoot . 'includes/footer.inc.php');
+	include($pathToRoot . 'includes/lastinclude.inc.php');
+?>	
diff --git a/contents/wissen/cpp-tutorial/07-funktionen.php b/contents/wissen/cpp-tutorial/07-funktionen.php
new file mode 100644
index 0000000..485e733
--- /dev/null
+++ b/contents/wissen/cpp-tutorial/07-funktionen.php
@@ -0,0 +1,61 @@
+<?php
+	$author = 'Jakob und Matthias';
+	$pathToRoot = '../../../';
+?>
+<?php
+	include($pathToRoot . 'includes/firstinclude.inc.php');
+	include($pathToRoot . 'includes/header.inc.php');
+	include($pathToRoot . 'includes/mainmenu.inc.php');
+	
+	include($pathToRoot . 'sidebars/wissen/cpp.inc.php');
+?>
+
+<div id="inhalt">
+	<h2>
+		7. Funktionen
+	</h2>
+	<p>
+		<code style="white-space:pre">
+#include &lt;iostream&gt;
+	
+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 &lt;&lt; &quot;Geben sie bitte zwei Zahlen ein.&quot; &lt;&lt; std::endl;
+  std::cin &gt;&gt; x;
+  std::cin &gt;&gt; y;
+  std::cout &lt;&lt; &quot;Die Summe ihrer Zahlen ist: &quot; &lt;&lt; summe(x, y) &lt;&lt; std::endl;
+  
+  return 0;
+}
+	
+		</code>
+	</p>
+<p>
+In diesem Programm werden erstmal eigene Funktionen benutzt.
+</p>
+<p>
+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.
+</p>
+<h3>Aufgabe:</h3>
+<p>
+Erstelle ein Programm, das mit Hilfe einer
+Funktion überprüft, ob eine Zahl ohne Rest
+durch 2 teilbar ist.
+</p>
+</div>
+	
+<?php
+	include($pathToRoot . 'includes/footer.inc.php');
+	include($pathToRoot . 'includes/lastinclude.inc.php');
+?>	
diff --git a/contents/wissen/cpp-tutorial/08-arrays.php b/contents/wissen/cpp-tutorial/08-arrays.php
new file mode 100644
index 0000000..748017d
--- /dev/null
+++ b/contents/wissen/cpp-tutorial/08-arrays.php
@@ -0,0 +1,81 @@
+<?php
+	$author = 'Jakob und Matthias';
+	$pathToRoot = '../../../';
+?>
+<?php
+	include($pathToRoot . 'includes/firstinclude.inc.php');
+	include($pathToRoot . 'includes/header.inc.php');
+	include($pathToRoot . 'includes/mainmenu.inc.php');
+	
+	include($pathToRoot . 'sidebars/wissen/cpp.inc.php');
+?>
+
+<div id="inhalt">
+	<h2>
+		8. Arrays
+	</h2>
+	<p>
+		<code style="white-space:pre">
+#include &lt;iostream&gt;
+
+int main()
+{
+	
+  int iX[5];
+  
+  std::cout &lt;&lt; &quot;Geben sie bitte einen Wert ein.&quot; &lt;&lt; std::endl;
+  int a = 0;
+  std::cin &gt;&gt; a;
+  
+  // Füllen des Arrays
+  for(int i = 0; i &lt; 5; i++)
+    iX[i] = a + i;
+  
+  // Ausgabe des Arrays
+  for(int i = 0; i &lt; 5; i++)
+    std::cout &lt;&lt; iX[i] &lt;&lt; std::endl;
+  
+  return 0;
+}
+	
+		</code>
+			</p>
+<p>
+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.
+</p>
+<p>
+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 &lt;&lt; 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.
+</p>
+<p>
+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.
+</p>
+<p>
+Arrays können auch mehrere Dimensionen haben:
+int iY[5][5]; deklariert ein Array mit 5 * 5 Feldern.
+</p>
+<h3>Aufgabe:</h3>
+	<p>
+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.
+	</p>
+</div>
+	
+<?php
+	include($pathToRoot . 'includes/footer.inc.php');
+	include($pathToRoot . 'includes/lastinclude.inc.php');
+?>	
diff --git a/contents/wissen/cpp-tutorial/09-strings.php b/contents/wissen/cpp-tutorial/09-strings.php
new file mode 100644
index 0000000..2630176
--- /dev/null
+++ b/contents/wissen/cpp-tutorial/09-strings.php
@@ -0,0 +1,67 @@
+<?php
+	$author = 'Jakob und Matthias';
+	$pathToRoot = '../../../';
+?>
+<?php
+	include($pathToRoot . 'includes/firstinclude.inc.php');
+	include($pathToRoot . 'includes/header.inc.php');
+	include($pathToRoot . 'includes/mainmenu.inc.php');
+	
+	include($pathToRoot . 'sidebars/wissen/cpp.inc.php');
+?>
+
+<div id="inhalt">
+	<h2>
+		9. Strings
+	</h2>
+	<p>
+		<code style="white-space:pre">
+#include &lt;iostream&gt;
+#include &lt;string&gt;
+	
+int main() 
+{
+  std::string s;
+  std::string s2(&quot;Text&quot;);
+  
+  // Ausgabe
+  std::cout &lt;&lt; s2 &lt;&lt; std::endl;
+  
+  // Eingabe
+  std::cout &lt;&lt; &quot;Gib einen Text ein.&quot; &lt;&lt; std::endl;
+  std::cin &gt;&gt; s;
+  
+  std::cout &lt;&lt; &quot;&quotDas war dein Text: &quot; &lt;&lt; s &lt;&lt; std::endl;
+  
+  std::cout &lr;&lt; &quot;1. Buchstabe: &quot; &lt;&lt; s[0] &lt;&lt; std::endl;
+
+  std::cout &lt;&lt; &quot;Dein Text ist so lang: &quot; &lt;&lt; s.length() &lt;&lt; std::endl;
+  
+  // Hier wird ein Buchstabe geändert
+  s2[2] = 's';
+  std::cout &lt;&lt; s2 &lt;&lt; std::endl;
+  
+  // Und hier einer angefügt
+  s2 += &quot;s&quot;;
+  std::cout &lt;&lt; s2 &lt;&lt; std::endl;
+}
+	
+		</code>
+	</p>
+	<p>
+		Jetzt müssen wir neben iostream auch die Datei string einbinden, da wir den String nutzen wollen.
+	</p>
+	<p>
+		Mit Klammern kann man sie mit einem Text initialisieren. Man kann wie in Arrays auf einzelne Buchstaben zugreifen.
+		Man darf dabei natürlich nicht über das Ende des Strings hinaus, daher kann man die Länge mit der length()-Methode bestimmen
+	</p>
+<h3>Aufgabe:</h3>
+	<p>
+Schreibe ein Programm, das Strings verwendet!
+	</p>
+</div>
+	
+<?php
+	include($pathToRoot . 'includes/footer.inc.php');
+	include($pathToRoot . 'includes/lastinclude.inc.php');
+?>	
diff --git a/contents/wissen/cpp-tutorial/10-klassen.php b/contents/wissen/cpp-tutorial/10-klassen.php
new file mode 100644
index 0000000..96905c7
--- /dev/null
+++ b/contents/wissen/cpp-tutorial/10-klassen.php
@@ -0,0 +1,115 @@
+<?php
+	$author = 'Jakob und Matthias';
+	$pathToRoot = '../../../';
+?>
+<?php
+	include($pathToRoot . 'includes/firstinclude.inc.php');
+	include($pathToRoot . 'includes/header.inc.php');
+	include($pathToRoot . 'includes/mainmenu.inc.php');
+	
+	include($pathToRoot . 'sidebars/wissen/cpp.inc.php');
+?>
+
+<div id="inhalt">
+	<h2>
+		10. Klassen
+	</h2>
+	<p>
+		<code style="white-space:pre">
+#include &lt;iostream&gt;
+#include &lt;string&gt;
+	
+class Person
+{
+  private:
+    std::string name;
+    int alter;
+    
+  public:
+    /* Dies sind sogenannte Kontruktoren,
+     * 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);
+};
+	
+Person::Person() {
+  name = &quot;Unbekannt&quot;;
+  // -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 &lt;&lt; &quot;Der Name ist: &quot; &lt;&lt; name &lt;&lt; std::endl;
+}
+	
+void Person::setName(std::string n) {
+  name = n;
+}
+	
+void Person::printAlter() {
+  if(alter &lt; 0) std::cout &lt;&lt; &quot;Das Alter ist unbekannt.&quot; &lt;&lt; std::endl;
+  else std::cout &lt;&lt; &quot;Das Alter ist: &quot; &lt;&lt; alter &lt;&lt; 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(&quot;Hans&quot;, 20);
+  	
+  p.printName();
+  p.printAlter();
+  	
+  p2.printName();
+  p2.printAlter();
+  	
+  p.setName(std::string(&quot;Horst&quot;));
+  p.setAlter(19);
+  p.printName();
+  p.printAlter();
+  
+  return 0;
+}
+	
+		</code>
+	</p>
+	
+	<p>
+		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.
+	</p>
+	<p>
+		Wir wollen also eine Klasse erstellen, die einen Eintrag einer Personen-Kartei darstellt.
+	</p>
+	<p>
+ 		Der Name des neuen Typs steht hinter class, in diesem Fall Person.
+	</p>
+	<p>
+	  Unter private stehen Einträge, die nur innerhalb der Klasse verfügbar sind, unter public stehen solche, die auch von außen aus aufrufbar sind. Man kann in einer Klasse sowohl Variablen, als auch Funktionen, sogenannte Methoden, definieren
+	</p>
+	<p>
+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.
+	</p>
+</div>
+	
+<?php
+	include($pathToRoot . 'includes/footer.inc.php');
+	include($pathToRoot . 'includes/lastinclude.inc.php');
+?>