Sie sind auf Seite 1von 41

Vorwort Top

Dieser Artikel ist ein Gemeinschaftstutorial von Online-tutorials.net, jeder kann es unter Editieren verbessern.

Um besser lernen zu können solltest du alle Beispiele abtippen, und nicht kopieren, es wäre gut, wenn du dir, nachdem du etwas neues gelernt hast, darüber Gedanken machst, ob du dazu ein Beispiel schreiben kannst, und es als Vorschlag hier postest.

Wenn du fragen hast, kannst du sie gerne im Forum posten.

Wir haben übrigens geplant aus diesem Tutorial eine Tutorialserie zu machen, die am Schluss eine ausführliche Einführung in DirectX macht. Als Krönung gibt es dann vielleicht am Ende eine kleines 3D-Spiel.

Warum dieses Tutorial geschrieben wurde/wird Top

Es gibt zwar tausende C++ Tutorials im Internet, aber ich habe noch kein einziges Tutorial gesehen mit dem ich richtig zufrieden war, die meisten Tutorials die ich kenne halten sich nicht an den C98 Standard, und schaden mehr als sie bringen.

Ich werde alles daran setzen, das sich dieses Tutorial an den C++ Standard hält.

Hilfe Top

Jeder der noch etwas verbessern oder ergänzen will ist herzlich dazu eingeladen. Wenn du was verändert hast, kannst du dich unten als Autor mit deiner Veränderung eintragen, damit das die anderen Wissen

deiner Veränderung eintragen, damit das die anderen Wissen Software Top Vor's losgeht brauchst du noch einen

Software Top

Vor's losgeht brauchst du noch einen Compiler bzw. eine IDE, hier solltest du etwas finden:

Wenn du bereit bist etwas Geld auszugeben, würde ich dir MS C++ Studio .net empfehlen, ein IDE das zwar sehr teuer ist, aber dafür auch sehr Leistungsfähig.

Kapitel 1: Grundlagen Top

Ok, nachdem du die IDE gestartet hast, und ein neues Projekt angefangen hast, können wir anfangen:

Das erste Programm Top

Es ist eine Programmierer-Tradition, das man beim ersten Programm in einer neuen Programmiersprache immer ein Programm schreibt, das Hello World auf den Bildschirm ausgibt, das machen wir jetzt auch.

Gib also folgendes ein, und kompilere und starte es dann:

Code:

#include <iostream>

using namespace std;

int main()

{

cout << "Hello World";

return 0;

}

Es sollte Hello World auf dem Bildschirm erscheinen, wenn nicht hast du ein Problem mit dem Compiler/der IDE, frag im C++ Forum wie man ihn bedient.

Unter Windows wird sich das Programm wahrscheinlich sofort wieder schließen, das kann man umgehen, indem man in die Kommandozeile (Start->Ausführen-> cmd eingeben) geht, dort zum Directory geht, und das Programm dann manuell startet.

Ansonsten kann man am Schluss, vor return 0; folgendes benutzen, das wird aber erst später erklärt:

Code:

cin.clear();

cin.ignore(cin.rdbuf()->in_avail());

cin.get();

Ok, du hast es also geschafft, dein erstes Programm ;-)

Erklärung

Header Top

Code:

#include <iostream> #include <cstdio> #include <string>

#include sagt dem Programm, das es Befehle aus der Datei zwischen den <> Klammern laden soll.

Anmerkung:

Bei STL Headern wird kein .h verwendet (#include <iostream>;#include <string>, und vor Standard -Header, die für C geschrieben wurden, wird ein c gesetz, und ebenfalls kein .h verwendet. (#includ e <cstdio>

int main() sagt dem Compiler dass das Programm hier anfängt, alles was zwischen den {} Klammern steht wird schrittweise durchgemacht. {} Klammern sind immer Anweisungsblöcke, alles was dazwischen steht gehört zusammen.

Das Programm beginnt jetzt bei der { Klammer, und geht zu cout, cout gibt eine Zeichenkette aus.

Alles was zwischen den " " Zeichen ist, ist eine Zeichenkette, alles zwischen ' ' ist ein Buchstabe.

Jeder Befehl in C++ hat einen Strichpunkt ; am Schluss, dabei ist es egal ob der Befehl über mehrere Zeilen geht, solange kein String offen ist.

Jetzt sagen wir der Konsolleanwendung das das Programm ordnungsgemäß, ohne Probleme beendet wurde: return 0;

Die Klammer } schließt die main Funktion ab.

using namespace std; wird später erklärt, dazu brauchst du noch weiteres Wissen.

Das nächste Programm Top

Ich hoffe du hast die Erklärung vom letzen Programm verstanden, wenn nicht kannst du im Forum fragen.

Kommentare

Ok, nimm das erste Programm, und füge folgendes am Anfang hinzu:

Code:

//Mein zweites Programm

/*

main.cpp

*/

Das sind Kommentare, es gibt in C++ 2 verschiedene Varianten Kommentare zu setzen.

Die erste Variante behandelt alles nach // bis zum Zeilenende als Kommentar, der vom Compiler einfach ignoriert wird.

Bei der 2. Variante wird alles zwischen /* und */ über mehrere Zeilen als Kommentar behandelt, und vom Compiler ignoriert.

Wenn du das Programm jetzt kompilierst, sollte das gleiche passieren wie beim letzen mal.

Steuerzeichen, cout, flush,

Tippe jetzt folgende Zeilen ab, und kopier sie zwischen die beiden {} Klammern, nach int main().

Code:

cout << "Hi,\n"; cout << "das hier ist mein 2. Programm," << " das Steuerzeichen,"; cout << " Kommentare, und\nflush() erläutert." << endl << endl; cout.flush();

Das ganze sollte jetzt so aussehen:

Code:

//Mein zweites Programm

/*

main.cpp

*/

#include <iostream>

using namespace std;

int main()

{

cout << "Hi,\n"; cout << "das hier ist mein 2. Programm," << " das Steuerzeichen,"; cout << " Kommentare, und\nflush() erläutert." << endl << endl; cout.flush();

return 0;

}

Fertig kompiliert, und ausgeführt sollte es jetzt folgendes Ausgeben:

Hi, das hier ist mein 2. Programm, das Steuerzeichen, Kommentare, und flush() erlaeutert.

Erklärung

Wie du hier siehst kann man mit cout noch viel mehr machen, als im ersten Programm.

Man kann z.B. mehrere Strings (Zeichenketten) hintereinander ausgeben lassen:

Code:

cout << "Text1" << "Text2";

Ausgabe: Text1Text2

Dann kann man mit sogenannten Steuerzeichen verschiedene Sonderaktionen machen:

Code:

\n Macht einen Zeilenumbruch: New Line \r Macht einen Wagenrücklauf (Return) \a Signalton \\ Macht ein Backslash (\) \b Backspace, löscht das linke Zeichen \f Formfeed, macht einen Seitenvorschub

\t Macht einen horizontalen Tabulator \v macht einen vertikalen Tabulator \" Macht ein " \' Macht ein '

Wenn man diese Zeichen in den Text einfügt, machen diese Zeichen ihre Aufgabe, so gibt z.B. cout << "Text\nText2"; folgendes aus:

Text

Text2

Obwohl es eigentlich 2 Zeichen sind, werden sie als eines gezählt.

Wie man ä,ö, und ü's macht erfahrt ihr hier.

cout gibt den Text in einen Ausgabenbuffer, das ist einfach ein Stück Speicher, das reserviert wurde.

Der Ausgabebuffer normalerweise am Schluss geleert wird, aber manchmal kann der auch durcheinander kommen, und darum verwendet man cout.flush();

cout.flush(); macht einfach das alles was im Moment im Buffer ist ausgegeben wird.

So, jetzt bleibt nur noch endl, endl kann man zwischen diese << Output-Operatoren geben, als wär es ein String.

endl mach 2 Dinge:

1. \n

2. cout.flush();

d.h. Zuerst wird eine neue Zeile angefangen, und danach wird der String ausgegeben.

Variablen Top

Variablen sind Speicherteile, die einen Wert speichern können.

Man kann ihnen einfach einen Wert zuweisen, und wieder auslesen.

Bevor man eine Variable benutzen kann muss man sie initialisieren, um Fehler vorzubeugen, und die richtige Größe benutzen zu können.

Schauen wir uns dazu ein Beispiel an:

Code:

/*

main.cpp

*/

#include <iostream>

using namespace std;

int main()

{

int z; int i = 3;

cout << "Der Wert der Variablen: " << i << "/" << z << endl;

return 0;

}

Ausgabe:

Der Wert der Variablen: 3/-858993460

Mit int z wird eine Variable im Speicher reserviert. int i = 3; reserviert die Variable mit dem Namen i und setzt sie auf 3. Man kann diese Variable dann mit cout wie eine Zeichenkette ausgeben.

Wenn man mehrere Variablen vom gleichen Typ reservieren will, so kann man sie mit einem Beistrich nebeneinander schreiben:

//Reserviert i, z, Test, und y int i,z,Test,y;

int ist der Variablentyp, es gibt folgende verschiedene:

int Eine ganze Zahl(ohne Komma), auf englisch Integer. char Ein Buchstabe bool kann true oder false sein float Eine Kommazahl double Eine sehr große Kommazahl mit mehr stellen als float short Kleiner int long Kann vor Variablen stehen, und vergrößert sie signed Kann vor Variablen stehen, und erlaubt die Verwendung von positiven und negativen Zahlen unsigned Erlaubt nur positive Zahlen, dadurch wird der Wertbereich größer

Du wirst im laufe der Zeit noch auf viele Variablentypen treffen, Tante Google wird dir sicher helfen, falls ein Typ unklar ist.

Anmerkung:

Ein Komma wird in C++ nicht wie im Deutschen mit einem Beistrich, sondern wie im Englischen

mit einem Punkt gemacht.

Wenn eine Variable überschritten/unterschritten wird, fängt sie von vorne(dem Mindestwert)/vom Ende(höchstwert) wieder an.

Beispiel:

int i = 214748357; cout << i;

Ausgabe: -2147483639

Dies nennt man overflow/underflow.

Achtung

Wenn man Variablen nicht initialisiert, haben sie je nach Compilereinstellungen 0, oder nicht, man sollte beim Programmieren bedenken, das sie beim Start nicht umbedingt 0 haben muss, und sie eventuell auf 0 setzen.

Um eine Variable einzulesen kann man cin benutzen.

Cin funktioniert ähnlich wie cout, nur das der Operator in die andere Richtung zeigt: >>

Code:

/*

main.cpp

*/

#include <iostream>

using namespace std;

int main()

{

int z;

cout << "Bitte geben Sie eine Zahl ein: " << endl;

cin >> z;

cout << "z hat den Wert: " << z << endl;

return 0;

}

Operatoren Top

Man kann Variablen auch manuell setzen dazu macht man folgendes (Zuweisungsoperator):

Code:

//Initialisiert MeineVariable mit dem Wert 4, ändert anschließend den Wert auf 3 und gibt den Wert der Variable aus.

int MeineVariable = 4;

MeineVariable = 3;

cout << MeineVariable << endl; //Ausgabe 3

//Die Folgende Zeile addiert zuerst MeineVariable & MeineVariable, setzt zuerst MeineZweiteVaria ble, und dann i auf das Ergebniss

i = MeineZweiteVariable = MeineVariable + MeineVariable;

Hier wird die Variable die rechts steht auf den rechten Wert gesetzt.

Mit bestimmten Operatoren kann man Variablen verändern, so kann man mit +,-,*,/ Variablen, oder Zahlen miteinander addieren/subtrahieren/multiplizieren, oder dividieren.

Hier gibt es wieder ein größeres Beispiel:

Code:

/*

main.cpp

*/ #include <iostream>

using namespace std;

int main()

{

int z,x,y,Test;

cout << "Bitte geben Sie eine Zahl ein: " << endl;

cin >> z;

cout << endl << endl << "Bitte geben Sie eine zweite Zahl ein: " << endl;

cin >> x;

y = Test = ((z + x) * x) + 5;

cout << "y hat den Wert: " << y << endl;

return 0;

}

Ausgabe:

Bitte geben Sie eine Zahl ein:

1

Bitte geben Sie eine zweite Zahl ein:

3

y hat den Wert: 17

Ein weiterer Operator ist der Modulo-Operator, er gibt den Rest einer ganzzahlen Division zurück;

int i = 7 % 3; // i ist 1 Rest (7/3 = 2 mal 1 Rest)

Es gibt noch einen Operator: sizeof. Er gibt die Größe der Variable in Bytes zurück.

Code:

/*

main.cpp

*/ #include <iostream>

using namespace std;

int a;

int main()

{

cout << "int: " << sizeof(int) << endl; cout << "char: " << sizeof(char) << endl; cout << "double " << sizeof(double) << endl; cout << "a: " << a << endl;

return 0;

}

Man kann den Typ für sizeof eine Klammer benutzen, oder nicht.

Konstante Top

Gewisse Dinge, wie z.B die Zahl PI sind immer gleich groß.

Für diese Dinge gibt es Konstanten:

const float PI = 3.141592653589;

Diese Variable kann später nicht mehr verändert werden.

Warum man Konstanten benutzt?

Einerseits weil man diese Variablen dann später nicht mehr versehentlich verändern kann, und andererseits machen sie das Programm viel besser lesbar, weil jemand, der den Code noch nie gesehen hat sofort weiß, das diese Variable immer gleich bleibt.

Es gibt 2 Arten von Konstanten: Runtime-Konstanten und Compiletime-Konstante. Runtime Konstante werden erst wärend der Ausführung des Programms erstellt, Compiletime werden beim compilen erstellt.

Hier ein paar Beispiele:

Code:

/*

main.cpp

*/ #include <iostream>

using namespace std;

int main()

{

int a = 5;

const int c = 5; const int x = 5*7;

//Compiletime Konstante //Compiletime Konstante

int d = 0; cin >> d;

const int e = d;

//Runtime Konstante

const int b = a;

//a könnte theoretisch wärend der Laufzeit geändert werden

//Runtime Konstante

return 0;

}

Namensvergabe Top

Für die Benennung der Variablen gibt es einige Einschränkungen:

- Variablennamen dürfen nicht mit einer Zahl am Anfang beginnen: 1Test

- Variablennamen dürfen keine Leerzeichen in der Mitte haben: Test Test

- Variablennamen dürfen keine Sonderzeichen wie keine Zeichen die nicht im Alphabet sind

- Variablen dürfen keine Namen von Funtionen aus den Bibliotheken haben

- Variablen dürfen nicht nach C++ Schlüsselwörter (if, case, class,

z.B.

.;,"< oder + (verwende bis auf _ am besten

) benannt werden

Es gibt verschiedene Konventionen für die Namensvergabe für Variablen. Einige Leute schreiben zum Beispiel jedes Wort in einer Variable groß: IchSpeichereEtwas, FileName. Andere schlagen vor zwischen jeder Variable einen _ zu machen.

Besonders beliebt ist die ungarische Notation, die vor Zeiger ein p, vor Funktionen ein fn, vor Handles ein h usw. setzt. Es ist egal falls du nicht weißt was das ist, dazu kommen wir später. Die ungarische Notation ist für C++ aber auch sehr umstritten, unter anderem, weil man eigene Typen erstellen kann.

Gültigkeitsbereiche Top

Es gibt verschiedene Gültigkeitsbereiche, von denen es wiederum 2 Arten gibt:

- lokale Gültigkeitsbereiche, sie sind zwischen den { } Klammern

- globaler Gültigkeitsbereiche, er ist im gesamten Programm gültig

Globaler Gültigkeitsbereiche:

/*

main.cpp

*/ #include <iostream>

using namespace std;

int a;

//Lokaler Gültigkeitsbereich von Main int main()

{

int b;

a = 33;

b = 3;

//Gültigkeitsbereich - Erste Unterebene von main

{

int c;

a = 3343;

b = 45;

c = 3;

//Gültigkeitsbereich - Unterebene von der ersten Unterebene von main

{

 

int

d;

a

= 3343;

b

= 45;

c

= 3;

d

= 343;

}

//2. Unterebene Ende

//d ist nicht mehr gültig

}

//1. Unterebene Ende

c = 3;

//Fehler c ist nicht mehr gültich

//d ist nich mehr gültig

//Gültigkeitsbereich - Zweite Unterebene von main

{

//Hier ist nur a und b gültig

}

return 0;

}

//Lokaler Gültigkeitsbereich von main Ende

Wenn wir die Struktur anschauen:

Struktur:

- Globaler Gültigkeitsbereich

- Gültigkeitsbereich von Main

- Erste Unterebene von Main - Unterebene der ersten Unterebene von Main

- Gültigkeitsbereich der zweiten Unterebene von Main

Eine Variable immer in dem Gültigkeitsbereich in dem sie reserviert wurde, und in den Unterebene dieses Gültigkeitsbereichs (Verschachtelung) gültig

Man kann zwei Variablen mit dem gleichen Namen reservieren, einmal im lokalen, und einmal im globalen Gültigkeitsbereich, innerhalb des lokalen Gültigkeitsbereiche wird dann immer die lokale Variable benutzt, sonst die globale.

Globaler Gültigkeitsbereiche:

/*

main.cpp

*/ #include <iostream>

using namespace std;

int a = 3;

//Gültigkeitsbereiche von main int main()

{

 

int a = 55;

 

cout << a << endl;

//Gibt 55 aus

{

// überdeckt die lokale wieder d.h. a == 55 ist nur innerhalb eines Gültigkeitsbereichs

 

cout << a << endl;

//Gibt 3 aus

 

}

return 0;

 

}

Kontrollstrukturen Top

Um das Programm flexibler zu machen benötigen wir Kontrollstrukturen. Damit kann man Variablen überprüfen.

Eine Möglichkeit ist mit if/else.

Mit if (Variable) überprüfen wir, ob die Variable true/1 (Wahr), oder false/0 (Falsch) zurückgibt.

Wenn es wahr ist, wird das in den { } Klammern ausgeführt.

Code:

/*

main.cpp

*/ #include <iostream>

using namespace std;

int main()

{

int a,b;

cout << "Gitte geben Sie bitte eine Zahl ein:" << endl;

cin >> a;

cout << endl << "Gitte geben Sie bitte nochmal eine Zahl ein:" << endl;

cin >> b;

if (a == b)

{

cout << "Beide Zahlen sind gleich";

}

if (a < b) cout << "a ist kleiner als b";

//Wenn die Anweisung in der Klammer nur eine Anweisung umfasst, dann kann man die Klamm ern weglassen if (a > b) cout << "b ist kleiner als a";

return 0;

}

Wie wir hier sehen gibt es in C++ Vergleichsoperatoren, sie vergleichen 2 Variablen, und geben true oder false zurück.

Vergleichsoperatoren:

== ist gleich

!= ungleich < kleiner als > größer als <= kleiner oder gleich >= größer oder gleich

Wichtig:

In anderen Programmiersprachen vergleicht man nicht mit == sondern mit =, in C++ weist = einer Variable einen Wert zu, und gibt dann true zurück.

int a = 5;

if (a = 3)

{

cout << "test";

}

Gibt IMMER test aus, und setzt a auf 3!

Es gibt ausserdem noch else und ifelse, wenn man if benützt, kann man ifelse (Ansonsten wenn) und else benutzen:

Code:

/*

main.cpp

*/ #include <iostream>

using namespace std;

int main()

{

int a,b;

cout << "Gitte geben Sie bitte eine Zahl ein:" << endl;

cin >> a;

cout << endl << "Gitte geben Sie bitte nochmal eine Zahl ein:" << endl;

cin >> b;

//Wenn a ist gleich b if (a == b)

{

cout << "Beide Zahlen sind gleich";

}

//Wenn if oben false ist überprüfe ob a kleiner als b ist else if (a < b)

{

cout << "a ist kleiner als b";

}

//Ansonsten gib b ist kleiner als a aus

else

{

cout << "b ist kleiner als a";

}

if (a = 3) cout << endl << endl << "Das hier beweist, das = einen Wert zuweist, und immer true zurückli efert." << endl;

if (a != b) cout << endl << a << " ist nicht " << b << endl;

//Wie in der Mathematik kann man beliebig Klammern setzen, das UND dreht das Ergebnis um (t rue wird zu false und false zu true) if (!(a != b)) cout << endl << a << " ist " << b << endl;

//0 ist das gleiche wie false, alles andere ausser 0 ist true if ((a == b) == 0) cout << endl << a << " ist nicht" << b << endl;

return 0;

Wie in einem Beispiel weiter oben angedeutet kann man, wenn zwischen den { } Klammern nur eine Anweisung ist, die Klammern weglassen.

Jetzt fehlt uns nur noch das UND (&&), und das ODER (||).

Code:

if (a == b && a == 3) cout << " a und b haben den Wert 3." << endl;

if (a == 4 || a == 3) cout << " a hat den Wert 3 oder 4." << endl;

Der Ausdruck wird in C++ nur soweit ausgewertet, bis das Ergebnis feststellt. Bei if (a == 4 || a == 3) wird nur (a == 4) ausgewertet (wenn (a == 4) true ist), und der Rest stehengelassen, da die erste Bedingung sowieso true zurück gibt.

Bei (a == b && a == 3) wird a == 3 nicht ausgewertet, wenn a == b false ergibt. Das nennt man Lazy Evaluation.

Switch Top

Wenn man eine bestimmte Variable oft überprüfen will, kann man auch switch verwenden. Dabei wird eine Variable (char oder int) überprüft:

Code:

/*

main.cpp

*/ #include <iostream>

using namespace std;

int main()

{

//Reserviert die Variable i int i = 0;

cout << "Bitte geben Sie eine Zahl ein: " << endl;

cin >> i;

//DIE IF VARIANTE

if(i == 0) cout << "Null"; else if(i == 1) cout << "Eins"; else if(i == 2) cout << "Zweit"; else cout << "Die Zahl ist größer als zwei";

//DIE SWITCH VARIANTE

switch(i)

{

case 0:

cout << "Null"; break;

case 1:

cout << "Eins"; break;

case 2:

cout << "Zwei"; break;

default:

cout << "Die Zahl ist größer als zwei"; break;

}

return 0;

}

Dadurch wird der Code zwar größer, aber er ist besser zu lesen. Bei switch erstellt der Computer eine Sprungtabelle, was die Performance verbessert.

Mit switch(Variablenname) gibt man dem Compiler an, welche Variablen man benutzen will, case überprüft auf den Wert danach, und ab dem Doppelpunkt werden Befehle ausgeführt. Break bestimmt, das der case fertig ist.

Default ist das gleiche wie else bei den if-statements, es wird benutzt, wenn alle anderen Abfragen nicht passen.

Code:

switch(i)

{

case 1:

case 2:

case 3:

cout << "gültig"; break; default:

cout "Bitte geben Sie eine gültige Zahl zwischen 1 und 3 ein."; break;

}

Bei diesem Beispiel, wird das case nicht sofort mit einem break beendet, d.h. wenn i 1 ist, geht es so weit, bis break kommt. Dadurch spart man sich viel Code.

Schleifen Top

Schleifen sind dazu da bestimmte Vorgänge wiederholen zu lassen. Wenn wir z.B. ein eine Zins- Rechnung machen, dann können wir das Programm solange wiederholen, bis der Anwender 0 eingibt.

Die while Schleife Top

while(bool) wiederholt alles zwischen den {} (kann man wie üblich weglassen, wenn nur ein Befehl kommt), solange wie die Variable true ist.

Hier ein Beispiel:

Code:

/*

main.cpp

*/ #include <iostream>

using namespace std;

int main()

{

int iLoop = 1;

// Wenn iLoop false (0) ist, dann macht die Schleife nach dem Durchgang (falls im Moment einer läuft) nicht mehr weiter. while(iLoop)

{

cout << "Geben Sie bitte eine Zahl ein (0=Quit) "; cin >> iLoop;

if(!iLoop)

//Mit ! dreht man das Ergebnis um, wenn iLoop false (0) ist, dann wird true daraus

, und wenn es true ist, wird false(0) daraus. cout << endl << "cya" << endl << endl; else cout << endl << iLoop << "+2 ist " << iLoop +2 << endl;

}

return 0;

}

Ausgabe:

Geben Sie bitte eine Zahl ein (0=Quit) 43

43+2 ist 45 Geben Sie bitte eine Zahl ein (0=Quit) 2

Anzeigen

Object 1 3+2 ist 5 Geben Sie bitte eine Zahl ein (0=Quit) 5 5+2 ist

Object 1

3+2 ist 5 Geben Sie bitte eine Zahl ein (0=Quit) 5

5+2 ist 7 Geben Sie bitte eine Zahl ein (0=Quit) 0

Die do while Schleife

Bei einer normalen while Schleife kann es sein, das die Schleife kein einziges mal durchläuft, wenn von Anfang an false übergeben wird. Die do while Schleife führt den Inhalt der Schleife, aber auf jeden Fall einmal aus. Wenn der Wert danach false ist bricht sie ab, ansonsten macht sie weiter.

Um sie zu benutzen muss man anstelle von while ein do schreiben, und das while( Schluss setzen.

Beispiel:

Code:

) ganz am

/*

main.cpp

*/ #include <iostream>

using namespace std;

int main()

{

bool bLoop = false; //Eine boolsche Variable, sie kann entweder false (0) oder true(!0)

do

{

cout << "Beenden mit 0"; cin >> static_cast<bool> bLoop;

}

while(bLoop);

return 0;

}

//Wandelt die Variable von cin in eine boolsche Variable um

Ich weiß, das ist ein billiges Beispiel, aber im Moment fällt mir nichts besseres ein

Beispiel, aber im Moment fällt mir nichts besseres ein Aber welche Variante ist am besten? Keine,

Aber welche Variante ist am besten? Keine, den das kommt ganz darauf an, was wir machen wollen. Meistens benötigt man die while Schleife, aber manchmal ist man froh darüber, dass es die do while Schleife gibt.

Die for Schleife Top

Eine weitere, und vermutlich die am meisten benutzte, Schleife ist die for-Schleife.

Wenn man etwas ziemlich oft machen will, z.B. etwas berechnen, und dabei noch eine Variable, die sich bei jedem Durchgang erhöht brauchen kann, dann ist die if-Schleife optimal dafür geeignet.

Nehmen wir an, wir wollen eine Zahl potenzieren. Dann multiplizieren wir die Basis einige Durchläufe mit sich selbst.

Hier der Code dazu:

Code:

#include <iostream>

using namespace std;

int main()

{

int iBase,n

= 0;

int iCalculate = 1;

cout << "Geben sie eine Zahl ein:\n"; cin >> iBase;

cout << "\nWie oft wollen Sie sie mit sich selbst multiplizieren?:\n"; cin >> n;

//Läuft insgesammt n mal durch for(int i=0; i < n; i=i+1)

{

iCalculate = iCalculate * iBase;

}

cout << "\n\n" << iBase << " hoch " << n << " = " << iCalculate << "\n\n";

return 0;

}

Die for Schleife besteht aus 3 Teilen:

for(Initialisierung;Bedingung;Statement)

Bei der Initialisierung wird eine Variable (meist die Laufvariable) initialisiert, man kann direkt Variablentyp Variablenname = 0; hineinschreiben, ohne das man die Variable vorher angelegt hat (z.B. mit int Variablenname) (Manche Compiler zerstören die Variable nach der if Schleife, andere erhalten sie noch), man kann aber auch eine bestehende Variable benutzten for(i=0;i<20;i=i+1), oder for(;i<20;i=i+1) (hier wird i am Anfang nicht auf 0 gesetzt)

Die Bedingung kann entweder true oder false erhalten, und wird vor jedem Durchgang überprüft, wenn sie false ist wird die Schleife abgebrochen, und der nächste Durchgang nicht mehr gemacht.

Als 3. kann man eine Statement angeben, das bei jeden Schleifendurchgang gemacht wird, üblicherweise erhöht man hier die Laufvariable.

Man kann diese Teile jederzeit auslassen, so kann man z.B for(;bTest == false (das entspricht einer while Schleife)

Anmerkung:

== false (das entspricht einer while Schleife) Anmerkung: schreiben Als C++ Programmierer fängt man beim Zählen

schreiben

Als C++ Programmierer fängt man beim Zählen nicht bei 1, sondern bei 0 an, und hört eine Zahl frü her auf.

Das sollte man sich angewöhnen, damit man später weniger Probleme hat.

Übrigens kann man z.B. in der Bedingung mehrere Bedingen angeben, die dann mit einem , getrennt werden.

z.B:

Code:

for(int i = 0; int j = 50; i < 30, j > 30; i++, j--); std::cout << j << std::endl;

Inkrement, Dekrement, Präfix- und Postfixoperatoren Top

Mit den Inkrement- und Dekrementoperatoren kann man Variablen um 1 erhöhen, oder verringern,

Code:

int i = 0; int j = 0;

//Statt

i = i + 1;

j = j - 1;

i++;j--;

//kann man auch folgendes schreiben:

//schreiben //es ist übrigens egal ob die beiden Befehle in einer Zeile sind, //der ; trennt sie

i++; <- ++ wird Inkrementoperator genannt, und erhöht den Wert der Variable um 1. j--; <- -- wird Dekrementoperator genannt, und verringert den Wert der Variable um 1.

Diese Methode erspart übrigens nicht nur Tipparbeit, sondern ist auf älteren Prozessoren (bis zur Pentium-Klasse) auch schneller , allerdings spielt das heute fast keine Rolle mehr.

Bei einer for Schleife schaut meistens übrigens so aus:

Code:

for(int i = 0;i < iAnzahlderElemente;i++)

{

}

Es gibt auch noch den Präfix, und den Prostfixoperator, sie machen eigentlich das gleiche wie die oben genannten Operatoren, bis auf einen kleinen Unterschied.

Codebeispiel:

int i = 0; int j = 0; int k = 0;

i = j++;

//i ist 0

i = ++k;

//i = 1

//Hier wird i zuerst den Wert von j zugewiesen, und j dann um 1 erhöht

//Hier wird zuerst k um 1 verringert, und dann bekommt i den Wert von k

Jetzt werden einige sicher an den Namen von C++ denken.

Casten Top

einige sicher an den Namen von C++ denken. Casten Top Manchmal ist es notwendig einen Variablentyp

Manchmal ist es notwendig einen Variablentyp umzuwandeln, wenn man einen Fließkommawert hat, aber eine ganze Zahl hat, muss man den float in einen int umwandeln.

Dies kann man mit GecasteteVariable = static_cast<Variablentyp> (Variable); machen.

Hier ein Beispiel:

Code:

float

fTest = 21.2321321f;

int

iTest = static_cast<int> (fTest);

//Wenn man static_cast<int> nicht machen würde, würde d

er Compiler hier eine Warnung ausgeben, in anderen Fällen können Fehler entstehen

Es gibt noch 2 weitere Arten, die aus C übernommen wurden, und veraltet sind, mit denen man aber casten kann:

Code:

float

fTest = 21.2321321f;

int a = (int) fTest;

//c style cast

int a = int (fTest);

Merken:

//function style cast

C-Casts sind böse, C++ casts sind gut. C-Casts sagen nichts, wenn man sie falsch benutzt, C++ cast s geben Fehlermeldungen aus

Hier gibt es noch ein schönes Tutorial zu dem Thema: In C++ richtig casten

Ein weiteres Beispiel:

In C++ gibt es den Variablentyp char, dieser Typ hat immer 1 Byte, also 256 verschiedene Möglichkeiten, und kann den ASCII Code darstellen. Wenn wir diese Variable in einen int umwandeln, bekommen wir die Nummer des Codes.

Die ersten Zeichen sind übrigens Steuerzeichen (Wagenrücklauf werden deshalb nicht korrekt dargestellt.

Code:

#include <iostream>

using namespace std;

int main()

{

cout << "Der ASCII Code:\n";

), und

//Eine Schleife die 256 (von 0 bis 255) mal durchläuft for(int i = 0; i < 255;i++) //Gibt die Zahl, und den umgewandelten char aus cout << "\n" << i << ": " << static_cast<char>(i);

return 0;

}

Weitere Operatoren Top

Bitoperatoren

[FEHLT]

Erweiterte Zuweisungsoperatoren

Damit man nicht immer i = i + 40; schreiben muss kann man stattdessen

i +=40;

verwenden.

Code:

int i = 1;

i += 20; // das selbe wie i = i + 20;

cout << i << endl;

//Ausgabe 21

Das selbe geht mit den anderen arithmetischen Operatoren:

i -= 20;

i *= 20;

i /= 20;

i % 20;

Arrays/Felder Top

Angenommen wir haben einige Zahlen, z.B. die Lebenspunkte der Gegner in einem Spiel. Jetzt haben wir eine größere Anzahl an Daten, die wir einzeln in Variablen speichern müssen:

100 //Lebenspunkte

53

34

95

100

232

//Diese Elemente nennt man Felder

In C++ kann man das mit Arrays umsetzen, das Programm reserviert einfach eine Reihe Variablen hintereinander.

Mit

Variablentyp Variablenname[AnzahlderFelder]; int iTest[30];

oder

Variablentyp Variablenname[AnzahlderFelder] = { Feld1, Feld2,

nacheinander setzen (man muss nicht allen einen Wert geben) int iTest[5] = {1,2,99}; // Die ersten 3 erhalten den Wert links, der Rest wird auf 0 gesetzt

Code:

};

//Hier kann man die Felder

#include <iostream>

using namespace std;

int main()

{

//Reserviert nacheinander 6 int Variablen für die Lebenspunkte int iHealthpoints[] = {100,53,34,95,100,232};

int iEnemy

= 0;

cout << "Von welchem Gegner wollen Sie die Anzahl Lebenspunkte wissen (0-5)? "; cin >> iEnemy;

if((iEnemy > 5) || (iEnemy < 0))

{

cout << "\nDer Gegner ist nicht vorhanden.";

}

else

{

cout << "\nDer NPC " << iEnemy << " hat " << iHealthpoints[iEnemy] << " Lebenspunkte." << endl;

iHealthpoints[0] = 3;

//Die erste Stelle wird verändert

//In C++ fängt man bei 0 an zu zählen

//iHealthpoints[6]

//Das Programm würde hier mit einem Fehler abbrechen, weil nur ein ei

ndimensionales Feld von 0 bis 5 (insgesammt 6 Felder) erzeugt wurde

}

cout << "\nDer Array iHealthpoints braucht "<< sizeof(iHealthpoints) / sizeof(iHealthpoints[0]) << " Bit";

cout << endl;

//Legt einen Array an, ohne den Elementen einen Wert zu geben int iTestArray[3];

//Setzt die Werte iTestArray[0] = 3; iTestArray[1] = 434; iTestArray[2] = 2;

int iTestArray2[3];

//iTestArray2 = {100,53,34,95,100,232}; <-- Fehler mit {} kann man nur beim reservieren zuwei sen

int iTestArray3[100] = {0}; int iTestArray4[100] = {1};

int iTestArray5[3]

//Setzt den Wert aller Elemente auf 0 //Setzt den Wert aller Elemente auf 0, nur das erste auf 1

= {0,1};//iTestArray5[0] ist 0, iTestArray5[1] ist 1, iTestArray5[2] ist 0

cout << endl;

return 0;

rde

}

//Main wird beendet, und 0 gibt zurück, dass das Programm erfolgreich ausgeführt wu

Wichtig:

Wie gesagt fängt man in C++ mit 0 an, der typische Anfängerfehler ist, das man einen Array mit z. B. 5 Feldern reservieren, und dann Variablenname[5] = 3; macht. Da man mit [0] anfängt ist bei [4] Schluss:

int i[5]; //Erzeugt an Array mit 5 Elementen

i[0] = 3; i[1] = 3; i[2] = 3; i[3] = 3; i[4] = 3; i[5] = 3;

//<- Falsch, das 6. Element gehört nicht zum Array

So, das reicht uns natürlich nicht, wir wollen wieder mal mehr. Nehmen wir an wir wollen auch noch die ID, und den max. Schaden haben.

Code:

[100][0][35]

//[Lebenspunkte],[ID],[Schaden]

[53 ][1][668]

[34 ][2][575]

[95 ][3][287]

[100][4][530]

[232][5][457]

Diesen mehrdimensionalen Array legen wir mit:

Code:

int iTestArray[6][3] =

{

{53,

1,

668},

{34,

2,

575},

{98,

3,

287},

{100,

4,

530},

{232,

5,

457},

};

cout << "Der letze Gegner macht " << iTestArray[5][2] << " Schaden" << endl;

Natürlich kann man das ganze auch so realisieren:

Code:

int iTestArray[6][3];

iTestArray[0][0]

= 100;

iTestArray[0][1]

= 0;

iTestArray[0][2]

= 35;

iTestArray[1][0]

= 53;

iTestArray[1][1]

= 1;

iTestArray[1][2]

= 668;

iTestArray[2][0]

= 34;

iTestArray[2][1]

= 2;

iTestArray[2][2]

= 575;

iTestArray[3][0]

= 98;

iTestArray[3][1]

= 3;

iTestArray[3][2]

= 287;

iTestArray[4][0]

= 100;

iTestArray[4][1]

= 4;

iTestArray[4][2]

= 530;

iTestArray[5][0]

= 232;

iTestArray[5][1]

= 5;

iTestArray[5][2]

= 475;

cout << "Der letze Gegner macht " << iTestArray[5][2] << " Schaden" << endl;

Funktionen Top

Wenn wir ein Programm schreiben wollen, das an 10 verschiedenen Stellen den arithmetischen Mittelwert von 2 Zahlen berechnen, und ausgeben soll. Jetzt können wir den Code, der den Durchschnitt berechnet natürlich 10 mal kopieren, aber wenn

wir einen Fehler in dem Code finden müssen wir das 10 mal ändern.

Zehn mal ist noch kein Problem, aber was ist wenn wir das hundert bis tausend mal machen wollen (Ich weiß man berechnet normalerweise nicht an hundert verschiedenen Stellen den Mittelwert,

aber es gibt auch noch andere Sachen, die man öfter wiederholen könnte

auch noch andere Sachen, die man öfter wiederholen könnte ). Für sowas gibt es Funktionen, mit

).

Für sowas gibt es Funktionen, mit ihnen kann man das Programm in Module einteilen, die dann eigenständig Arbeiten.

Hier unser Programm ohne Funktion:

Code:

#include <iostream>

using namespace std;

int main()

{

int iFirst = 3; int iSecond = 99;

int iAverage = (iFirst + iSecond) / 2;

cout << iAverage;

//[

]

iFirst = 5; iSecond = 88;

iAverage = (iFirst + iSecond) / 2;

cout << iAverage;

return 0;

}

Und hier das Programm der Funktion (Function):

Code:

#include <iostream>

using namespace std;

//Deklariert vom Funktionsprototyp int Average(int iFirst, int iSecond);

int main()

{

cout << Average(3,99) << endl;

//[

]

cout << Average(5,88) << endl;

return 0;

}

//Definition

int Average(int iFirst, int iSecond)

{

 

//Zählt beide Zahlen zusammen, und dividiert sie anschließend durch 2 int iAverage = (iFirst + iSecond) / 2;

//Gibt den Wert der Variable zurück return iAverage;

}

Ein Prototyp einer Funktion schaut immer so aus:

RückgabeTyp Funktionsname(AnzahlDerParameterVon0BisBeliebig);

Damit sagen wir dem Programm das weiter unten eine Funktion definiert wird.

Die Funktion int Average(int iFirst, int iSecond);

wird nachdem sie Aufgerufen wird den Typ (RückgabeTyp, in diesem Fall int) zurückgeben (wenn nichts zurückgegeben wird, dann benutzt man void), und man muss dieser Funktion 2 Parameter (Variablen) übergeben, in diesem Fall 2 int's.

Bei der Definition wird der Prototyp nochmal angeschrieben, und zusätzlich kommt noch das, was die Funktion macht dazu.

Die Parameter int iFirst, int iSecond werden der Funktion beim Aufrufen übergeben, und sind dann innerhalb der Funktion gültig.

Am Schluss wird dann mit return Wert; der Wert der Funktion zurückgegeben, solange der Rückgabewert nicht void ist.

Ein 2. Beispiel:

Code:

#include <iostream>

using namespace std;

//Deklariert vom Funktionsprototyp void GiveMessageOut(int iFirst);

int main()

{

int i = 0;

cout << "Geben Sie bitte eine Zahl ein: "; cin >> i;

GiveMessageOut(i);

return 0;

}

//Definition

void GiveMessageOut(int iFirst)

{

cout << endl << "Der Wert, der dieser Funktion übergeben wird beträgt " << iFirst << endl;

}

main() ist übrigens die einzige int Funktion, die keinen Wert zurückgeben muss. (Sie gibt Standardmässig 0 zurück)

Globale Variablen Top

In Funktionen gelten globale Variablen wie im Abschnitt [jump=space]Gültigkeitsbereiche[/jump].

Beispiel:

Code:

#include <iostream>

using namespace std;

int i = 3;

//Deklariert vom Funktionsprototyp void GiveMessageOut();

//Deklariert vom Funktionsprototyp

void GiveMessageOut2(int i);

int main()

{

int iTest;

cout << "Geben Sie bitte eine Zahl ein: "; cin >> iTest;

GiveMessageOut(iTest);

GiveMessageOut2(iTest);

return 0;

}

//Definition

void GiveMessageOut()

{

cout << endl << "Der Wert, der dieser Funktion übergeben wird beträgt " << i << endl;

}

//Definition

void GiveMessageOut2(int i)

{

cout << endl << "Der Wert, der dieser Funktion übergeben wird beträgt " << i << endl;

}

Hier würde die 1. Methode (Funktion) 3 ausgeben, die 2. aber den Wert von iTest, da die lokale Variable immer Vorrang hat. Eine globale Variable wie in der ersten Funktion, GiveMessageOut() sollte man vermeiden, die zweite Version ist viel eleganter.

Funktionen überladen Top

Es kommt relativ häufig vor, das man für Funktionen verschiedene Datentypen als Parameter braucht.

Man könnte z.B. eine Funktion machen, die entweder void(nichts) und eine die einen int als Parameter erwartet.

Dank Vererbung können beide gleich heißen, je nachdem was übergeben wird sucht sich der Compiler die Richtige aus:

Code:

#include <iostream>

void Initialisiere(); void Initialisiere(int iStartValue);

int iVariable = 0;

int main()

{

Initialisiere();

//Gibt "iVariable hat den Wert:3" aus std::cout << "iVariable hat den Wert:" iVariable << std::endl;

Initialisiere(5);

//Gibt "iVariable hat den Wert:5" aus std::cout << "iVariable hat den Wert:" iVariable << std::endl;

return 0;

}

void Initialisiere()

{

iVariable = 3;

}

void Initialisiere(int iStartValue)

{

iVariable = iStartValue;

}

Weiter Beispiele:

Code:

void Ausgabe(); int Ausgabe(int iVariable); void Ausgabe(int iVariable, int y);

Jetzt darf man allerding keine weiter Funktion mit 1 oder 2 Integer als Parameter deklarieren.

Funktionen einen Standardwert geben Top

Nehmen wir an das wir eine Funktion haben, die als letztes Parameter eine boolsche Variable hat (eine Variable vom Typ bool, d.h. sie kann entweder true oder false sein). Wenn die Variable true ist, wird etwas ausgegeben, ansonsten wird nichts ausgegeben:

Code:

int TestFunction(int iVariable1, int iVariable2, bool bOutput)

{

int i = iVariable1 + iVariable2;

if(bOutput) //Äquivalent zu (bOutput == true)

std::cout << i << std::endl;

return i;

}

Wenn wir diese Funktion jetzt aber öfter brauchen, und das Ergebnis aber so gut wie nie von der Funktion ausgeben lassen, müssten wir jedesmal TestFunction(23,23,false); schreiben.

In C++ haben wir die Möglichkeit das zu vermeiden indem wir der Variable bOutput einen Standardwert zuweisen:

Code:

int TestFunction(int iVariable1, int iVariable2, bool bOutput = false)

{

 

int i = iVariable1 + iVariable2;

if(bOutput) //Äquivalent zu (bOutput == true) std::cout << i << std::endl;

return i;

}

Das "= false" heißt, das der Compiler die Variable automatisch auf false setzt, wenn das letzte Parameter nicht angegeben wird.

Man kann den Parameter von rechts nach link einen Standardparameter geben, man darf dabei aber keine Variable auslassen:

richtig:

int Test(int x, int y = 3, int z = 3);

[node=falsch] //Nur von rechts nach link, keine Variable darf ausgelassen werden int Test(int x = 3, int y, int z = 34); [/note]

Wenn wir Prototypen definieren, dürfen wir das nur in den Prototypen machen, sonst gibt der Compiler einen Fehler aus:

Code:

#include <iostream>

int main()

{

Test(3);

}

//Das Standardparameter wurde im Prototyp schon gesetzt void Test(int i, int z)

{

std::cout << "Hallo";

}

Parameter der Main Funktion Top

Über die Parameter der main Funktion kann man dem Programm per Kommandozeile Werte übergeben, du hast sicher schon einmal mit DOS/Unix gearbeiten, und Erfahrungen damit gemacht.

Damit wir über die Kommandozeile Werte übergeben können verwenden wir folgenden aufbau:

Code:

int main(int argc, char* argv[])

{

return 0;

}

Die Namen der Parameter sind natürlich frei wählbar. Das erste Parameter enthält die Anzahl der übergebenen Parameter, das zweite ein Array von Zeichenketten.

Beispiel:

#include <iostream>

int main (int argc, char* argv[])

{

std::cout << "Dem Programm wurden " << argc << " Parameter uebergeben." << std::endl << "Pa rameter:" << std::endl << std::endl;

for(int i = 0; i < argc; i++)

{

std::cout << (i+1) << ": " << argv[i] << std::endl;

}

}

Wenn wir das Programm jetzt per Kommandozeile starten:

Code:

./Programmname "hallo" "hallo3"

gibt das Programm folgendes aus:

Code:

Dem Programm wurden 3 Parameter uebergeben. Parameter:

1: ./Testprogramm 2: hallo 3: hallo3

Rekursion Top

Eine rekursive Funktion ist eine Funktion, die sich selbst aufruft, das ist etwas, was man oft für sehr elegante Lösungen verwenden kann.

Nehmen wir an wir wollen die Fakultät (Fakultät von n = n!= (n-1)*(n-1) * berechnen.

* (1)) einer Zahl

Eine Möglichkeit wäre eine Schleife durchzugehen, und eine Variable immer wieder multiplizieren, wir verwenden in diesem Beispiel aber eine rekursive Funktion:

Code:

#include <iostream>

//Prototyp int Factorial(int iNumber);

int main (int argc, char* argv[])

{

 

std::cout << "Die Fakultaet von 5 ist: " << Factorial(5) << std::endl;

return 0;

}

//Diese Funktion ruft sich solange selbst auf bis iNumber-x 0 ist int Factorial(int iNumber)

{

}

Eine Funktion kann sich übrigens nur eine bestimmte Anzahl mal rekursiv selbst aufrufen, da es sonst negative Folgen auf die Hardware des Computers hätte.

Zeiger Top

Strings Top

Namespaces Top

Namespaces sind Gruppen von Variablen, Objekten, Funktionen, die unter einem Name definiert wurde. Dank ihnen lassen sich Namenskonflikte vermeiden.

Das ganze schaut so aus:

Code:

namespace Name

{

Inhalt

}

Auf die Elemente im Namespace wird so zugegriffen:

Name::Element;

Hier ein reeles Beispiel:

Code:

namespace Test

{

int iHallo = 3; int iTest = 55;

int GetInt(){ return 0; }

};

namespace Blubbfish

{

 

int iHallo = 1011;

int GetInt(){ return 66; }

};

int main(int args, char* argv[])

{

std::cout << "Namespace Test: iHallo: " << Test::iHallo << " GetInt(): " << Test::GetInt() << "\n" << std::endl;

std::cout << "Namespace Blubbfish: iHallo: " << Blubbfish::iHallo << " GetInt(): " << Blubbfish:

:GetInt() << "\n" << std::endl;

}

Ausgabe:

Namespace Test: iHallo: 3 GetInt(): 0

Namespace Test: iHallo: 1011 GetInt(): 66

Wir haben jetzt 3 globale Variablen angelegt, auf die wir danach mit Name::Element zugegriffen haben.

Das gleiche Prinzip haben wir übrigens schon mehrfach mit std:: verwendet

haben wir übrigens schon mehrfach mit std:: verwendet Wir können ausserdem alternative Namensräume mit namespace

Wir können ausserdem alternative Namensräume mit namespace new_name = current_name ; schaffen.

Damit ein namespace in der gesammten Datei global wird kann man using namespace namespace_name; verwenden, dadurch kann es aber (vor allem in unserem Fall) zu Namenskonflikten kommen.

Beispiel:

#include <iostream>

using namespace std;

int main(int args, char* argv[])

{

cout << "hallo!" << endl; return 0;

}

Ich ziehe die std:: Methode aber vor!

Für ein Objekt die in keinem Namespace ist kann man ::Objekt benutzen:

std::cout << ::iTest;

Weblinks Top

www.msdn.com - MSDN.com Die Entwickler Datenbank von Microsoft www.mathematik.uni-marburg.de/~cpp - Ein Kurs der Uni Marburg tutorial.schornboeck.net/inhalt.htm - Ein sehr gutes C++ Tutorial www.mindview.net/Books/TICPP/ThinkingInCPP2e.html - ein Online Buch www.volkard.de/vcppkold/inhalt.html - C++ Tutorial von Volkard Henkel www.c-plusplus.de/tutorials.htm - eine C++ Tutorialsammlung www.volkard.de/vcppkold/inhalt.html - Volkards C++-Kurs ladedu.com/cpp/ - Einführung in C++

+

cpp.programmersbase.net/ - CPP.ProgrammersBase.NET www.cpp-programming.de/ - Eine Seite, mit sehr vielen Quellcodes

- Vererbung in C++

Literatur Top

- Bjarne Stroustrup: Die C++ Programmiersprache, ISBN: 3-8273-1660-X, das Standardwerk zu C+ +, Nicht für Einsteiger geeignet, sehr empfehlenswert

Autoren & ihre Arbeit am Tutorial Top

- Simon Hecht Hauptautor

Dank geht an: Gothreaper, mazze, xardias