JLI Spieleprogrammierung Foren-Übersicht JLI Spieleprogrammierung

 
 FAQFAQ   SuchenSuchen   MitgliederlisteMitgliederliste   BenutzergruppenBenutzergruppen 
 medals.php?sid=c3687322082b26ef84c2e97fb5c53a9fMedaillen   RegistrierenRegistrieren   ProfilProfil   Einloggen, um private Nachrichten zu lesenEinloggen, um private Nachrichten zu lesen   LoginLogin 

C++ Tutorial Teil 1

 
Neues Thema eröffnen   Neue Antwort erstellen    JLI Spieleprogrammierung Foren-Übersicht -> Tutorials
Vorheriges Thema anzeigen :: Nächstes Thema anzeigen  
Autor Nachricht
abc_d
JLI Master Trainee


Alter: 34
Anmeldedatum: 27.01.2003
Beiträge: 615

Medaillen: Keine

BeitragVerfasst am: 13.07.2005, 15:41    Titel: C++ Tutorial Teil 1 Antworten mit Zitat

Vorwort

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

Um besser lernen zu könnten 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

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 haltet.

Hilfe

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 Smile

Inhaltsverzeichnis

Software
Kapitel 1: Grundlagen
- Das erste Programm
- Header
- Kommentare, cout, flush, Escapezeichen
- Variablen
- Operatoren
- Konstante
- Namensvergabe
- Gültigkeitsbereiche
- Kontrollstrukturen
- if statements
- switch
- Schleifen
- while
- for
- Inkrement, Dekrement, Präfix- und Postfixoperatoren
- Casten
- Weitere Operatoren
- Arrays/Felder
- Funktionen
- Globale Variablen
- Funktionen überladen
- Funktionen einen Standardwert geben
- Main Funktion
- Rekursion
- Zeiger
- Strings
- Namespaces
Weblinks
Literatur
Autoren

Software

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

http://www.c-plusplus.de/compiler.htm

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

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

Das erste Programm

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:
CPP:
#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:

CPP:
cin.clear();
cin.ignore(cin.rdbuf()->in_avail());
cin.get();


Ok, du hast es also geschafft, dein erstes Programm Wink

Erklärung

- Header
CPP:
#include <iostream>
#include <cstdio>
#include <string>


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

CPP:
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. (#include <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

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:
CPP:
//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().

CPP:
   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:

CPP:
//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:
CPP:
cout << "Text1" << "Text2";


Ausgabe: Text1Text2

Dann kann man mit sogenannten Steuerzeichen verschiedene Sonderaktionen machen:

CPP:
\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

Variablen sind Speicherteile, die einen Wert speichern können.
Man kann ihnen einfach einen Wert zuweisen, und wieder auslesen.

Vor 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:

CPP:
/*
   
   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.

CPP:
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: >>

CPP:
/*
   
   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

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

CPP:
int MeineVariable = 4;
int MeineZweiteVariable = 2;
int i;

MeineVariable = 3;

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

//Addiert zuerst MeineVariable & MeineVariable, setzt zuerst MeineZweiteVariable, und dann i auf das Ergebniss, un
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:

CPP:
/*
   
   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.

CPP:
/*
   
   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

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

Für diese Dinge gibt es Konstanten:

const int 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:

CPP:
/*
   
   main.cpp

*/

#include <iostream>

using namespace std;

int main()
{
   int a = 5;

   const int c = 5;   //Compiletime Konstante
    const int x = 5*7;   //Compiletime Konstante

   int d = 0;
   cin >> d;

   const e = d;      //Runtime Konstante


   const int b = a;   //a könnte theoretisch wärend der Laufzeit geändert werden
                  //Runtime Konstante
   
   int const z;      //Noch was, man kann const auch nach dem Variablentyp schreiben

   return 0;
}


Namensvergabe

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 z.B. .;,"< oder + (verwende bis auf _ am besten 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,...) 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

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

CPP:
Globaler Gültigkeitsbereiche

/*
   
   main.cpp

*/

#include <iostream>

using namespace std;

int a;

//[b]Lokaler Gültigkeitsbereich von Main[/b]
int main()
{
   
   int b;

   a   = 33;
   b   = 3;


   //[b]Gültigkeitsbereich - Erste Unterebene von main[/b]
   {
      int c;

      a   = 3343;
      b   = 45;
      c   = 3;

      //[b]Gültigkeitsbereich - Unterebene von der ersten Unterebene von main[/b]
      {
         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

   //[b]Gültigkeitsbereich - Zweite Unterebene von main[/b]
   {
      
      //Hier ist nur a und b gültig
   }

   return 0;
}
//Lokaler Gültigkeitsbereich von main Ende


Wenn wir die Struktur anschauen:

CPP:
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.

CPP:
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

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.


CPP:
/*
   
   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 Klammern 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

CPP:
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:

CPP:
/*
   
   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ückliefert." << 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 (true 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 (||).

CPP:
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

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

CPP:
/*
   
   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.

CPP:
   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

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

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:

CPP:
/*
   
   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

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(...) ganz am Schluss setzen.

Beispiel:

CPP:
/*

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;   //Wandelt die Variable von cin in eine boolsche Variable um
   }
   while(bLoop);

   return 0;
}


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

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

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:

CPP:
#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;) schreiben (das entspricht einer while Schleife)

CPP:
Anmerkung

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:

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


Inkrement, Dekrement, Präfix- und Postfixoperatoren

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

CPP:
int i = 0;
int j = 0;

//Statt
i = i + 1;
j = j - 1;

         //kann man auch folgendes schreiben:
i++;j--;   //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:

CPP:
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.

CPP:
int i = 0;
int j = 0;
int k = 0;

i = j++;   //Hier wird i zuerst den Wert von j zugewiesen, und j dann um 1 erhöht
      
//i ist 0

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

//i = 1


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

Casten

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:

CPP:
float   fTest = 21.2321321f;
int      iTest = static_cast<int> (fTest);   //Wenn man static_cast<int> nicht machen würde, würde der 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:

CPP:
float   fTest = 21.2321321f;

int a = (int) fTest;   //c style cast
int a = int (fTest);   //function style cast

CPP:
Merken

C-Casts sind böse, C++ casts sind gut. C-Casts sagen nichts, wenn man sie falsch benutzt, C++ casts 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
[url=de.wikipedia.org/wiki/ASCII]ASCII Code[/url] darstellen.
Wenn wir diese Variable in einen int umwandeln, bekommen wir die Nummer des
Codes.

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

CPP:
#include <iostream>

using namespace std;

int main()
{
cout << "Der ASCII Code:\n";

//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

Bitoperatoren

[FEHLT]

Erweiterte Zuweisungsoperatoren

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

i +=40;

verwenden.

CPP:
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

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, ...}; //Hier kann man die Felder 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

CPP:
#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 eindimensionales 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 zuweisen

   int iTestArray3[100] = {0};   //Setzt den Wert aller Elemente auf 0
   int iTestArray4[100] = {1};   //Setzt den Wert aller Elemente auf 0, nur das erste auf 1
   int iTestArray5[3]   = {0,1};//iTestArray5[0] ist 0, iTestArray5[1] ist 1, iTestArray5[2] ist 0

   cout << endl;

   return 0;   //Main wird beendet, und 0 gibt zurück, dass das Programm erfolgreich ausgeführt wurde
}


CPP:
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.

CPP:
[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:

CPP:
int iTestArray[6][3] =
{
   {100,   0,   35}
   {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:


CPP:
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

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 Wink ).

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:

CPP:
#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):

CPP:
#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:

CPP:
#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

In Funktionen gelten globale Variablen wie im Abschnitt Gültigkeitsbereiche.

Beispiel:

CPP:
#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

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:

CPP:
#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:

CPP:
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

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:

CPP:
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:

CPP:
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:

CPP:
Richtig:

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


CPP:
Falsch:

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


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

CPP:
#include <iostream>

void Test(int i, int z = 3);

int main()
{
   Test(3);
}

//Das Standardparameter wurde im Prototyp schon gesetzt
void Test(int i, int z)
{
  std::cout << "Hallo";
}


Parameter der Main Funktion

Ü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:

CPP:
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.

CPP:
#include <iostream>

int main (int argc, char* argv[])
{
    std::cout << "Dem Programm wurden " << argc << " Parameter uebergeben." << std::endl << "Parameter:" << 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:

CPP:
./Programmname "hallo" "hallo3"


gibt das Programm folgendes aus:

CPP:
Dem Programm wurden 3 Parameter uebergeben.
Parameter:

1: ./Testprogramm
2: hallo
3: hallo3


Rekursion

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) * ... * (1)) einer Zahl berechnen.

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

CPP:
#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)
{
   if(iNumber > 1)   return iNumber * Factorial(iNumber -1);
   return 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

Strings

Namespaces

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

Das ganze schaut so aus:

CPP:
namespace Name
{
  Inhalt
}


Auf die Elemente im Namespace wird so zugegriffen:

Name::Element;

Hier ein reeles Beispiel:

CPP:
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 Wink

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.

CPP:
#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

http://www.msdn.com - MSDN.com Die Entwickler Datenbank von Microsoft
http://www.mathematik.uni-marburg.de/~cpp - Ein Kurs der Uni Marburg
http://tutorial.schornboeck.net/inhalt.htm - Ein sehr gutes C++ Tutorial
http://www.mindview.net/Books/TICPP/ThinkingInCPP2e.html - ein Online Buch
http://www.volkard.de/vcppkold/inhalt.html - C++ Tutorial von Volkard Henkel
http://www.c-plusplus.de/tutorials.htm - eine C++ Tutorialsammlung
http://www.volkard.de/vcppkold/inhalt.html - Volkards C++-Kurs
http://ladedu.com/cpp/ - Einführung in C++
http://www.tutorialpage.de/Cpp2/main.php - C++-Programmierung für Einsteiger
http://www.math.uni-wuppertal.de/~axel/skripte/oop/start.html - Objektorientiertes Programmieren mit C++
http://www.inf.fu-berlin.de/lehre/kurse/cplusplus/Skript.book.html - C++-Kurs
http://www.mut.de/media/buecher/VCPLUS6/data/start.htm - Visual C++ in 21 Tagen
http://www.mathematik.uni-marburg.de/~cpp/ - C++ Eine Einführung
http://www.comnets.rwth-aachen.de/doc/handout/handout.html - Objektorientierte Programmierung in C++
http://www.kompf.de/cplus/index.html - Objektorientiertes Programmieren in C++
http://alpha.fesg.tu-muenchen.de/dieter/oop/vorlesung.html - Eine OOP/C++ Vorlesung
http://www.home.unix-ag.org/martin/c++.ring.buch.html - Einführung in C++
http://os.inf.tu-dresden.de/~jn4/cppkurs/ - Ein kleiner Kurs in C++
http://www.shinigurai.de/Start.html - C++
http://www.bonn-online.com/~solar/cpp/contens/map.htm - Solars C++ Kurs
http://www.ges-training.de/Expertentips/C++-Regeln/cpp_tabelle.html - Entwicklungsregeln für C++-Klassen
http://www.wi-bw.tfh-wildau.de/~hendrix/grundstudium/cpp/skript/vererbung.html - Vererbung in C++
http://cpp.programmersbase.net/ - CPP.ProgrammersBase.NET
http://www.cpp-programming.de/ - Eine Seite, mit sehr vielen Quellcodes

Literatur

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


Zuletzt bearbeitet von abc_d am 23.02.2006, 19:13, insgesamt 3-mal bearbeitet
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden E-Mail senden
Patrick
Dark JLI Master



Anmeldedatum: 25.10.2004
Beiträge: 1895
Wohnort: Düren
Medaillen: Keine

BeitragVerfasst am: 13.07.2005, 16:07    Titel: Antworten mit Zitat

Geiles Tutorial!

Hab aber einen Kritikpunkt:
CPP:
float   fTest = 21.2321321f;
int      iTest = static_cast<int> (fTest);   //Wenn man static_cast<int> nicht machen würde, würde das IDE hier eine Warnung ausgeben, in anderen Fällen können Fehler entstehen


Die IDE gibt nichts aus sondern der Compiler Smile Die IDE ist nur die Oberfläche also Dein Visual Studio und der Compiler und Linker sind komplett andere Dinge Smile

Aber bei dieser Menge an Tutorial kann man da ruhig drüber weg sehen Smile Auf jedenfall MEGA GEIL!

Darf ich das auch auf meine Site stopfen? Very Happy
_________________
'Wer der Beste sein will muss nach Perfektion streben und jede Gelegenheit nutzen sich zu verbessern.' - KIA
[ German Game Dev | Boardsuche hilft sehr oft | Google rockt | Wie man Fragen richtig stellt | ICQ#: 143040199 ]
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden Website dieses Benutzers besuchen
abc_d
JLI Master Trainee


Alter: 34
Anmeldedatum: 27.01.2003
Beiträge: 615

Medaillen: Keine

BeitragVerfasst am: 13.07.2005, 16:25    Titel: Antworten mit Zitat

Hallo,

Danke für das Lob Smile

Das mit dem IDE wurde ausgebessert, obwohl das IDE die Fehlermeldung ausgibt. (Sofern ein IDE benutzt wird) Wink
_________________
http://mitglied.lycos.de/sarti/linuxisevil.gif Linux is evil - get the fact.

Never touch a running System - der Systemling


Zuletzt bearbeitet von abc_d am 07.11.2006, 19:54, insgesamt einmal bearbeitet
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden E-Mail senden
under_construction
Junior JLI'ler


Alter: 35
Anmeldedatum: 12.11.2002
Beiträge: 52

Medaillen: Keine

BeitragVerfasst am: 13.07.2005, 20:52    Titel: Antworten mit Zitat

Zitat:
Kapitel 1: Grundlagen

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


Ich finde, dass es für einen Anfänger nicht gerade leicht ist mal eben schnell
ein Projekt zu erstellen, vor allem dann, wenn er sich mit der IDE nicht so
recht auskennt. Bevor es also wieder Fragen hagelt, sollte man hier noch
anfügen, wie man eine neues Projekt erstellt:
Bsp.:

Zitat:

Benutzt du beispielsweise MS VC++ .NET, so erstellst du ein neues Projekt,
indem du auf "Datei" und dann auf "Neues Projekt" gehst und hier
"Konsolenanwendung" auswählst.


(Hoffentlich gilt das auch für .NET, weil ich kenn das nur für die normale
Autorenversion von MS VC++ 6.0)
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden
PeaceKiller
JLI Master


Alter: 35
Anmeldedatum: 28.11.2002
Beiträge: 970

Medaillen: Keine

BeitragVerfasst am: 13.07.2005, 21:11    Titel: Antworten mit Zitat

Deine Idee ist vielleicht gut, aber vollkommen überflüssig.

1. Es ist schwierig für 18 IDEs eine aktuelle Anleitung zu haben. (http://www.c-plusplus.de/cms/modules.php?op=modload&name=Web_Links&file=index&req=viewlink&cid=30)
2. Sollte das in der Anleitung für die IDE und nicht im C++-Tutorial stehen.
_________________
»If the automobile had followed the same development cycle as the computer, a Rolls-Royce would today cost $100, get a million miles per gallon, and explode once a year, killing everyone inside.«
– Robert X. Cringely, InfoWorld magazine
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden Website dieses Benutzers besuchen
abc_d
JLI Master Trainee


Alter: 34
Anmeldedatum: 27.01.2003
Beiträge: 615

Medaillen: Keine

BeitragVerfasst am: 13.07.2005, 21:53    Titel: Antworten mit Zitat

Genau das selbe habe ich mir auch gedacht. Vielleicht habt ihr ein paar Links für IDE-Tutorials?
_________________
http://mitglied.lycos.de/sarti/linuxisevil.gif Linux is evil - get the fact.

Never touch a running System - der Systemling
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden E-Mail senden
Beiträge der letzten Zeit anzeigen:   
Neues Thema eröffnen   Neue Antwort erstellen    JLI Spieleprogrammierung Foren-Übersicht -> Tutorials Alle Zeiten sind GMT
Seite 1 von 1

 
Gehe zu:  
Du kannst keine Beiträge in dieses Forum schreiben.
Du kannst auf Beiträge in diesem Forum nicht antworten.
Du kannst deine Beiträge in diesem Forum nicht bearbeiten.
Du kannst deine Beiträge in diesem Forum nicht löschen.
Du kannst an Umfragen in diesem Forum nicht mitmachen.


Powered by phpBB © 2001, 2005 phpBB Group
Deutsche Übersetzung von phpBB.de

Impressum