Das klingt jetzt ein bisschen blöd, weil ich diese Methode hier ja fördere, aber meiner Meinung nach, kann man sich C/C++ nicht wirklich gut selber beibringen, wie z.B. von zu Hause übers Internet. So wie das bei PHP zum Beispiel einfacher möglich ist.
Ich selbst habe es in der Schule gelernt. Auch mit der ganzen Theorie. Struktogramme, Sequenzdiagramme, Zustandsdiagramme, usw. All das hat dazu gehört, ist aber weniger wichtig. Wichtig ist, denke ich, das Hintergrundverständis "Was läuft da eigentlich ab, wenn ich xyz mache?". Wenn man versteht, was C/C++ eigentlich macht, wie ein Compiler, Linker usw. arbeitet, dann kann man sagen, dass man C/C++ programmiert. Wenn man richtig einrückt, sauber schreibt und ein paar kleine Regeln einhält.
Am schlimmsten sind diese schlampigen "Hacker"-Codes (Hacker hier nicht im Sinne von Verbrechner ). Also haltet euch ein diese wenigen Regeln, die folgen werden, und ihr werdet vielleicht etwas erfolgreicher beim Programmieren!
Regeln
Nun ja, wozu Regeln? Ganz klar: Wenn man irgendwann mal komplexere Programme schreibt, oder sogar in die Spieleentwicklung geht - sei es kommerziell oder privat - dann ist Teamarbeit angesagt. Man kann kein Spiel wie Gothic 3 im 1-Mann-Projekt durchziehen. Da muss die Arbeit aufgeteilt werden ... Engine, 3D Grafik, logische Abläufe im Spiel ... Aber von Spieleprogrammierung möchte ich jetzt garnicht weiter reden, da das sowieso mehr als Programmierung erfordert!
Also hier nun ein paar Regeln:
* Einrücken
* Benennung der Dinge
* Sprache
* Kommentare
Einrücken: Rückt nach einer geschweiften Klammer immer 3 oder 4 Leerzeichen vor, damit man den Quelltext später noch gut lesen kann, und selber auch nach einem Monat noch versteht. Auch anderen Programmierern, sei es im Team oder Leute, die einem helfen sollen, fällt es so einfacher, das Programm zu verstehen!
Benennung der Dinge: Benennt die Variablen, Klassen usw. immer nach dem, was sie tun oder was sie sind. Benennt zum Beispiel keinen Integer "Integer1, Integer2, Integer3" usw.
Sprache: Einigt euch selbst auf eine Sprache! Wenn ihr die Bennenung der Dinge und die Sprache einhaltet, dann werdet ihr euer Programm später wie ein Buch lesen können. Ich bevorzuge Deutsch, da ich alleine programmiere und die Groß- und Kleinschreibung auch einiges an Übersicht schafft.
Kommentare: Sind nicht unbedingt erforderlich. Aber, wenn ihr mal ein Programm schreibt, das euch Schwierigkeiten bereitet hat, dann solltet ihr den Teil, den ihr vielleicht nicht auf Anhieb wieder verstehen werdet, kommentieren.
So, ihr werdet auch in meinen weiteren Tutorials sehen, was genau ich damit meine. Wenn euch das gefällt, dann werde ich mehr Tutorials schreiben, tiefer auf Dinge eingehen und euch noch ein paar nette Dinge zeigen. Wichtig ist Geduld. Ihr könnt es auf jeden Fall vergessen, wenn ihr noch nie zuvor Programmiert habt, dass ihr in 2 Wochen auf dem Stand seid, dass ihr euer eigenes 3D-Spiel programmiert. Aber wie ihr Ping Pong programmiert, kann ich euch auf jeden Fall demnächst zeigen. Und Bewertungen geben mir dementsprechend ein Feedback, ob es Anklang findet
Nun zur Sache...
Programm
Damit sich das ganze hier nicht - wie jedes andere Einsteiger Tutorial - mit der einfachen Textausgabe beschäftigt, erweitere ich es noch um ein paar Kleinigkeiten, nicht viel, aber etwas
Um einen lauffähigen Compiler müsst ihr euch leider selbst kümmern. Ich programmiere mit dem Borland C++ Builder 5. In diesem Tutoria dürfte das keine Rolle spielen. Hauptsache ihr habt einen lauffähigen Compiler.
Also los gehts: Grundgerüst ist für uns erstmal die main() Funktion. Ich weiß, ich habe gesagt, dass ich mich für die deutsche Sprache entschieden hab. Bei dieser Funktion mache ich jedoch eine Ausnahme, ich glaube, man muss sie sogar so nennen, da sie die Hauptfunktion ist und sie demnach aufgerufen wird.
Code:
void main() { }
So siehts aus! Die Funktion ist vom Typ void, das bedeutet, sie hat keinen Rückgabewert. Wäre sie z.B. vom Typ Integer (int main()), dann müsste man einen Integerwert zurück geben mit z.B. return 0. Da wir aber keinen Rückgabewert brauchen, weil wir keine Verwendung für ihn hätten, lassen wir es erst mal so.
Durchcompiliert macht das Programm noch garnichts. Es beendet sich auch am Ende wieder. Das wollen wir natürlich nicht, deshalb fügen wir noch die Funktion getch() ("Get Charakter") hinzu. Diese wartet auf einen Tastendruck vom Benutzer. Um diese Funktion zu benutzen müssen wir die Bibliothek conio.h einbinden. Am besten binden wir sie am Anfang des Programms ein, dann kennt alles darunter die Funktion. Bibliotheken werden eingebunden mit #include, Bibliotheken des Compilers stehen in einer spitzen Klammer (#include <conio.h>), eigene Dateien, die man einbinden, werden mit Einführungsstrichen eingebunden (#include "EigeneCPPDatei.cpp"). So wird sie aus dem Pfad der .exe Datei eingefüht. Bei eigenen Dateien müsst ihr also ggf. den entsprechenden Pfad angeben. Der Includebefehl wird nicht mit einem Strichpunkt beendet, da dieser eine Compileranweisung ist und kein C++ Befehl. Der Compiler fügt an dieser Stelle einfach nur den Quelltext der eingefügten Header(*.h)- / C++ Datei ein. Damit entwickelt sich noch ein Problem, auf das ich in einem eigenen Tutorial noch beschreiben werde. Hier wird es noch keine Probleme geben.
Der getch() Befehl muss innerhalb der main() Funktion aufgerufen werden. Außerhalb hat er keinerleis Auswirkung. Außerhalb sind demnach nur Funktionsdeklarationen und ausprogrammierte Funktionen.
An dieser Stelle muss ich noch erklären, was eine Deklaration ist. Eine Deklaration ist das alleinige "in's Leben rufen" einer Funktion oder Variable, ohne Zuweisung von Werten oder Inhalt. So wie z.B. int Wert;. Der Integer "Wert" hat jetzt theoretisch keinen Inhalt. Er wird jedoch irgendeinen wirren Inhalt aus dem Speicher haben, wenn man ihn nun aufruft.
Code:
#include <conio.h> void main() { getch(); }
So, jetzt sollte das Programm noch irgendetwas machen! Also als bestes Beispiel ist eine Ein-/Ausgabe. Ich bevorzuge nicht cin und cout, sondern printf(). Die Funktion printf() gibt einen String auf dem Bildschirm aus, also einen Text oder Zahlen oder Zeichen. Der Text steht innerhalb der Klammern. Um die Funktion zu benutzen, müssen wir allerdings eine weitere Bibliothek einfügen: stdio.h, für Standardfuntionen. Also wieder wie oben, per #include!
Wenn man einen festen Text ausgeben will, würde das so aussehen (ein konstanter Text steht in Anführungsstrichen!):
Code:
#include <conio.h> #include <stdio.h> void main() { printf("Hello World!"); getch(); }
Und was sehen wir nach dem Compilieren? Auf dem Bildschirm erscheint "Hello World!". Da wir aber eine Ein-/Ausgabe planen, brauchen wir eine Ausgabe, die nicht konstant, sondern variabel ist. Also brauchen wir eine Variable, die ausgegeben werden muss. Wir wollen nur Rechnen, also geben wir einen Integer ein und aus. Eine Fließkommzahl (Datentyp float) wäre natürlich auch möglich, aber schauen wir uns erstmal die Ganzzahlen (Datentyp int) an!
Wir legen also drei Integer an. Das ist die Mindestanzahl, die wir für eine Rechnung brauchen (a + b = c, a - b = c, a / b = c, a * b = c). Man könnte natürlich auch eine eingegebene Zahl mit einer Konstanten verrechnen, doch selbst dann bräuchten wir mindestens drei Integer! Also deklarieren wir erstmal die Integer. Ich bevorzuge es, aufgrund der Übersicht, sie nicht in einem Zug (int a, b, c) zu deklarieren, sondern untereinander (siehe Code).
Code:
#include <conio.h> #include <stdio.h> void main() { int a; int b; int c; printf("Hello World!"); getch(); }
So, nun muss jede Variable noch eingelesen werden. Um euch zu zeigen, was sonst raus kommen würde, geben wir erstmal die Variablen nur aus. Also müssen wir das printf() verändern. Wir geben in das printf() ein: a + b = c. Damit er jedoch nicht den Text ausgibt, sondern die Variablen, müssen wir das kennzeichnen.
Code:
[...] printf("%i", a); [...]
So gibt man mit printf() einen Integer (%i) aus. Weitere Datentypen sind auch möglich, dementsprechende Kürzel müssen verwendet werden. Um mehrere Variablen in einem printf() auszugeben, schreibt man sie einfach nach dem Komma in der Reihenfolge, wie sie ausgegeben werden sollen. Demensprechend viele %i müssen auch im printf() zur Verfügung stehen!
Code:
#include <conio.h> #include <stdio.h> void main() { int a; int b; int c; printf("%i + %i = %i", a, b, c); getch(); }
Nach dem Compilieren wird bei mir zum Beispiel "1 + 256 = 1" ausgegeben, was natürlich nicht stimmt. Wir haben ja noch keine Werte eingegeben, also kommen irgendwelche Werte, die vorher jemand anders mal in den Speicher gesetzt hat raus. Jetzt brauchen wir also eine Abfrage. Diese machen wir mit scanf()! Damit der Benutzer weiß, was er wann eingeben muss, setzen wir noch ein printf() vor jede Eingabe. Die Funktion scanf() benötigt wieder Datentyp und einen Zeiger auf die Variable. Wir zeigen auf eine Variable mit dem & Operator.
Da der Integer c das Ergebnis aus a und b sein soll, wird dieser logischerweise nicht eingelesen.
Code:
#include <conio.h> #include <stdio.h> void main() { int a; int b; int c; printf("a = "); scanf("%i", &a); printf("b = "); scanf("%i", &b); printf("%i + %i = %i", a, b, c); getch(); }
So, das einzige, was uns jetzt noch fehlt, ist eine Rechnung. Damit der Benutzer auch weiß, was gerechnet wird, geben wir vor der Abfrage noch die Formel aus. Wir benutzen vorerst a + b = c, so wie es schon da steht. In unserem Integer c steht später das Ergebnis. Also weisen wir dem Wert die Rechnung zu. In C++ wird das rechte immer dem linken zugewiesen, also c = a + b. a + b = c würde nicht funktionieren.
Da die Rechnung mit unserer Eingabe stattfinden soll, muss sie natürlich nach der Eingabe geschehen. Würde man c = a + b vor das scanf() setzen, würde das Programm mit falschen Werten rechnen.
Code:
#include <conio.h> #include <stdio.h> void main() { printf("a + b = c\n\n"); int a; int b; int c; printf("a = "); scanf("%i", &a); printf("b = "); scanf("%i", &b); c = a + b; printf("%i + %i = %i", a, b, c); getch(); }
Bei der Ausgabe von "a + b = c" habe ich zwei mal "\n" angehangt. Eines davon bewirkt einen Zeilenumbruch. Andernfalls würde die Ausgabe "a =" gleich hinten angehängt werden. Ihr könnt diese Zeilenumbrüche so oft ihr wollt in eure anderen printf() Funktionen einfügen, um die Darstellung euren Wünschen anzupassen.
So, wenn ihr jetzt das Programm ausführt, dann rechnet es auch a + b aus. Die Eingabe von negativen Zahlen ist auch möglich, so rechnet das Programm zum Beispiel: -5 + 5 = 0. Das könnte man auch verhindern, indem man zum Beispielen einen unsigned int verwendet, jedoch würde das in diesem Fall keinen Sinn ergeben. Der Wertebereich des Integers ist auch beschränkt und spätestens wenn man multiplizieren oder dividieren will reicht der Integer nicht mehr aus.
Also probieren wir das mal aus. Wir ersetzen das + durch ein / und haben so eine Division. Per Abfrage wäre natürlich auch eine Auswahl möglich, jedoch nicht in diesem Tutorial! Die Division ist für das Beispiel noch besser geeignet, da bei einer Division auch eine Kommazahl raus kommen kann, die mit dem Integer nicht dargestellt werden kann.
Code:
#include <conio.h> #include <stdio.h> void main() { printf("a / b = c\n\n"); int a; int b; int c; printf("a = "); scanf("%i", &a); printf("b = "); scanf("%i", &b); c = a / b; printf("%i / %i = %i", a, b, c); getch(); }
Gibt man jetzt 2 / 5 ein, so bekommt man das Ergebnis 0. Es besteht auch die Möglichkeit, den Rest auszugeben, aber da ist die Lösung mit einer Fließkommazahl doch angenehmer! Also ändern wir vor a, b und c das int zu float. Bei scanf() unf printf() muss demensprechend auch der Datentyp von %i zu %f geändert werden. Vergesst es nirgends, da euch sonst an irgendeiner Stelle ein falscher Wert ausgegeben wird!
Code:
#include <conio.h> #include <stdio.h> void main() { printf("a / b = c\n\n"); float a; float b; float c; printf("a = "); scanf("%f", &a); printf("b = "); scanf("%f", &b); c = a / b; printf("%f / %f = %f", a, b, c); getch(); }
Added after 1 minutes:
Code:
So, weiter gehts! Hier nun mein zweites Tutorial
Vorraussetzungen:
- Einstieg in C
Vorwort:
In diesem Tutorial werde ich euch:
* Klassen
* if-Abfrage
* UML (Klassendiagramm)
beibringen.
Programm:
Wir erstellen erst einmal wieder unser Hauptprogramm mit der main() Funktion. Bauen wir es gleich so auf, das es sich nicht nach einem Durchlauf schließt und binden wir gleich die Bibliotheken stdio.h und conio.h ein, damit wir sie gleich drin haben!
Code:
#include <stdio.h> #include <conio.h> void main() { getch(); }
Ihr könnt übrigens bei den Compilerbibliotheken, also den Bibliotheken, die ihr in die spitzen Klammern schreibt, ".h" auch weg lassen. Sie werden trotzdem eingebunden.
So, nun zu unsrer Klasse. Wir bauen uns vorerst mal eine ganz einfache Klasse. Sie soll rechnen können: Addieren, Subtrahieren, Dividieren und Multiplizieren. Wie schon im vorherigen Tutorial brauchen wir dafür 3 Variablen.
Eine Klasse besteht aus Methoden und / oder Eigenschaften. Eigenschaften sind Variablen, die in der Klasse stehen (int, string, float, usw.), Methoden ausführbare Befehle, so wie z.B. printf().
Die Klasse muss vor der main() Funktion deklariert werden, damit sie in der main() Funktion auch bekannt ist. Eine Klasse ist vom Datentyp class. Für unsere Klasse verwenden wir einen aussagekräftigen Namen "Rechner", damit man weiß, was die Klasse macht. Ihr könnt sie folgendermaßen deklarieren:
Code:
#include <stdio.h> #include <conio.h> class Rechner; void main() { getch(); }
So hat die Klasse jedoch noch keinen Inhalt. Weder Methoden noch Eigenschaften. Nebenbei möchte ich euch auch noch einen kleinen Einblick in die UML (Unified Modeling Language) geben. Wenn ihr mal etwas programmieren wollt, das komplexer ist, könnt ihr mit ihr sehr gut dokumentieren. Im Beruf kann es auch sein, dass ihr einen Plan bekommt, nachdem ihr dann programmieren müsst.
So, wir erstellen also ein Klassendiagramm zu unserer Klasse "Rechner". Sie hat noch keine Inhalte, also sieht unser Klassendiagramm folgendermaßen aus:
Download
Im oberen "Kasten" des Klassendiagramms steht der Klassenname. Im nächsten stehen die Eigenschaften und im letzten die Methoden. Die Bezeichnung der Datentypen und die Syntax ist in der UML etwas anders, als in der Programmiersprache. Darauf werd ich aber am entsprechenden Punkt noch eingehen.
So, nun brauchen wir Inhalt für unsere Klasse. Wir brauchen also drei Variablen (float) für unsere Rechnungen (Eigenschaften) und vier Funktionen für jede Rechnung (Methoden). Bei Klassen muss man angeben, ob die Methoden und Eigenschaften public, private oder protected sind. Ich schreibe erstmal die Klasse, später erkläre ich es:
Code:
#include <stdio.h> #include <conio.h> class Rechner { public: float Zahl1; float Zahl2; float Ergebnis; float addieren(float Uebergabe1, float Uebergabe2) { } float subtrahieren(float Uebergabe1, float Uebergabe2) { } float dividieren(float Uebergabe1, float Uebergabe2) { } float multiplizieren(float Uebergabe1, float Uebergabe2) { } }; void main() { getch(); }
So, jetzt wirds kernig xD Es kommt nun einiges zu erklären! Erstmal das mit public, private, protected usw.! Also, alles was unterhalb von public: steht ist public! Wollt ihr private Elemente müsst ihr private: in die Klasse schreiben und darunter eure private Elemente. Aber lassen wir das vorerst. Nun die Erklärung:
public: Auf Elemente, die public sind, kann jeder zugreifen. Ob außerhalb der Klasse oder innerhalb, jeder kann es. So kann z.B. innerhalb der main() Funktion direkt auf Zahl1 der Klasse Rechner zugegriffen werden. Möchte man dies nicht, braucht man ...
private: Auf Elemente, die private sind, kann nur die Klasse selbst zugreifen. Außerhalb der Klasse kann nicht auf die Elemente zugegriffen werden.
protected: Elemente die protected sind, sind nur für Ableitungen wichtig. Auf diese werde ich in einem anderen Tutorial eingehen.
Man kann Klassen ableiten, dabei werden die Inhalte der Klasse kopiert und in eine neue hinzugefügt (wie gesagt, späteres Tutorial!). Dabei geschieht folgendes:
* public: Wird abgeleitet, bleibt public
* private: wird nicht abgeleitet
* protected: wird abgeleitet und zu private
In der UML wird die Sichbarkeit mit folgenden Kürzeln angegeben:
* public: +
* private: -
* protected: #
Wir ändern unsere Zahlen so, dass sie private sind, damit nur die Methoden auf diese zugreifen können:
Code:
#include <stdio.h> #include <conio.h> class Rechner { private: float Zahl1; float Zahl2; float Ergebnis; public: float addieren(float Uebergabe1, float Uebergabe2) { } float subtrahieren(float Uebergabe1, float Uebergabe2) { } float dividieren(float Uebergabe1, float Uebergabe2) { } float multiplizieren(float Uebergabe1, float Uebergabe2) { } }; void main() { getch(); }
Nun weiter mit der Erklärung... Die Syntax einer Klasse sieht folgendermaßen aus (wie schon im Code zu sehen ist):
Code:
[...] class Klassenname { // ... }; [...]
Ganz wichtig ist der Strichpunkt nach der schließenden geschweiften Klammer! Dieser wird oft vergessen und sorft für Compilerfehlermeldungen. Dieser Strichpunkt ist etwas ungewöhnlich, ich weiß. Man kann die Klasse auch vorher deklarieren, was in speziellen Fällen notwendig ist (hier nicht):
Code:
#include <stdio.h> #include <conio.h> class Rechner; class Rechner { private: float Zahl1; float Zahl2; float Ergebnis; public: float addieren(float Uebergabe1, float Uebergabe2) { } float subtrahieren(float Uebergabe1, float Uebergabe2) { } float dividieren(float Uebergabe1, float Uebergabe2) { } float multiplizieren(float Uebergabe1, float Uebergabe2) { } }; void main() { getch(); }
So, weiter mit der Erklärung. Wir behalten die Variante bei, die die Klasse nicht vorher schon deklariert. Wenn nicht, macht das auch nichts aus. Also, wir haben hier vier Methoden. Eine Methode hat folgenden Aufbau, folgende Syntax:
Code:
[...] Rückgabetyp Methodenname(Parametertyp Parameter_1, Parametertyp Parameter_2, ..., Parametertyp Parameter_n) { //... return Rückgabe; // ggf. } [...]
Ist der Rückgabetyp void, gibt die Methode keinen Wert zurück, braucht demzufolge kein return. In unserem Fall wird jedoch jede Methode einen Wert zurückgeben, da wir ja ein Ergebnis bekommen.
Dann gibt es noch den Parameter. In unserem Fall haben wir je Methode zwei Paramter. Die Variablen werden in unserem Fall in der Methode deklariert, da vor dem Parameternamen ein Parametertyp (float) steht:
Code:
float addieren(float Uebergabe1, float Uebergabe2) { }
Die Variablen Uebergabe1 und Uebergabe2 können nur in der jeweiligen Methode verwendet werden. Sie sterben am Ende der Methode.
Code:
float addieren(float Uebergabe1, float Uebergabe2) {// <- Uebergabe1, Uebergabe2 werden ins Leben gerufen }//<- Uebergabe1, Uebergabe2 sterben
Ihr könnt also Uebergabe1 und Uebergabe2 nicht von wo anders aus aufrufen. Zahl1 wird später Uebergabe1 zugewiesen und Zahl2 Uebergabe2. Man bräuchte sie garnicht zuzuweisen, sondern könnte gleich der Variable Ergebnis das Ergebnis der beiden Übergabewerte zuweisen, jedoch machen wir das hier so, es ist einfach ordentlicher.
Jetzt müssen wir jedoch erstmal unser Klassendiagramm aktualisieren. Syntax ist hier bei Eigenschaften:
Code:
Sichtbarkeit Name: Datentyp
Bei einer Methode:
Code:
Sichtbarkeit Name(Parameter_1:Parametertyp, Parameter_2:Parametertyp, ..., Parameter_n:Parametertyp): Rückgabetyp
Wie man sieht ist das ganze genau anders rum, ja, ziemlich blöd. Was noch dazu kommt, ist, dass man die Datentypen nicht programmiersprachenspezifisch angibt. Das heißt, ihr schreibt dort nicht "+ Name: int" rein.
Ein paar Datentypen:
* int = GZ (Ganzzahl)
* float = FKZ (Fließkommazahl)
* string = Text
Also sieht unser neues Klassendiagramm folgendermaßen aus:
Download
So, nun zurück zu unseren Methoden. Jetzt programmieren wir sie aus.
Code:
#include <stdio.h> #include <conio.h> class Rechner { private: float Zahl1; float Zahl2; float Ergebnis; public: float addieren(float Uebergabe1, float Uebergabe2) { Zahl1 = Uebergabe1; Zahl2 = Uebergabe2; Ergebnis = Zahl1 + Zahl2; return Ergebnis; } float subtrahieren(float Uebergabe1, float Uebergabe2) { Zahl1 = Uebergabe1; Zahl2 = Uebergabe2; Ergebnis = Zahl1 - Zahl2; return Ergebnis; } float dividieren(float Uebergabe1, float Uebergabe2) { Zahl1 = Uebergabe1; Zahl2 = Uebergabe2; Ergebnis = Zahl1 / Zahl2; return Ergebnis; } float multiplizieren(float Uebergabe1, float Uebergabe2) { Zahl1 = Uebergabe1; Zahl2 = Uebergabe2; Ergebnis = Zahl1 * Zahl2; return Ergebnis; } }; void main() { getch(); }
Jetzt haben wir in jeder Methode den entsprechenden Rechenschritt. Den Variablen Zahl1 und Zahl2 der Klasse werden die Übergabewerte Uebergabe1 und Uebergabe2 der jeweiligen Methoden zugewiesen. Wenn man jetzt z.B. eine Addition durchführen würde und diese beendet wäre, würden die Werte in Zahl1 und Zahl2 immernoch drin stehen. Jedoch könnte man sie nicht abrufen, da sie private sind. Die Werte von Uebergabe1 und Uebergabe2 könnte man nicht mehr von Außerhalb abrufen, da die Werte am Ende der Methode sterben.
Und da unsere Methoden einen Rückgabewert vom Typ float erwarten, geben wir ihnen auch einen vom Typ float zurück (return Ergebnis). Ein anderer Datentyp wäre wahrscheinlich nicht möglich, wie z.B. ein String. Einen Integer akzeptiert der Compiler, aber ob alles problemlos funktionieren wird, weiß ich nicht.
So, nun haben wir unsere Klasse fertig geschrieben. Eine Klasse ist jedoch nur etwas wie ein Bauplan. Wir können die Klasse so nicht benutzen, wir brauchen eine Instanz. Wir können uns das so vorstellen: Der Vogel ist die Klasse (der Bauplan) und eine Amsel ist eine Instanz. Oder ein Auto. Ein Auto kann ein Bauplan sein und ein Opel eine Instanz. Ein Opel kann natürlich auch wieder ein Bauplan sein, das ist Ansichtssache. Und dann das bestimmte Model eine Insanz.
Also, wir haben jetzt unsere Klasse Rechner geschrieben und können, genauso wie bei allen anderen Datentypen, eine Instanz vom Typ Rechner bilden. Deshalb solltet ihr keine Klasse schreiben, die int, float, string usw. heißt. Also rufen wir eine Instanz ins Leben:
Code:
#include <stdio.h> #include <conio.h> class Rechner { private: float Zahl1; float Zahl2; float Ergebnis; public: float addieren(float Uebergabe1, float Uebergabe2) { Zahl1 = Uebergabe1; Zahl2 = Uebergabe2; Ergebnis = Zahl1 + Zahl2; return Ergebnis; } float subtrahieren(float Uebergabe1, float Uebergabe2) { Zahl1 = Uebergabe1; Zahl2 = Uebergabe2; Ergebnis = Zahl1 - Zahl2; return Ergebnis; } float dividieren(float Uebergabe1, float Uebergabe2) { Zahl1 = Uebergabe1; Zahl2 = Uebergabe2; Ergebnis = Zahl1 / Zahl2; return Ergebnis; } float multiplizieren(float Uebergabe1, float Uebergabe2) { Zahl1 = Uebergabe1; Zahl2 = Uebergabe2; Ergebnis = Zahl1 * Zahl2; return Ergebnis; } }; void main() { Rechner DerRechner; getch(); }
Jetzt haben wir die Instanz "DerRechner". Ein ordentlicher Name würde ich sagen. In den meisten Fällen wird die Instanz so benannt: Artikel + Klassenname. Da mir sonst nichts besseres einfällt. Jetzt können wir auf die einzelnen Elemente zugreifen, solange sie public sind. Beim Methodenaufruf: DerRechner.addieren(5, 5); würden wir 10 zurück bekommen, also können wir es direkt ausgeben lassen. Damit es jedoch übersichtlicher wird, und wir nicht einen so langen Methodenaufruf im printf() haben, verwenden wir eine Zwischenvariable (float Ausgabe). Sie dient nur der Übersicht:
Code:
#include <stdio.h> #include <conio.h> class Rechner { private: float Zahl1; float Zahl2; float Ergebnis; public: float addieren(float Uebergabe1, float Uebergabe2) { Zahl1 = Uebergabe1; Zahl2 = Uebergabe2; Ergebnis = Zahl1 + Zahl2; return Ergebnis; } float subtrahieren(float Uebergabe1, float Uebergabe2) { Zahl1 = Uebergabe1; Zahl2 = Uebergabe2; Ergebnis = Zahl1 - Zahl2; return Ergebnis; } float dividieren(float Uebergabe1, float Uebergabe2) { Zahl1 = Uebergabe1; Zahl2 = Uebergabe2; Ergebnis = Zahl1 / Zahl2; return Ergebnis; } float multiplizieren(float Uebergabe1, float Uebergabe2) { Zahl1 = Uebergabe1; Zahl2 = Uebergabe2; Ergebnis = Zahl1 * Zahl2; return Ergebnis; } }; void main() { Rechner DerRechner; float Ausgabe; Ausgabe = DerRechner.addieren(5, 5); printf("Ergebnis: %f \n", Ausgabe); getch(); }
Damit das ganze nicht so langweilig ist, fügen wir noch die Eingabe hinzu, aus dem vorherigen Tutorial. Wir brauchen dafür jedoch wieder zwei Variablen zum Zwischenspeichern. Erst wird die Eingabe in sie rein geschrieben, dann werden sie an die Klasse übergeben:
Code:
#include <stdio.h> #include <conio.h> class Rechner { private: float Zahl1; float Zahl2; float Ergebnis; public: float addieren(float Uebergabe1, float Uebergabe2) { Zahl1 = Uebergabe1; Zahl2 = Uebergabe2; Ergebnis = Zahl1 + Zahl2; return Ergebnis; } float subtrahieren(float Uebergabe1, float Uebergabe2) { Zahl1 = Uebergabe1; Zahl2 = Uebergabe2; Ergebnis = Zahl1 - Zahl2; return Ergebnis; } float dividieren(float Uebergabe1, float Uebergabe2) { Zahl1 = Uebergabe1; Zahl2 = Uebergabe2; Ergebnis = Zahl1 / Zahl2; return Ergebnis; } float multiplizieren(float Uebergabe1, float Uebergabe2) { Zahl1 = Uebergabe1; Zahl2 = Uebergabe2; Ergebnis = Zahl1 * Zahl2; return Ergebnis; } }; void main() { Rechner DerRechner; float Ausgabe; float Zahl1; float Zahl2; printf("Zahl1: "); scanf("%f", &Zahl1); printf("Zahl2: "); scanf("%f", &Zahl2); Ausgabe = DerRechner.addieren(Zahl1, Zahl2); printf("Ergebnis: %f \n", Ausgabe); getch(); }
So, jetzt habt ihr eine Klasse, die rechnen kann. Natürlich konnte man das vorher auch schon unumständlicher. Aber das ist ein gutes Beispiel für Klassen.
Ich werde euch hier noch am Rande kurz die if-Abfrage zeigen. Schwierig ist dieser Befehl nicht. Syntax:
Code:
if(Bedingung) { // Code für Bedingung erfüllt } else { // Bedingung nicht erfüllt, kann auch weg gelassen werden }
Wir möchten in unserem Beispiel abfragen, ob der Benutzer addieren, subtrahieren, multiplizieren oder dividieren will. Wir weisen jedem dieser Operationen einen Zahlenwert zu. Gibt der Benutzer diesen ein, dann wird die entsprechende Operation ausgeführt.
Man könnte das auch mit "Befehlen", also Text, umsetzen, aber wir bleiben hier bei einem einfachen Beispiel.
Wir brauchen also einen Integer für die mögliche Eingabe (0, 1, 2, 3). Diesen nennen wir "Eingabe". Dann brauchen wir noch ein printf(), damit ausgegeben wird, was der Benutzer für die jeweilige Operation drücken muss. Und noch ein scanf(), das die Eingabe einliest. Und eben die if-Abfrage.
Code:
#include <stdio.h> #include <conio.h> class Rechner { private: float Zahl1; float Zahl2; float Ergebnis; public: float addieren(float Uebergabe1, float Uebergabe2) { Zahl1 = Uebergabe1; Zahl2 = Uebergabe2; Ergebnis = Zahl1 + Zahl2; return Ergebnis; } float subtrahieren(float Uebergabe1, float Uebergabe2) { Zahl1 = Uebergabe1; Zahl2 = Uebergabe2; Ergebnis = Zahl1 - Zahl2; return Ergebnis; } float dividieren(float Uebergabe1, float Uebergabe2) { Zahl1 = Uebergabe1; Zahl2 = Uebergabe2; Ergebnis = Zahl1 / Zahl2; return Ergebnis; } float multiplizieren(float Uebergabe1, float Uebergabe2) { Zahl1 = Uebergabe1; Zahl2 = Uebergabe2; Ergebnis = Zahl1 * Zahl2; return Ergebnis; } }; void main() { Rechner DerRechner; float Ausgabe; float Zahl1; float Zahl2; int Eingabe; printf("Zahl1: "); scanf("%f", &Zahl1); printf("Zahl2: "); scanf("%f", &Zahl2); printf("0 = Addieren\n"); printf("1 = Subtrahieren\n"); printf("2 = Multiplizieren\n"); printf("3 = Dividieren\n\n"); scanf("%i", &Eingabe); if(Eingabe == 0) { Ausgabe = DerRechner.addieren(Zahl1, Zahl2); } if(Eingabe == 1) { Ausgabe = DerRechner.subtrahieren(Zahl1, Zahl2); } if(Eingabe == 2) { Ausgabe = DerRechner.multiplizieren(Zahl1, Zahl2); } if(Eingabe == 3) { Ausgabe = DerRechner.dividieren(Zahl1, Zahl2); } if(Eingabe != 0 && Eingabe != 1 && Eingabe != 2 && Eingabe != 3) { printf("Eingabe nicht möglich!\n\n"); } printf("Ergebnis: %f \n", Ausgabe); getch(); }
Die if-Abfrage ist eigentlich ziemlich selbsterklärend. Wenn wir den Fall durchgehen, dass ich eine 1 drücke, dann durchläuft das Programm die if-Abfragen: Ist die Eingabe == 0? Nein (false). Ist die Eingabe == 1? Ja (true), Code ausführen. Ist die Eingabe == 2? Nein (false). Ist die Eingabe == 3? Nein (false). Wenn keine der Bedinungen erfüllt (true) ist, dann gib "Eingabe nicht möglich!" aus.
Ein Ergebnis wird in diesem Fall leider trotzdem ausgegeben. Man könnte das natürlich verhindern. Z.B. indem man die Ausgabe des Ergebnisses in jede if-Abfrage setzt. Das wäre jedoch weniger elegant. Also lasse ich es so. Ihr könnt z.B. auch die Ausgabe von Anfang an auf 0 setzen (Ausgabe = 0). Dann wird im else-Fall einfach Ergebnis: 0 ausgegeben.
An dieser Stelle vielen Dank an Sn0wm4n, der mich auf diesen Fehler hingewiesen hat! (Ich hatte es vorher mit einem else gelöst!)
In diesem Beispiel kann ich euch leider nur ungeschickt die else-Anweisung zeigen, da ich für jede if-Anweisung ein else bräuchte und somit pro else im Fall false des ifs ein printf() ausgegeben werden würde. Deshalb muss ich hier am Schluss abfragen: "Ist die Eingabe ungleich 0 und ungleich 1 und ungleich 2 und ungleich 3, dann gib ... aus".
Kurze Info zur &&-Verknüpfung (logisches UND):
0 steht für false (if-Bedingung nicht erfüllt)
1 steht für true (if-Bedingung erfüllt)
0 & 0 = 0
0 & 1 = 0
1 & 1 = 1
Dann noch zum Ungleich etwas. Bei if-Abfragen könnt ihr fragen:
* == : ist gleich (immer zwei = !!!)
* != : ist ungleich
* > : ist größer als
* < : ist kleiner als
* >= : ist größergleich (größer oder gleich)
* <= : ist kleinergleich (kleiner oder gleich)
So, das wars dann. Im nächsten Tutorial werde ich weiter auf Klassen eingehen. Dann wird es um Operatoren und um Header-Dateien gehen.
nummer 2
Code:
So, weiter gehts! Hier nun mein zweites Tutorial
Vorraussetzungen:
- Einstieg in C
Vorwort:
In diesem Tutorial werde ich euch:
* Klassen
* if-Abfrage
* UML (Klassendiagramm)
beibringen.
Programm:
Wir erstellen erst einmal wieder unser Hauptprogramm mit der main() Funktion. Bauen wir es gleich so auf, das es sich nicht nach einem Durchlauf schließt und binden wir gleich die Bibliotheken stdio.h und conio.h ein, damit wir sie gleich drin haben!
Code:
#include <stdio.h> #include <conio.h> void main() { getch(); }
Ihr könnt übrigens bei den Compilerbibliotheken, also den Bibliotheken, die ihr in die spitzen Klammern schreibt, ".h" auch weg lassen. Sie werden trotzdem eingebunden.
So, nun zu unsrer Klasse. Wir bauen uns vorerst mal eine ganz einfache Klasse. Sie soll rechnen können: Addieren, Subtrahieren, Dividieren und Multiplizieren. Wie schon im vorherigen Tutorial brauchen wir dafür 3 Variablen.
Eine Klasse besteht aus Methoden und / oder Eigenschaften. Eigenschaften sind Variablen, die in der Klasse stehen (int, string, float, usw.), Methoden ausführbare Befehle, so wie z.B. printf().
Die Klasse muss vor der main() Funktion deklariert werden, damit sie in der main() Funktion auch bekannt ist. Eine Klasse ist vom Datentyp class. Für unsere Klasse verwenden wir einen aussagekräftigen Namen "Rechner", damit man weiß, was die Klasse macht. Ihr könnt sie folgendermaßen deklarieren:
Code:
#include <stdio.h> #include <conio.h> class Rechner; void main() { getch(); }
So hat die Klasse jedoch noch keinen Inhalt. Weder Methoden noch Eigenschaften. Nebenbei möchte ich euch auch noch einen kleinen Einblick in die UML (Unified Modeling Language) geben. Wenn ihr mal etwas programmieren wollt, das komplexer ist, könnt ihr mit ihr sehr gut dokumentieren. Im Beruf kann es auch sein, dass ihr einen Plan bekommt, nachdem ihr dann programmieren müsst.
So, wir erstellen also ein Klassendiagramm zu unserer Klasse "Rechner". Sie hat noch keine Inhalte, also sieht unser Klassendiagramm folgendermaßen aus:
Download
Im oberen "Kasten" des Klassendiagramms steht der Klassenname. Im nächsten stehen die Eigenschaften und im letzten die Methoden. Die Bezeichnung der Datentypen und die Syntax ist in der UML etwas anders, als in der Programmiersprache. Darauf werd ich aber am entsprechenden Punkt noch eingehen.
So, nun brauchen wir Inhalt für unsere Klasse. Wir brauchen also drei Variablen (float) für unsere Rechnungen (Eigenschaften) und vier Funktionen für jede Rechnung (Methoden). Bei Klassen muss man angeben, ob die Methoden und Eigenschaften public, private oder protected sind. Ich schreibe erstmal die Klasse, später erkläre ich es:
Code:
#include <stdio.h> #include <conio.h> class Rechner { public: float Zahl1; float Zahl2; float Ergebnis; float addieren(float Uebergabe1, float Uebergabe2) { } float subtrahieren(float Uebergabe1, float Uebergabe2) { } float dividieren(float Uebergabe1, float Uebergabe2) { } float multiplizieren(float Uebergabe1, float Uebergabe2) { } }; void main() { getch(); }
So, jetzt wirds kernig xD Es kommt nun einiges zu erklären! Erstmal das mit public, private, protected usw.! Also, alles was unterhalb von public: steht ist public! Wollt ihr private Elemente müsst ihr private: in die Klasse schreiben und darunter eure private Elemente. Aber lassen wir das vorerst. Nun die Erklärung:
public: Auf Elemente, die public sind, kann jeder zugreifen. Ob außerhalb der Klasse oder innerhalb, jeder kann es. So kann z.B. innerhalb der main() Funktion direkt auf Zahl1 der Klasse Rechner zugegriffen werden. Möchte man dies nicht, braucht man ...
private: Auf Elemente, die private sind, kann nur die Klasse selbst zugreifen. Außerhalb der Klasse kann nicht auf die Elemente zugegriffen werden.
protected: Elemente die protected sind, sind nur für Ableitungen wichtig. Auf diese werde ich in einem anderen Tutorial eingehen.
Man kann Klassen ableiten, dabei werden die Inhalte der Klasse kopiert und in eine neue hinzugefügt (wie gesagt, späteres Tutorial!). Dabei geschieht folgendes:
* public: Wird abgeleitet, bleibt public
* private: wird nicht abgeleitet
* protected: wird abgeleitet und zu private
In der UML wird die Sichbarkeit mit folgenden Kürzeln angegeben:
* public: +
* private: -
* protected: #
Wir ändern unsere Zahlen so, dass sie private sind, damit nur die Methoden auf diese zugreifen können:
Code:
#include <stdio.h> #include <conio.h> class Rechner { private: float Zahl1; float Zahl2; float Ergebnis; public: float addieren(float Uebergabe1, float Uebergabe2) { } float subtrahieren(float Uebergabe1, float Uebergabe2) { } float dividieren(float Uebergabe1, float Uebergabe2) { } float multiplizieren(float Uebergabe1, float Uebergabe2) { } }; void main() { getch(); }
Nun weiter mit der Erklärung... Die Syntax einer Klasse sieht folgendermaßen aus (wie schon im Code zu sehen ist):
Code:
[...] class Klassenname { // ... }; [...]
Ganz wichtig ist der Strichpunkt nach der schließenden geschweiften Klammer! Dieser wird oft vergessen und sorft für Compilerfehlermeldungen. Dieser Strichpunkt ist etwas ungewöhnlich, ich weiß. Man kann die Klasse auch vorher deklarieren, was in speziellen Fällen notwendig ist (hier nicht):
Code:
#include <stdio.h> #include <conio.h> class Rechner; class Rechner { private: float Zahl1; float Zahl2; float Ergebnis; public: float addieren(float Uebergabe1, float Uebergabe2) { } float subtrahieren(float Uebergabe1, float Uebergabe2) { } float dividieren(float Uebergabe1, float Uebergabe2) { } float multiplizieren(float Uebergabe1, float Uebergabe2) { } }; void main() { getch(); }
So, weiter mit der Erklärung. Wir behalten die Variante bei, die die Klasse nicht vorher schon deklariert. Wenn nicht, macht das auch nichts aus. Also, wir haben hier vier Methoden. Eine Methode hat folgenden Aufbau, folgende Syntax:
Code:
[...] Rückgabetyp Methodenname(Parametertyp Parameter_1, Parametertyp Parameter_2, ..., Parametertyp Parameter_n) { //... return Rückgabe; // ggf. } [...]
Ist der Rückgabetyp void, gibt die Methode keinen Wert zurück, braucht demzufolge kein return. In unserem Fall wird jedoch jede Methode einen Wert zurückgeben, da wir ja ein Ergebnis bekommen.
Dann gibt es noch den Parameter. In unserem Fall haben wir je Methode zwei Paramter. Die Variablen werden in unserem Fall in der Methode deklariert, da vor dem Parameternamen ein Parametertyp (float) steht:
Code:
float addieren(float Uebergabe1, float Uebergabe2) { }
Die Variablen Uebergabe1 und Uebergabe2 können nur in der jeweiligen Methode verwendet werden. Sie sterben am Ende der Methode.
Code:
float addieren(float Uebergabe1, float Uebergabe2) {// <- Uebergabe1, Uebergabe2 werden ins Leben gerufen }//<- Uebergabe1, Uebergabe2 sterben
Ihr könnt also Uebergabe1 und Uebergabe2 nicht von wo anders aus aufrufen. Zahl1 wird später Uebergabe1 zugewiesen und Zahl2 Uebergabe2. Man bräuchte sie garnicht zuzuweisen, sondern könnte gleich der Variable Ergebnis das Ergebnis der beiden Übergabewerte zuweisen, jedoch machen wir das hier so, es ist einfach ordentlicher.
Jetzt müssen wir jedoch erstmal unser Klassendiagramm aktualisieren. Syntax ist hier bei Eigenschaften:
Code:
Sichtbarkeit Name: Datentyp
Bei einer Methode:
Code:
Sichtbarkeit Name(Parameter_1:Parametertyp, Parameter_2:Parametertyp, ..., Parameter_n:Parametertyp): Rückgabetyp
Wie man sieht ist das ganze genau anders rum, ja, ziemlich blöd. Was noch dazu kommt, ist, dass man die Datentypen nicht programmiersprachenspezifisch angibt. Das heißt, ihr schreibt dort nicht "+ Name: int" rein.
Ein paar Datentypen:
* int = GZ (Ganzzahl)
* float = FKZ (Fließkommazahl)
* string = Text
Also sieht unser neues Klassendiagramm folgendermaßen aus:
Download
So, nun zurück zu unseren Methoden. Jetzt programmieren wir sie aus.
Code:
#include <stdio.h> #include <conio.h> class Rechner { private: float Zahl1; float Zahl2; float Ergebnis; public: float addieren(float Uebergabe1, float Uebergabe2) { Zahl1 = Uebergabe1; Zahl2 = Uebergabe2; Ergebnis = Zahl1 + Zahl2; return Ergebnis; } float subtrahieren(float Uebergabe1, float Uebergabe2) { Zahl1 = Uebergabe1; Zahl2 = Uebergabe2; Ergebnis = Zahl1 - Zahl2; return Ergebnis; } float dividieren(float Uebergabe1, float Uebergabe2) { Zahl1 = Uebergabe1; Zahl2 = Uebergabe2; Ergebnis = Zahl1 / Zahl2; return Ergebnis; } float multiplizieren(float Uebergabe1, float Uebergabe2) { Zahl1 = Uebergabe1; Zahl2 = Uebergabe2; Ergebnis = Zahl1 * Zahl2; return Ergebnis; } }; void main() { getch(); }
Jetzt haben wir in jeder Methode den entsprechenden Rechenschritt. Den Variablen Zahl1 und Zahl2 der Klasse werden die Übergabewerte Uebergabe1 und Uebergabe2 der jeweiligen Methoden zugewiesen. Wenn man jetzt z.B. eine Addition durchführen würde und diese beendet wäre, würden die Werte in Zahl1 und Zahl2 immernoch drin stehen. Jedoch könnte man sie nicht abrufen, da sie private sind. Die Werte von Uebergabe1 und Uebergabe2 könnte man nicht mehr von Außerhalb abrufen, da die Werte am Ende der Methode sterben.
Und da unsere Methoden einen Rückgabewert vom Typ float erwarten, geben wir ihnen auch einen vom Typ float zurück (return Ergebnis). Ein anderer Datentyp wäre wahrscheinlich nicht möglich, wie z.B. ein String. Einen Integer akzeptiert der Compiler, aber ob alles problemlos funktionieren wird, weiß ich nicht.
So, nun haben wir unsere Klasse fertig geschrieben. Eine Klasse ist jedoch nur etwas wie ein Bauplan. Wir können die Klasse so nicht benutzen, wir brauchen eine Instanz. Wir können uns das so vorstellen: Der Vogel ist die Klasse (der Bauplan) und eine Amsel ist eine Instanz. Oder ein Auto. Ein Auto kann ein Bauplan sein und ein Opel eine Instanz. Ein Opel kann natürlich auch wieder ein Bauplan sein, das ist Ansichtssache. Und dann das bestimmte Model eine Insanz.
Also, wir haben jetzt unsere Klasse Rechner geschrieben und können, genauso wie bei allen anderen Datentypen, eine Instanz vom Typ Rechner bilden. Deshalb solltet ihr keine Klasse schreiben, die int, float, string usw. heißt. Also rufen wir eine Instanz ins Leben:
Code:
#include <stdio.h> #include <conio.h> class Rechner { private: float Zahl1; float Zahl2; float Ergebnis; public: float addieren(float Uebergabe1, float Uebergabe2) { Zahl1 = Uebergabe1; Zahl2 = Uebergabe2; Ergebnis = Zahl1 + Zahl2; return Ergebnis; } float subtrahieren(float Uebergabe1, float Uebergabe2) { Zahl1 = Uebergabe1; Zahl2 = Uebergabe2; Ergebnis = Zahl1 - Zahl2; return Ergebnis; } float dividieren(float Uebergabe1, float Uebergabe2) { Zahl1 = Uebergabe1; Zahl2 = Uebergabe2; Ergebnis = Zahl1 / Zahl2; return Ergebnis; } float multiplizieren(float Uebergabe1, float Uebergabe2) { Zahl1 = Uebergabe1; Zahl2 = Uebergabe2; Ergebnis = Zahl1 * Zahl2; return Ergebnis; } }; void main() { Rechner DerRechner; getch(); }
Jetzt haben wir die Instanz "DerRechner". Ein ordentlicher Name würde ich sagen. In den meisten Fällen wird die Instanz so benannt: Artikel + Klassenname. Da mir sonst nichts besseres einfällt. Jetzt können wir auf die einzelnen Elemente zugreifen, solange sie public sind. Beim Methodenaufruf: DerRechner.addieren(5, 5); würden wir 10 zurück bekommen, also können wir es direkt ausgeben lassen. Damit es jedoch übersichtlicher wird, und wir nicht einen so langen Methodenaufruf im printf() haben, verwenden wir eine Zwischenvariable (float Ausgabe). Sie dient nur der Übersicht:
Code:
#include <stdio.h> #include <conio.h> class Rechner { private: float Zahl1; float Zahl2; float Ergebnis; public: float addieren(float Uebergabe1, float Uebergabe2) { Zahl1 = Uebergabe1; Zahl2 = Uebergabe2; Ergebnis = Zahl1 + Zahl2; return Ergebnis; } float subtrahieren(float Uebergabe1, float Uebergabe2) { Zahl1 = Uebergabe1; Zahl2 = Uebergabe2; Ergebnis = Zahl1 - Zahl2; return Ergebnis; } float dividieren(float Uebergabe1, float Uebergabe2) { Zahl1 = Uebergabe1; Zahl2 = Uebergabe2; Ergebnis = Zahl1 / Zahl2; return Ergebnis; } float multiplizieren(float Uebergabe1, float Uebergabe2) { Zahl1 = Uebergabe1; Zahl2 = Uebergabe2; Ergebnis = Zahl1 * Zahl2; return Ergebnis; } }; void main() { Rechner DerRechner; float Ausgabe; Ausgabe = DerRechner.addieren(5, 5); printf("Ergebnis: %f \n", Ausgabe); getch(); }
Damit das ganze nicht so langweilig ist, fügen wir noch die Eingabe hinzu, aus dem vorherigen Tutorial. Wir brauchen dafür jedoch wieder zwei Variablen zum Zwischenspeichern. Erst wird die Eingabe in sie rein geschrieben, dann werden sie an die Klasse übergeben:
Code:
#include <stdio.h> #include <conio.h> class Rechner { private: float Zahl1; float Zahl2; float Ergebnis; public: float addieren(float Uebergabe1, float Uebergabe2) { Zahl1 = Uebergabe1; Zahl2 = Uebergabe2; Ergebnis = Zahl1 + Zahl2; return Ergebnis; } float subtrahieren(float Uebergabe1, float Uebergabe2) { Zahl1 = Uebergabe1; Zahl2 = Uebergabe2; Ergebnis = Zahl1 - Zahl2; return Ergebnis; } float dividieren(float Uebergabe1, float Uebergabe2) { Zahl1 = Uebergabe1; Zahl2 = Uebergabe2; Ergebnis = Zahl1 / Zahl2; return Ergebnis; } float multiplizieren(float Uebergabe1, float Uebergabe2) { Zahl1 = Uebergabe1; Zahl2 = Uebergabe2; Ergebnis = Zahl1 * Zahl2; return Ergebnis; } }; void main() { Rechner DerRechner; float Ausgabe; float Zahl1; float Zahl2; printf("Zahl1: "); scanf("%f", &Zahl1); printf("Zahl2: "); scanf("%f", &Zahl2); Ausgabe = DerRechner.addieren(Zahl1, Zahl2); printf("Ergebnis: %f \n", Ausgabe); getch(); }
So, jetzt habt ihr eine Klasse, die rechnen kann. Natürlich konnte man das vorher auch schon unumständlicher. Aber das ist ein gutes Beispiel für Klassen.
Ich werde euch hier noch am Rande kurz die if-Abfrage zeigen. Schwierig ist dieser Befehl nicht. Syntax:
Code:
if(Bedingung) { // Code für Bedingung erfüllt } else { // Bedingung nicht erfüllt, kann auch weg gelassen werden }
Wir möchten in unserem Beispiel abfragen, ob der Benutzer addieren, subtrahieren, multiplizieren oder dividieren will. Wir weisen jedem dieser Operationen einen Zahlenwert zu. Gibt der Benutzer diesen ein, dann wird die entsprechende Operation ausgeführt.
Man könnte das auch mit "Befehlen", also Text, umsetzen, aber wir bleiben hier bei einem einfachen Beispiel.
Wir brauchen also einen Integer für die mögliche Eingabe (0, 1, 2, 3). Diesen nennen wir "Eingabe". Dann brauchen wir noch ein printf(), damit ausgegeben wird, was der Benutzer für die jeweilige Operation drücken muss. Und noch ein scanf(), das die Eingabe einliest. Und eben die if-Abfrage.
Code:
#include <stdio.h> #include <conio.h> class Rechner { private: float Zahl1; float Zahl2; float Ergebnis; public: float addieren(float Uebergabe1, float Uebergabe2) { Zahl1 = Uebergabe1; Zahl2 = Uebergabe2; Ergebnis = Zahl1 + Zahl2; return Ergebnis; } float subtrahieren(float Uebergabe1, float Uebergabe2) { Zahl1 = Uebergabe1; Zahl2 = Uebergabe2; Ergebnis = Zahl1 - Zahl2; return Ergebnis; } float dividieren(float Uebergabe1, float Uebergabe2) { Zahl1 = Uebergabe1; Zahl2 = Uebergabe2; Ergebnis = Zahl1 / Zahl2; return Ergebnis; } float multiplizieren(float Uebergabe1, float Uebergabe2) { Zahl1 = Uebergabe1; Zahl2 = Uebergabe2; Ergebnis = Zahl1 * Zahl2; return Ergebnis; } }; void main() { Rechner DerRechner; float Ausgabe; float Zahl1; float Zahl2; int Eingabe; printf("Zahl1: "); scanf("%f", &Zahl1); printf("Zahl2: "); scanf("%f", &Zahl2); printf("0 = Addieren\n"); printf("1 = Subtrahieren\n"); printf("2 = Multiplizieren\n"); printf("3 = Dividieren\n\n"); scanf("%i", &Eingabe); if(Eingabe == 0) { Ausgabe = DerRechner.addieren(Zahl1, Zahl2); } if(Eingabe == 1) { Ausgabe = DerRechner.subtrahieren(Zahl1, Zahl2); } if(Eingabe == 2) { Ausgabe = DerRechner.multiplizieren(Zahl1, Zahl2); } if(Eingabe == 3) { Ausgabe = DerRechner.dividieren(Zahl1, Zahl2); } if(Eingabe != 0 && Eingabe != 1 && Eingabe != 2 && Eingabe != 3) { printf("Eingabe nicht möglich!\n\n"); } printf("Ergebnis: %f \n", Ausgabe); getch(); }
Die if-Abfrage ist eigentlich ziemlich selbsterklärend. Wenn wir den Fall durchgehen, dass ich eine 1 drücke, dann durchläuft das Programm die if-Abfragen: Ist die Eingabe == 0? Nein (false). Ist die Eingabe == 1? Ja (true), Code ausführen. Ist die Eingabe == 2? Nein (false). Ist die Eingabe == 3? Nein (false). Wenn keine der Bedinungen erfüllt (true) ist, dann gib "Eingabe nicht möglich!" aus.
Ein Ergebnis wird in diesem Fall leider trotzdem ausgegeben. Man könnte das natürlich verhindern. Z.B. indem man die Ausgabe des Ergebnisses in jede if-Abfrage setzt. Das wäre jedoch weniger elegant. Also lasse ich es so. Ihr könnt z.B. auch die Ausgabe von Anfang an auf 0 setzen (Ausgabe = 0). Dann wird im else-Fall einfach Ergebnis: 0 ausgegeben.
An dieser Stelle vielen Dank an Sn0wm4n, der mich auf diesen Fehler hingewiesen hat! (Ich hatte es vorher mit einem else gelöst!)
In diesem Beispiel kann ich euch leider nur ungeschickt die else-Anweisung zeigen, da ich für jede if-Anweisung ein else bräuchte und somit pro else im Fall false des ifs ein printf() ausgegeben werden würde. Deshalb muss ich hier am Schluss abfragen: "Ist die Eingabe ungleich 0 und ungleich 1 und ungleich 2 und ungleich 3, dann gib ... aus".
Kurze Info zur &&-Verknüpfung (logisches UND):
0 steht für false (if-Bedingung nicht erfüllt)
1 steht für true (if-Bedingung erfüllt)
0 & 0 = 0
0 & 1 = 0
1 & 1 = 1
Dann noch zum Ungleich etwas. Bei if-Abfragen könnt ihr fragen:
* == : ist gleich (immer zwei = !!!)
* != : ist ungleich
* > : ist größer als
* < : ist kleiner als
* >= : ist größergleich (größer oder gleich)
* <= : ist kleinergleich (kleiner oder gleich)
Viel Spaß damit
! Achja der Compiler is umsonst 
