Initialer ImportHEADmaster

7 files changed, 163 insertions, 0 deletions

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;
+}