From d0668d3cd77ad617c83f6c2f124d84417285766b Mon Sep 17 00:00:00 2001 From: Matthias Schiffer Date: Tue, 16 Sep 2008 17:01:28 +0200 Subject: Initialer Import --- README.txt | 12 ++++ fortgeschritten/01_Klassen/01_Klassen.cpp | 23 ++++++ fortgeschritten/01_Klassen/Makefile | 2 + fortgeschritten/01_Klassen/Person.cpp | 32 +++++++++ fortgeschritten/01_Klassen/Person.h | 38 ++++++++++ fortgeschritten/01_Klassen/README | 3 + fortgeschritten/02_Zeiger/02_Zeiger.cpp | 33 +++++++++ .../03_Zeiger_als_Parameter.cpp | 32 +++++++++ grundelemente/01_Hello_World/01_Hello_World.cpp | 32 +++++++++ grundelemente/02_Konsole/02_Konsole.cpp | 31 ++++++++ grundelemente/03_Integer/03_Integer.cpp | 48 +++++++++++++ .../04_Kontrollstrukturen.cpp | 64 +++++++++++++++++ grundelemente/05_Switch/05_Switch.cpp | 42 +++++++++++ grundelemente/06_Schleifen/06_Schleifen.cpp | 38 ++++++++++ grundelemente/07_Funktionen/07_Funktionen.cpp | 32 +++++++++ grundelemente/08_Arrays/08_Arrays.cpp | 50 +++++++++++++ grundelemente/09_Strings/09_Strings.cpp | 41 +++++++++++ grundelemente/10_Klassen/10_Klassen.cpp | 84 ++++++++++++++++++++++ grundelemente/info.txt | 28 ++++++++ 19 files changed, 665 insertions(+) create mode 100644 README.txt create mode 100644 fortgeschritten/01_Klassen/01_Klassen.cpp create mode 100644 fortgeschritten/01_Klassen/Makefile create mode 100644 fortgeschritten/01_Klassen/Person.cpp create mode 100644 fortgeschritten/01_Klassen/Person.h create mode 100644 fortgeschritten/01_Klassen/README create mode 100644 fortgeschritten/02_Zeiger/02_Zeiger.cpp create mode 100644 fortgeschritten/03_Zeiger_als_Parameter/03_Zeiger_als_Parameter.cpp create mode 100644 grundelemente/01_Hello_World/01_Hello_World.cpp create mode 100644 grundelemente/02_Konsole/02_Konsole.cpp create mode 100644 grundelemente/03_Integer/03_Integer.cpp create mode 100644 grundelemente/04_Kontrollstrukturen/04_Kontrollstrukturen.cpp create mode 100644 grundelemente/05_Switch/05_Switch.cpp create mode 100644 grundelemente/06_Schleifen/06_Schleifen.cpp create mode 100644 grundelemente/07_Funktionen/07_Funktionen.cpp create mode 100644 grundelemente/08_Arrays/08_Arrays.cpp create mode 100644 grundelemente/09_Strings/09_Strings.cpp create mode 100644 grundelemente/10_Klassen/10_Klassen.cpp create mode 100644 grundelemente/info.txt 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 +#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 + + +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 + + +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 + + +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 + + +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 + +/* 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 + +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 " << 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 + +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 " << 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 + +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 + +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 + +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 ausgeführt, nach jedem Durchlauf wird einmal + * 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 + +// 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 + +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 +// Jetzt müssen wir auch die Datei string einbinden, da wir den String nutzen wollen +#include + + +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 +#include + + +/* 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 ? -- cgit v1.2.3