summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorMatthias Schiffer <matthias@gamezock.de>2008-09-16 17:01:28 +0200
committerMatthias Schiffer <matthias@gamezock.de>2008-09-16 17:01:28 +0200
commitd0668d3cd77ad617c83f6c2f124d84417285766b (patch)
tree9fad24568d43505120df46a297e0b352d836acc0
downloadc++-tutorial-d0668d3cd77ad617c83f6c2f124d84417285766b.tar
c++-tutorial-d0668d3cd77ad617c83f6c2f124d84417285766b.zip
Initialer ImportHEADmaster
-rw-r--r--README.txt12
-rw-r--r--fortgeschritten/01_Klassen/01_Klassen.cpp23
-rw-r--r--fortgeschritten/01_Klassen/Makefile2
-rw-r--r--fortgeschritten/01_Klassen/Person.cpp32
-rw-r--r--fortgeschritten/01_Klassen/Person.h38
-rw-r--r--fortgeschritten/01_Klassen/README3
-rw-r--r--fortgeschritten/02_Zeiger/02_Zeiger.cpp33
-rw-r--r--fortgeschritten/03_Zeiger_als_Parameter/03_Zeiger_als_Parameter.cpp32
-rw-r--r--grundelemente/01_Hello_World/01_Hello_World.cpp32
-rw-r--r--grundelemente/02_Konsole/02_Konsole.cpp31
-rw-r--r--grundelemente/03_Integer/03_Integer.cpp48
-rw-r--r--grundelemente/04_Kontrollstrukturen/04_Kontrollstrukturen.cpp64
-rw-r--r--grundelemente/05_Switch/05_Switch.cpp42
-rw-r--r--grundelemente/06_Schleifen/06_Schleifen.cpp38
-rw-r--r--grundelemente/07_Funktionen/07_Funktionen.cpp32
-rw-r--r--grundelemente/08_Arrays/08_Arrays.cpp50
-rw-r--r--grundelemente/09_Strings/09_Strings.cpp41
-rw-r--r--grundelemente/10_Klassen/10_Klassen.cpp84
-rw-r--r--grundelemente/info.txt28
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 ?