Grundwissen cc+

Grundwissen C/C++   Inhalt   Inhalt 1 Grundwissen. 3 Elemente in C.. 4 Variablen: 4 Verschiedene Variablentypen: 4 Standard Ein- und Ausgabe: 4 Rechnen in C.. 4 Kommentare: 5 Schleifen.

6 For - Schleife: 6 While - Schleife: 6 DO - While - Schleife: 7 Case - Anweisung. 7 Break und Continue. 8 Break: 8 Continue: 8 IF - Verzweigung. 8 Felder 10 Eindimensionales Feld: 10 Zweidimensionales Feld: 10 Strings. 11 Funktionen. 12 Call by Value.

12 Call by Reference. 13 Übergabe eines Feldes an eine Funktion: 14 GUI - Befehle und Spezialfunktionen. 16 Eingabe aus einem Eingabefeld auslesen und in einer double - Variable speichern: 16 Variableninhalt in einem Label ausgeben: 16 Message Box ausgeben (nur Borland C++ Builder!) 17 Inhalt eines Eingabefeldes in char umwandeln (nur Borland C++ Builder!) 17 Externes Programm oder Batchfile starten. 17 Microsoft Visual Studio. 18 Debuggerfunktionen: 18 Callstack: 18 Shortcuts: 18 Objektorientiertes Programmieren. 19 Deklaration einer Klasse: 19 Konstruktor und Destruktor 20 Konstruktor 20 Destruktor: 21 Vectoren (Nur Borland C++ Builder!) 22 Programmierstile.

23 Kommentare in klassischem C - Stil 23 Geschweifte Klammern. 23 Einrückungen. 23 Quellcodekommentierung. 23   Grundwissen   Ein C - Programm wird mit einem Editor erstellt, der Textdateien ohne eingebettete Steuerbefehle liefert. Um es dann ausführen zu können, muss es compiliert und gelinkt werden. In einen C - Programm endet jede Zeile mit einem Semikolon ; (Achtung, es gibt auch Ausnahmen).

  Ein einfaches C - Konsolenprogramm beginnt immer mit der main - Funktion. Sie ist der Einstiegspunkt ins Programm.   void main() {     /* Hier arbeitet das Programm */ }   Innerhalb dieser geschweiften Klammern stehen dann die einzelnen C - Befehle, die ausgeführt werden sollen.   Am Anfang jedes Programms müssen sog. Include - Dateien eingefügt werden.   Syntax: #include <name_der_datei.

h> Elemente in C   Variablen:   Um in C eine Variable verwenden zu können, muss Sie initialisiert werden. Am Anfang des Programms steht dann Variablentyp Variablenname = Wert;   Beispiel: int test=0;   Variablen dürfen nur mit Buchstaben beginnen, danach folgen Buchstaben oder Zahlen. Sonderzeichen und Umlaute sind nicht erlaubt. Case sensitive.   Verschiedene Variablentypen:   int:      Der Variablentyp int kann nur ganze Zahlen aufnehmen, keine Kommazahlen. Er wird vor allem zur Schleifensteuerung verwendet.

Double: Der Variablentyp double ist eine sog. Gleitpunktvariable, d.h. er kann auch mit   Kommazahlen arbeiten. Zusätzlich reicht sein Zahlenraum bis in die Milliarden. String: Der Variable String kann eine Zeichenkette zugeordnet werden, z.

b. ein kleiner Satz, der dann später wieder ausgegeben wird. Auch Zahlen kann String aufnehmen, allerdings stehen sie dann nicht mehr Rechenoperationen zur Verfügung, da String nur die Zahl selbst aufnimmt. Für den Computer hat sie dann genau den gleichen Wert wie die Zahl als Wort geschrieben.     Standard Ein- und Ausgabe:   Ein Text kann mit dem Befehl cout auf dem Bildschirm ausgegeben werden.   Syntax: cout<< "Auszugebender Text" << auszugebende_Variable;   Text wird immer in Hochzeichen gesetzt, eine Variable einfach so eingetragen.

  Mit dem Befehl cin kann ein Text oder eine Zahl in eine Variable geschrieben werden.   Syntax: cin>>variable;   Wenn das Programm auf diese Codezeile trifft, hält es an und wartet auf eine Eingabe des Users. Die Eingabe wird dann in die variable geschrieben. Achtung: Diese Funktion ist sehr empfindlich bei falschen Eingaben. Wird einer Int - Variable eine Kommazahl zugeordnet, schmiert das Programm ab.   Rechnen in C   In C gibt es viele Möglichkeiten, mit Zahlen zu rechnen.

Nachfolgend nun einige Beispiele mit verschiedenen Operatoren: Variable = variable + 3;  ®        Zum aktuellen Wert von variable wird 3 addiert. Dann wird der                                                neue Wert zurück in die variable gerschrieben. Variable = a * b;                        ®        Die Werte in a und b werden miteinander multipliziert und das Ergebnis in variable geschrieben. Die Werte in a und b werden nicht verändert. variable++;                    ®        Der Wert von Variable wird um 1 erhöht variable = a % b                        ®        Variable a wird durch Variable b geteilt. Der Rest, der dabei übrig bleibt, wird in variable geschrieben.

  Bei den ersten beiden Beispielen können die Operatoren +, -, *, / beliebig ausgetauscht werden.   Kommentare:   Kommentare können auf zwei verschiedene Arten in den C - Quellcode eingefügt werden.   1.       //Alles was hinter den beiden Doppelstrichen in der selben Zeile steht, gehört zum //Kommentar   2.       /* Ab hier ist alles Kommentar, bis das entsprechende Gegenzeichen kommt. Der Kommentar kann sich auch über mehrere Zeilen erstrecken.

*/   Es empfiehlt sich sehr stark, seinen Quellcode zu kommentieren! Am Anfang sieht man das vielleicht noch nicht ein, aber es hilft extrem, um sich später vor allem in größeren Codes zu orientieren. Speziell die komplizierten Stellen eines Programms sollten kommentiert sein. Nur die zweite Möglichkeit der Kommentierung ist ANSI C - Standard, deshalb sollte nur sie bei C und auch C++ - Programmen verwendet werden. Schleifen   For - Schleife:   Syntax: for(variable=1;variable<50;variable++)             {                 /* Hier folgt der Inhalt der Schleife */             }   Die For - Schleife wird verwendet, wenn die Anzahl der Durchläufe bekannt ist. variable=1: Der Variable wird der Startwert zugeordnet. Dies geschieht nur beim Ersten Durchlauf  der Schleife.

Ab dem zweiten wird dieser Teil ignoriert. variable<50: Die Schleife läuft solange weiter, bis diese Bedingung nicht mehr wahr ist. Sobald der inhalt der variable 50 oder größer beträgt, läuft die Schleife nicht mehr durch. variable++: Der Wert der Variable wird bei jedem Durchlauf um 1 erhöht. Beim ersten Durchlauf  kommt dieser Bereich nicht zum Einsatz. Statt variable++ kann auch variabe=variable+3 an dieser Stelle stehen.

  Struktogramm:                     While - Schleife:   Syntax: while(variable==1)             {                 /* Hier kommt der Inhalt der Schleife */             }   Die while - Schleife wird verwendet, wenn die Anzahl der Durchläufe nicht genau bekannt ist. Da sie eine kopfgesteuerte Schleife ist, wird sie beim ersten Mal nur durchlaufen, wenn die Bedingung "variable==1" auch wahr ist. Ist sie nicht wahr, kann es auch sein, dass die Schleife gar nicht durchläuft.   Struktogramm while und do - while Schleife:       DO - While - Schleife:   Syntax: do             {                 /* Hier folgt der Inhalt der Schleife */               }while(variable==1);   Die Do - While - Schleife wird verwendet, wenn die Anzahl der Durchläufe nicht genau bekannt ist. Da sie eine fußgesteuerte Schleife ist, läuft sie auf jeden Fall einmal durch. Am Ende wird die Bedingung "variable==1" überprüft.

Ist sie wahr, läuft die Schleife noch mal durch. Ist sie unwahr, läuft die Schleife nicht mehr durch.     Case - Anweisung   Syntax: switch(variable)             {                 case 1: /* Hier kommt der Code, der bei diesem Fall ausgeführt werden soll! */         Break;                   case 2: /* Hier kommt der Code, der bei diesem Fall ausgeführt werden soll! */                     Break;                   Default: /* Dieser code wird aktiv, wenn keiner der oberen fälle erfüllt wurde! */             }   Mit der Case - Anweisung kann auf eine Eingabe der Users reagiert und der dazu passende Programmteil präsentiert werden. Switch(variable): Die variable sagt aus, auf welche variable die case - anweisung reagieren soll. Case 1: Der erste Fall. Wurde in der variable eine 1 gefunden, tritt dieser in Kraft.

Break: das break unterbricht die case - anweisung. Danach arbeitet das Programm nach der Case Anweisung wieder weiter. Case 2: Der zweite Fall. Wurde in der variable eine 2 gefunden, tritt dieser in Kraft Default: ist keiner der oberen fälle eingetreten, wird die default anweisung aktiv.   Struktogramm:     Break und Continue   Mit den C - Schlüsselwörtern Break und Continue lassen sich Schleifen steuern.   Break:   Trifft das Programm während eines Schleifendurchlaufes auf das Schlüsselwort break, wird die Schleife sofort abgebrochen, das Programm läuft nach der Schleife weiter.

  Continue:   Trifft das Programm während eines Schleifendurchlaufes auf das Schlüsselwort continue, springt es sofort zur Schleifenbedingung. Dabei ist es egal ob die Bedingung am Anfang oder am Ende der Schleife steht. Die Bedingung wird dann geprüft. Ist sie wahr, läuft die Schleife weiterhin weiter, ist sie falsch, läuft sie nicht mehr weiter.   IF - Verzweigung   Syntax: if(Bedingung)             {                 /* Wenn die Bedingung wahr ist, wird dieser Bereich abgearbeitet */             }             else             {                 /* Wenn die Bedingung falsch ist, wird dieser Bereich ausgeführt, sonst nicht! */             }   Die IF - Verzweigung wird verwendet, um in einem Programm Entscheidungen zu treffen. Somit kann auf eine bestimmte Situation reagiert werden.

If(Bedingung): Wenn die Bedingung in der Klammer wahr ist, wird der folgende Bereich in der geschweiften Klammer ausgeführt. Ist die Bedingung aber falsch, wenn das   Programm darauf trifft, wird der else Bereich abgearbeitet. Der obere Bereich wird dann ignoriert. Der else Bereich kann auch weggelassen werden. Else if:                          Wenn man mehrere Verzweigungen hintereinander abfragen möchte, kann man Sie mit else if "hintereinanderschalten. Jedes else if hat seine eigene Bedingung   dahinter stehen.

Ist die erste Bedingung falsch, wird die zweite Bedingung abgefragt. Wenn eine richtig ist, wird der Inhalt dazu ausgeführt, dann werden die anderen übersprungen und das Programm läuft am Ende der IF - Schleife weiter. Struktogramm:         Felder   In einem Feld kann man beliebig viele Datensätze eines Datentypes speichern. Das Feld wird hierbei mit einem Index angesprochen.   Eindimensionales Feld:   Deklaration: double feld[10]   Dieses Feld kann 10 double - Werte aufnehmen. Um einen Wert an eine bestimmte Stelle zu schreiben, wird folgende Syntax verwendet: feld[4-1] = 120; Hierbei wird an Position 3 der Wert 120 geschrieben.

  Jedes Feld beginnt bei null und geht bis n-1, d.h. der erste Datensatz steht an Position 0, der letzte an n -1. n steht für den Anfangswert, mit dem das Feld angelegt wurde, in diesem Fall 10.   Zweidimensionales Feld:   Deklaration: double feld[10][10];   Dieses Feld kann 100 Datensätze aufnehmen. Um einen Wert an eine bestimmte Stelle zu schreiben, wird folgende Syntax verwendet: feld[4-1][5-1] = 100; Hiermit wird in Zeile 5, Spalte 4 der Wert 100 geschrieben.

Auch hier gilt, dass der Index bei null beginnt. Strings   Funktionen   Es gibt verschiedene Methoden, wie einer Funktion die benötigten Werte übergeben werden können.   Call by Value   Beim Call by Value wird der Funktion eine Kopie der Variablen übergeben. Die Funktion bearbeitet dann die Kopie, der Originalwert im Hauptprogramm wird beibehalten. Bei der Rückgabe kann nur ein Wert mit Hilfe des return - Befehls zurückgegeben werden,   Vorteile: -         Es besteht eine Sicherungskopie, falls die Funktion die Werte zerstören sollte.   Nachteile: -         Nur ein Rückgabewert -         Zeit- und Speicheraufwendig, da die Variablem beim Start der Funktion erst kopiert werden müssen.

  Syntax:   Funktionsprototyp:   double NameDerFunktion (double, double);   Das erste double bestimmt den Rückgabewert, danach kommt der Name der Funktion. In der Klammer stehen die Datentypen, die die Funktion aufnimmt.   Funktion:   double NameDerFunktion (double zahl1, double zahl2) {     /* Hier kommen die Befehle der Funktion rein */     return zahl1; }   So sieht die Funktion im Quelltext aus. In die beiden Variable zahl1 und zahl2 werden die Kopien der übergebenen Werte geschrieben. Die Typen müssen mit denen im Funktionsprototyp übereinstimmen. Am Schluss wird der Wert von zahl1 mit dem return - Befehl zurückgegeben.

  Funktionsaufruf:   ergebnis = NameDerFunktion (wert1, wert2);   wert1 und wert2 werden der Funktion übergeben. Der Rückgabewert wird in die Variable ergebnis geschrieben.     Call by Reference   Beim Call by Reference wird der Funktion keine Kopie der Werte übergeben, sondern nur ein Verweis (Pointer) auf die Speicherstelle, an der sie vom Hauptprogramm angelegt wurden. Dadurch muss auch kein Wert zurückgegeben werden, da die Funktion die Variablen direkt an ihrem Ursprungsort bearbeitet und somit die Änderungen gleich vom Hauptprogramm angenommen werden können.   Vorteile: -         Speicher- und Zeitaufwendiges Kopieren der Variablen entfällt. -         Es können mehrere Variable bearbeitet werden     Nachteile: -         Kein Schutz der Werte vor Fehlfunktionen der Funktion     Syntax:   Funktionsprototyp:   void NameDerFunktion (double&, double&);   Das void signalisiert, dass kein Wert zurückgegeben wird.

Mit dem & nach dem Varaiblentyp erkennt der Compiler, dass nur die Speicheradresse übergeben wird.   Funktion:   void NameDerFunktion (double& zahl1, double& zahl2) {     /* Hier kommen die Befehle der Funktion rein */ }   In zahl1 wird die Adresse der ersten übergebenen Variable gespeichert. Sobald sie verwendet wird, schreibt das Programm den Wert an die in der Variable angegebene Adresse oder liest ihn von dort. zahl1 kann wie eine normale Variable verwendet werden.   Funktionsaufruf:   NameDerFunktion(wert1, wert2);   Am Aufruf ändert sich bis auf die Tatsache, dass keine Variable für die Rücknahme bereitgestellt werden muss, nichts.     Übergabe eines Feldes an eine Funktion:   Felder werden nie als Kopie an eine Funktion übergeben, das Programm übergibt immer nur einen Pointer.

Dies macht der Compiler automatisch, um Resourcen zu schonen, da ein Feld sehr groß werden kann und dadurch die Kopie viel Zeit in Anspruch nehmen würde. Trotzdem muss die Syntax speziell angepasst werden:   Funktionsprototyp:   void NameDerFunktion (double [] );   Das void signalisiert wieder, dass kein Wert zurückgegeben wird. Durch die leere eckige Klammer erkennt der Compiler, dass hier ein double - Feld mit einer unbestimmen Anzahl Positionen übergeben wird.   Funktionsaufruf:   Umrechnen(feld);   Am Funktionsaufruf ändert sich nichts, wichtig ist nur, dass nur der Name des Feldes angegeben wird, keine genaue Positionsangabe in Klammer dahinter.   Funktion:   void Umrechnen(double zahl[]) {     /* Hier kommen die Befehle rein */ }   Die Funktion beginnt mit einem void. Danach wird in der Klammer ein Feld angelegt, welches die Adresse des übergebenen Feldes aufnimmt.

Die eckige Klammer bleibt wiederum leer, da die Anzahl der Positionen nicht bekannt ist. In der Funktion kann dann das Feld ganz normal angesprochen werden. Dabei wird aber immer der Originalwert aus dem Hauptprogramm editiert. Pointer (Zeiger)   Ein Zeiger ist ein wichtiges Element in C. Er zeigt auf einen bestimmten Speicherbereich, der dann von ihm editiert wird. So kann z.

B. dem Zeiger ,a' gesagt werden, dass er auf den Speicherbereich der Variable ,b' zeigen soll. Immer wenn nun der Zeiger ,a' verwendet wird, z.B. um seinen Wert auszulesen oder was reinzuschreiben, wird nun direkt der Speicherbereich von ,b' editiert. ,a' und ,b' sind also sozusagen das Gleiche, alle Änderungen die ich mit ,a' mache, betreffen auch ,b'.

  Beispiel:   int b =0; int *a = 0;   Zuerst wird ganz normal eine Variable ,b' initialisiert. Ihr wird der Wert 0 zugeordnet. Danach wird ein Pointer initialisiert, der Pointer ,a'. Der Compiler erkennt dies am vorgesetzten Stern. Er wird auch mal mit 0 deklariert, was aber hier noch keine Auswirkungen hat.   a = &b;   Mit dieser Syntax wird dem Pointer ,a' die Adresse von ,b' zugeordnet.

In Zukunft zeigt nun ,a' immer auf den Speicherbereich von ,b'. Änderungen, die dort durchgeführt werden, betreffen somit beide Variablen.   *a = 123;   Hier wird an den zugewiesenen Speicherplatz der Wert 123 geschrieben. Der Compiler erkennt durch den Stern, dass die Speicherstelle, auf die der Pointer zeigt, modifiziert wird, und nicht die Adresse, auf die er zeigt.   a = &andere_variable;   Hier wird dem Pointer ein neues Ziel gegeben. Er zeigt nun auf den Speicherbereich von andere_variable.

  Zusammenfassend lässt sich sagen, dass es zwei Methoden gibt, einen Pointer zu verwenden. Wird er wie eine normale Variable behandelt, modifiziert man immer die Adresse, auf die er zeigt. Benutzt man ihn dagegen mit einem vorgestellten *, wird immer der Wert, der an der Speicherstelle steht, auf die er zeigt, modifiziert. Natürlich gelten die selben Regeln auf beim Lesen aus einem Pointer. Nur mit vorgestelltem Stern bekommt man den Wert, auf den er zeigt. GUI ( Graphical User Interface)   Eine grafische Benutzeroberfläche ist eine anwenderfreundliche Programmdarstellung.

Sie kann mit der Maus bedient werden. Die GUI ist betriebssystemabhängig und orientiert sich an den Einstellungen des Betriebssystems, in dem es ausgeführt wird.   Beispiel: Wird ein Programm mit GUI erstellt, das zwei Zahlen aufnimmt, muss bei einem deutschen Windows eine Zahl ganz normal eingegeben werden, eine Kommazahl wird natürlich mit einem , (Komma) geschrieben. Wird das selbe Programm aber auf einem amerikanischen Windows ausgeführt, muss bei einer Kommazahl für das Komma (,) ein Punkt (.) eingegeben werden.   Ein Programm mit GUI wird mit einer speziellen Entwicklungsumgebung erstellt, z.

B.Microsoft Visual Studio oder Borland C++ Builder. Die GUI wird auf einem Formular angeordnet. Dort können mit Hilfe von Drag and Drop Buttons, Labels und Eingabefelder angelegt werden. Mit einem Doppelklick auf eines der Felder öffnet sich der Quelltext und man kann den Code, der beim Klick auf diese Schaltfläche ausgeführt werden soll, eingeben. Hier kommt nun normaler C/C++ Code zum Einsatz.

    GUI - Befehle und Spezialfunktionen   Die folgenden, GUI - spezifischen Befehle funktionieren teilweise nur mit einer Borland C++ Entwicklungsumgebung:   Eingabe aus einem Eingabefeld auslesen und in einer double - Variable speichern:   eingabe=eingabeteil->Text.ToDouble();   Der Syntaxteil "eingabeteil" steht für den Namen des Eingabefeldes.   Variableninhalt in einem Label ausgeben:   ausgabe->Caption = Format ("Eingabe: %10.3f", OPENARRAY (TVarRec, (eingabe)));   Im Label mit dem Namen "ausgabe" wird der String "Eingabe:" und dann der Inhalt der Variable "eingabe" ausgegeben. Mit der Zahl hinter dem % lässt sich die Form der Ausgabe bestimmen. Bei diesem Beispiel wird der Wert in Variable "eingabe" mit max.

10 Vorkomma- und 3 Nachkomastellen ausgegeben. Kürzere Syntaxform:   ausgabe->Caption = eingabe;   Bei dieser Form wird einfach der Inhalt von Variable "eingabe" im Label "ausgabe" ausgegeben.   Message Box ausgeben (nur Borland C++ Builder!)   Application->MessageBox ("Dieser Teil wird in der Box ausgegeben","Dieser Teil steht im Titel", 0+16)   Die Zahlen am Schluss bestimmen, mit welchen Auswahlbuttons (Ja, Nein, Ok, Abbruch ...) und mit welchem Icon (Frage, Warnkreuz .

..) die Messagebox geöffnet wird.   Inhalt eines Eingabefeldes in char umwandeln (nur Borland C++ Builder!)   StrCopy (variable1, Eingabe1->Text.c_str());   Mit diesem Syntax wird der Text oder die Zahlen im Eingabefeld "Eingabe 1" mit Hilfe des Befehls "StrCopy" in die Variable "variable1" geschrieben. Nun kann mit ihr wie mit einer normalen Char - Variable weitergearbeitet werden.

  Externes Programm oder Batchfile starten   STARTUPINFO si; PROCESS_INFORMATION pi;   CreateProcess(NULL,"umwandlung.bat",NULL,NULL,FALSE,0,NULL,NULL,&si,&pi);   Die ersten beiden Zeilen müssen bei den globalen Variablen eingefügt werden. Sie werden von diesem Befehl benötigt. CreateProcess können verschiedene Parameter mitgegeben werden. Bei dem oben stehenden Beispiel wird einfach das Batchfile "umwandlung.bat" gestartet.

Es muss hierbei im selben Verzeichnis liegen. Man kann natürlich jede beliebige Datei auf der Platte starten, dazu muss dann eben der absolute Pfad mit angegeben werden. Bsp: Wenn man ein Programm direkt im Root von C: starten möchte, gibt man einfach als zweiten Parameter "c:\neu.exe" an. Der Doppelslash ist nötig, damit der Compiler erkennt dass hier ein Backslash und nicht ein Sonderzeichen dargestellt wird (z.B.

n). Die anderen Parameter können so wie in diesem Beispiel gelassen werden. Sie bieten noch Zusatzfunktionen an. (Genauere Informationen gibt es in der MSDN unter dem Suchwort "Create Process"). Wichtig ist nur noch der sechste Parameter: Wird ein Bachfile oder eine Konsolenapplikation gestartet, lässt sich mit dem Befehl "CREATE_NO_WINDOW" die Anzeige der schwarzen Commandbox verhindern. Das Programm läuft natürlich trotzdem durch.

  Ein alternativer Befehl ist "system".   system(path_to_file); system("xcopy *.c c:test");   Er bietet den Vorteil, dass neben ganzen Programmen auch DOS - Befehle ausgeführt werden können. "system" erstellt eine virtuelle Kommandozeile und führt den Befehl darauf aus. Allerdings ist bei "sytem" immer eine schwarze DOS - Box zu sehen, welche sich nicht unterdrücken lässt.     Microsoft Visual Studio   Debuggerfunktionen:   Callstack:   Der Callstack beinhaltet alle ausgeführten Funktionen.

In ihm kann man sehen, was vom Programm nacheinander ausgeführt wurde. So lässt sich erkennen, welche Funktion welche Funktion aufgerufen hat und wie das Programm bisher abgelaufen ist.   Shortcuts:   F9: Setzt einen Breakpoint im Code F5: Wenn während des Debuggens der Debugger an einem Breakpoint anhält, kann damit das Programm fortgesetzt werden. F11: Während des Debuggens kann Zeile für Zeile fortgeschritten werden. Trifft man auf eine            Funktion wird eingesteppt. F10: Während des Debuggens kann Zeile für Zeile fortgeschritten werden.

Funktionen werden         hierbei aber übersprungen. Objektorientiertes Programmieren   Objektorientierte Programmierung ist Programmierung in C++. Es werden Klassen definiert, die ein bestimmtes Objekt beschreiben, seine Fähigkeiten und Eigenschaften festlegen. Eine Klasse ,sparkonto' besitzt zum Beispiel die Methoden ,einzahlen' und ,auszahlen'. Als Eigenschaften hat sie ein ,guthaben'.   Klassenname: Name der Klasse Objekt:            Angelegtes Objekt, welches aus der Klasse besteht.

Von jeder Klasse können mehrere Objekte bestehen. Methoden:      Fähigkeiten eines Objektes, z.B. Geld abheben. Es entspricht eigentlich einer Art Funktion. Eigenschaften: Die Eigenschaften sind Variablen, welche bestimmte Werte, Eigenschaften des Objekts aufnehmen, z.

B. beim ,sparkonto' das Guthaben oder den Zinssatz.     Deklaration einer Klasse:   Eine Klasse wird im Headerfile angelegt und beinhaltet die Prototypen der Methoden und die Eigenschaften:   class sparkonto {     public:     double einzahlen(double betrag);     double auszahlen(double betrag);     private:     double Guthaben; };   public:  Die Methoden sind meist im public - Bereich der Klasse definiert. Auf sie kann von außen zugegriffen werden. Private: Die Eigenschaften dagegen sind meist private, da man sie von unberechtigtem Zugriff von außen schützen möchte.   Um auf eine Methode zugreifen zu können, wird die gleiche Syntax wie bei einer Struktur verwendet.

Zuerst kommt der Name des Objektes, danach ein Punkt und der Methodenname:   konto1.einzahlen(100);   konto1:           Name des Objektes einzahlen:       Name der Methode (100):              Werte, die an die Methode mitgegeben werden.     Die Methoden müssen natürlich genauso wie normale Funktionen definiert werden. Nachfolgend nun ein Beispiel, wie die Methode ,einzahlen' aussehen würde:   double sparkonto::einzahlen(double betrag) {     guthaben+=betrag;     return guthaben; }   Der Kopf besteht aus dem Rückgabewert, dem Name der Klasse, danach dem Namen der Metode und zum Schluss noch die Parameterliste. Er muss mit der Deklaration in der Headerdatei übereinstimmen. Die Eigenschaften (in diesem Fall das ,guthaben') können ohne Deklaration direkt verwendet werden.

    Nun fehlt nur noch das Anlegen eines Objektes. Dies unterscheidet sich aber nicht wesentlich vom Anlegen einer Variable:   sparkonto konto1(uebergabe);   sparkonto:      Zuerst der Name der Klasse konto1:           Name des Objektes, welches angelegt werden soll. (uebergabe):  Übergabeparameter für den Konstruktur     Konstruktor und Destruktor   Konstruktor   Mit einem Konstruktor kann ein neues Objekt beim Start initialisiert werden. Es können bestimmte Werte mitgegeben werden, um die Variablen zu initialisieren. So kann z.B.

vor dem Anlegen eines Sparkontos der Startwert abgefragt und dieser dann an den Konstruktor übergeben werden. Er initialisiert dann die ,Guthaben' - Eigenschaft bei der Erstellung des Objektes.   Der Konstruktor muss ebenfalls in der Headerdatei festgelegt werden. Er bekommt immer den Namen der Klasse. Da er keinen Rückgabewert hat, wird dieser Code weggelassen.   class sparkonto {     public:     sparkonto(double uebergabe);     double einzahlen(double betrag);     double auszahlen(double betrag);     private:     double Guthaben; };   Der Body sieht folgendermaßen aus:   sparkonto::sparkonto(double uebergabe) {     guthaben = uebergabe; }   Auf hier fehlt die Angabe des Rückgabewertes.

  Destruktor:   Der Destruktor hat eigentlich die selbe Aufgabe wie der Konstruktor. Allerdings wird er am Ende eines Programmes aufgerufen, oder wenn ein Objekt aus dem Speicher gelöscht wird. Mit ihm können Aufgaben durchgeführt werden, die unbedingt am Ende eines Objektes erledigt werden müssen, z.B. Löschung vertraulicher Daten aus dem Speicher oder der Festplatte etc.   Deklariert wird er wieder im Header und hat ebenfalls den Namen der Klasse, allerdings mit einer vorgesetzten Tilde (~):   class sparkonto {     public:     ~sparkonto(double uebergabe);     sparkonto(double uebergabe);     double einzahlen(double betrag);     double auszahlen(double betrag);     private:     double Guthaben; };   Der Body sieht folgendermaßen aus:   sparkonto::~sparkonto(double uebergabe) {     guthaben = uebergabe; }   Ein Rückgabewert ist wiederum nicht vorhanden.

Vectoren (Nur Borland C++ Builder!)   Vectoren sind erweiterte Arrays. Sie können beliebig viele Elemente einer Gruppe (z.b. nur Integerwerte) speichern. Zusätzlich gibt es Methoden, die das Bearbeiten des Vectors ermöglichen. Man kann ohne Probleme Container anhängen, bearbeiten oder aus dem Vector löschen (Bei einem Vector werden die einzelnen Speicherplätze Container genannt).

Der große Vorteil von Vectoren liegt in ihrer Dynamik. Sie passen ihre Größe dynamisch während der Laufzeit an. Somit muss nicht im Vorfeld vom Programmierer definiert werden, wie viele Elemente zur Verfügung stehen.   Ein Vector kann nur unter C++ verwendet werden. Zuerst muss die Includedatei "vector" eingebunden werden. Der Vector selbst wird mit folgendem Code angelegt:   #include "vector"   vector <int> name_des_vectors;   Das <int> gibt den Typ der Elemente an, welche der Vector speichern soll.

Es können gleich wie bei einem Array nur Elemente eines Typs gespeichert werden. name_des_vectors definiert den Namen.   name_des_vectors.push_back(50);   Mit diesem Code wird ein neuer Container ans Ende des Vectors angehängt und der Wert 50 reingeschrieben.   name_des_vectors.pop();   Das letzte Element des Vectors wird gelöscht.

  name_des_vectors[10];   Zum Zugriff auf einzelne Container kommt die gleiche Syntax wie bei einem normalen Array zum Einsatz. Hier wird auf den Container mit dem Index 10 zugegriffen und sein Inhalt zurückgegeben. Alternativ kann auch der Code name_des_vectors.at[10] verwendet werden.   name_des_vectors.insert(10,50);   Dieser Code fügt einen neuen Container mit dem Inhalt 50 an Index 10 ein.

Der bisher dort stehende Container wird um eine Position verschoben, sein Index erhöht sich um 1. Dementsprechend werden auch alle nachfolgenden Container um eine Position verschoben. Programmierstile   Jeder Programmierer schreibt seinen (C -) Quellcode anders. Die einen achten penibel auf Einrückungen und übersichtliche Klammersetzung, andere packen so viel Code wie möglich in eine Zeile. Um Quellcode übersichtlich und vor allem für Andere verständlich zu halten, sollte man sich allerdings an bestimmte Programmierstile halten. Die folgenden Grundregeln stimmen nicht unbedingt mit offiziellen Dokumenten der ANSI oder anderen überein.

Sie sind aber trotzdem sinnvoll, wenn man sich einheitlich daran hält.   Kommentare in klassischem C - Stil   Kommentare sollten immer in Verbindung mit folgender Syntax verwendet werden:   /* Das ist ein Kommentar */   Nur diese Kommentarzeichen gehören zum ANSI C -  Standard. Zusätzlich soll nach dem Kommentarzeichen eine Leerstelle vorhanden sein.   Geschweifte Klammern   Geschweifte Klammern sollten immer gesetzt werden, auch wenn sie bei einzeiligen If - Strukturen oder Schleifen weggelassen werden können. Das erhöht die Übersichtlichkeit und Lesbarkeit des Codes. Geschweifte Klammern werden immer in eine eigene Zeile gesetzt, also in die nächste Zeile nach dem Schlüsselwort:   If (a) {     for(i=0;i<10;i++)     {          /* code */     } }   Auch bei Funktionen gehören geschweifte Klammern in die nächsten Zeile:   void Funktion() {     /* code */ }   Einrückungen   Nach geschweiften Klammern wird der Code grundsätzlich eingerückt.

Dafür aber besser an Stelle eine Tabs fünf Leerzeichen verwenden. Ein Tab kann von verschiedenen Programmen unterschiedlich interpretiert werden. Ein Code, erstellt in Editor X sieht dann in Editor Y ganz anders aus, das Layout ist u.U. zerhackt. Leerzeichen dagegen werden immer gleich interpretiert.

  Quellcodekommentierung   Alle wichtigen Elemente des Codes müssen ausreichend kommentiert sein, damit sie auch von anderen Entwicklern schnell verstanden werden. Lieber ein paar mehr Kommentare schreiben als wichtige Stellen unerklärt lassen. Auch vor jede Funktion gehört eine kurze Beschreibung über ihre Aufgabe, die Rückgabewerte und Übergabeparameter.

Suchen artikel im kategorien
Schlüsselwort    Kategorien    - kategorien - astronomiebiographienbiologiechemiedeutschenglischfranzosischgeographiegeschichtehauswirtschaftinformatikitalienischkunstlateinliteraturmathematikmusikphilosophiephysikpolitikpsychologierechtsozialkundesporttechnikwirtschaft	•  Zusammenfassung Der Vorleser  •  sachtextanalyse  •  interpretation zwist  •  Fabel interpretation  •  literarische charakteristik  •  interpretation bender heimkehr  •  felix lateinbuch  •  interpretation der taucher von schiller  •  textbeschreibung  •  charakterisierung eduard selicke

Anmerkungen: * Name: * Email: URL: * Diskussion: (NO HTML)

| impressum | datenschutz