 |
|
|
|
Ähnliche Berichte:
|
Papers in anderen sprachen:
|
|
informatik referate |
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()
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>
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.
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.
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.
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 können auf zwei verschiedene Arten in den C - Quellcode eingefügt werden.
//Alles was hinter den beiden Doppelstrichen in der selben Zeile steht, gehört zum
//Kommentar
/* 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.
Syntax: for(variable=1;variable<50;variable++)
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
Syntax: while(variable==1)
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:
Syntax: do
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.
Syntax: switch(variable)
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:
Mit den C - Schlüsselwörtern Break und Continue lassen sich Schleifen steuern.
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.
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.
Syntax: if(Bedingung)
else
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:
In einem Feld kann man beliebig viele Datensätze eines Datentypes speichern. Das Feld wird hierbei mit einem Index angesprochen.
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.
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.
Es gibt verschiedene Methoden, wie einer Funktion die benötigten Werte übergeben werden können.
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)
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.
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 Anderungen 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)
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.
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[])
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 Anderungen 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'. Anderungen, 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.
Die folgenden, GUI - spezifischen Befehle funktionieren teilweise nur mit einer Borland C++ Entwicklungsumgebung:
eingabe=eingabeteil->Text.ToDouble();
Der Syntaxteil "eingabeteil" steht für den Namen des Eingabefeldes.
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.
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.
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.
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.
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.
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.
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.
Eine Klasse wird im Headerfile angelegt und beinhaltet die Prototypen der Methoden und die Eigenschaften:
class sparkonto
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;
konto1 Name des Objektes
einzahlen Name der Methode
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)
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
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
Der Body sieht folgendermaßen aus:
sparkonto::sparkonto(double uebergabe)
Auf hier fehlt die Angabe des Rückgabewertes.
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
Der Body sieht folgendermaßen aus:
sparkonto::~sparkonto(double uebergabe)
Ein Rückgabewert ist wiederum nicht vorhanden.
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;
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.
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 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 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)
Auch bei Funktionen gehören geschweifte Klammern in die nächsten Zeile:
void Funktion()
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.
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.
| Referate über:
|
|
Datenschutz |
| Copyright ©
2024 - Alle Rechte vorbehalten AZreferate.com |
Verwenden sie diese referate ihre eigene arbeit zu schaffen. Kopieren oder herunterladen nicht einfach diese # Hauptseite # Kontact / Impressum |
