C++ Allgemein

• C++ ist eine Programmiersprache (Hochsprache)
• Ein Programm wird als Quelltext in einen Texteditor geschrieben und dann mit einem Compiler übersetzt:
  • Präprozessor (Fügt Code aus Headern etc. ein)
  • Compiler (Übersetzt den Quellcode in Maschinensprache)
  • Linker (Bindet zusätzliche Funktionen, wie Bibliotheken, ein!
  • Da Linker und Präprozessor nahezu immer beim Compiler dabei sind, kann man vereinfacht folgende Darstellung verwenden:
    
  • Richtiger:
    
  • Und:
    
• Ein Programm bekommt vom Linker einen Betriebssystemabhängigen Startcode!
• Als Syntax bezeichnet man die Struktur eines Kommandos
• Um die Arbeit einfacher zu gestalten nutzen einige Leute lieber IDE's, also graphische Entwicklungsumgebungen. Eine solche IDE bringt meist selber einen Compiler mit, der Compiler kann allerdings oft ausgetauscht werden.
• Ein kompiliertes C++-Programm kann nicht wieder in Quellcode umgewandelt werden, allerdings können Werte und Zeichenketten trotzdem "wiederhergestellt" werden!

Programmaufbau

• Ein C++-Programm braucht eine "main()"-Funktion!
  • muss einen "int" zurückgeben! ("int main" und "return #;")
  • muss keinen, 1, 2 oder 3 Parameter haben
    

    int main();
    int main(int argc); //Selten, aber möglich
    int main(int argc, char *argv[]);
    int main(int argc, char *argv[], char *env[]);
     //Sehr selten, nur auf einigen Systemen sinnvoll
     
    /*
    argc               ist die Anzahl der Parameter.
    argv[0]            ist das, was der Nutzer getippt hat,
                       um das Programm zu starten.
    argv[1 bis argc-1] speichert die Parameter.
    env[]              speichert die Environment-Variablen.
    */
     

  • ist der Startpunkt des Programms, hier beginnt die Ausführung.
• Innerhalb der "main()"- oder einer anderen Funktion können Funktionen aufgerufen werden, die vor diesem Punkt in der Quellcodedatei stehen. Ein Prototyp reicht aus (s. Funktionen)
• Fehler werden entweder beim Compilieren gefunden (Compiletime error) oder bei der Ausführung (Runtime error)
• Anweisungen stehen immer in Blöcken, die mit geschweiften Klammern ("{}") definiert werden. Es kann auch innerhalb eines Blockes ein weiterer Block stehen!
• Es wird zwischen Groß- und Kleinschreibung unterschieden, einrücken oder Zeilenumbrüche haben allerdings keine Einflüsse, wenn man von einzeiligen Kommentaren und dem Präprozessor absieht!

Werte in Variablen speichern

• In Variablen können Werte und Daten gespeichert und mit diesen gearbeitet werden. Variablen haben immer eine Bezeichnung, unter der sie angesprochen werden, und einen Wert!
• In C++ haben Variablen auch einen Typ, der die Art von enthaltenen Daten bezeichnet:
  (Die Größen können von System zu System variieren! 1 Byte=8 Bit)
  

  16-Bit-Systeme
  Name	Deutsch	Werte	Größe (Byte)	Beispiel
  bool	Ja/Nein	false/true bzw. 0/1	1	bool b_test=false;
  signed char	Zeichen mit Vorzeichen	-128/127	1	signed char sch_test=-34;
  unsigned char	Zeichen ohne Vorzeichen	0/255	1	unsigned char uch_test=240;
  enum	Auflistung von Konstanten	-32.768/ 32.767	2	s.u.
  (signed) int	Ganzzahl mit Vorzeichen	-32.768/ 32.767	2	signed int si_test=-1234;
  unsigned int	Ganzzahl ohne Vorzeichen	0/65.535	2	unsigned int ui_test=12;
  short (int)	kurze Ganzzahl	-32.768	2	short int shi_test=345;
  (signed) long (int)	lange Ganzzahl mit Vorzeichen		4	signed long int sli_test=-2345;
  unsigned long (int)	lange Ganzzahl ohne Vorzeichen		4	unsigned long int uli_test=5678;
  float	Gleitkommazahl, z.B.: 3.14		4	float f_test=1.618;
  double	Gleitkommazahl mit doppelter Genauigkeit		8	double d_test=1.6180339887;
  long double	lange Gleitkommazahl mit doppelter Genauigkeit		10	long double ld_test=4.896542;
  32-Bit-Systeme Nur Änderungen gegenüber 16-Bit
  enum			4	Auf die gesamte Tabelle
  (signed) int			4	keine Garantie!!!
  unsigned int			4

  Dazu kommen noch enum etc. und eigene Typen (OOP)!
  Die genaue Größekann mit dem "sizeof()"-Operator ermittelt werden: "sizeof(int)" gibt die Größe eines Integers zurück, z.B.: "4". Die Größe eines "char" ist allerdings auf JEDEM System "1"!
• Die Namen der Variablen unterliegen einigen Regeln:
  
  • Variablennamen müssen mit einem Buchstaben oder Unterstrich beginnen
  • Leerzeichen im Namen sind nicht erlaubt, man darf aber Buchstaben, Zahlen und Unterstriche benutzen.
  • Die maximale Länge variirt je nach Compiler, ist aber meist bei ca. 247
  • Reservierte Wörter dürfen nicht genutzt werden, siehe Anhang!
  • Es wird zwischen Groß- und Kleinschreibung unterschieden!
• Um mit Variablen zu rechnen oder Operationen auszuführen, gibt es Operatoren und Funktionen. Weiterhin gibt es Methoden, also zum Typ gehöhrende Funktionen (s. OOP)
• Variablen können lokal oder global sein, d.h. entweder nur innerhalb des Blockes, in dem sie deklariert worden sind, oder im ganzen Programm sichtbar sind. Globale Variablen bestehen also das gesamte Programm über und beanspruchen Speicher! Lokale werde aus dem Speicher entfernt, sobald ihr Gültigkeitsbereich überschritten wird.
• Variablen können mit einem "=" Werte und andere Variablen zugewiesen werden!

Sprachelemente

• Kommentare
  • gehen von "//" bis zum Ende der Zeile
  • oder von "/*" bis "*/"
  • Werden vom Compiler einfach ausgelassen
• Blöcke
  • gehen von "{" bis "}" und dienen zu Strukturierung und zum definieren von Gültigkeitsbereichen
  • Bei einzeiligen Anweisungen in einem Block nach z.B. einer "if"-Abfrage können die Klammern auch wegfallen, ausgeführt wird dann nur das folgende Kommando!
• Bedingungen
  • Bedingungen braucht man bei Schleifen und Bedingter Ausführung
  • Es gibt solche Bedingungen:

    Zeichen	Bedeutung	Beispiel
    ==	Wert1 gleich Wert2?	1==1 1==3	true false
    !=	Wert1 nicht gleich Wert2?	1!=2 1!=1	true false
    <	Wert1 kleiner Wert2?	1<2 2<2	true false
    >	Wert1 größer Wert2?	2>1 5>5	true false
    <=	Wert1 kleiner oder gleich Wert2?	1<=1 3<=2	true false
    >=	Wert1 größer oder gleich Wert2?	3>=3 4>=5	true false
    !	Nicht Wert	!(false) !(true)	true false

    Falls man mehrere Bedingungen verknüpfen möchte,
    gibt es die beiden folgenden Möglichkeiten:
    

    &&	Bedingung1 und Bedingung2	(1==1) && (2>0) (1<=1) && (2==3)	true false
    ||	Bedingung1 oder Bedingung2	(1!=1) || (2==2) (1==3) || (2==6)	true false
    !	Nicht diese Bedingung!	!(1<0) !(1==1)	true false

• Inkrementierung/Dekrementierung

  //Erst um eins erhöhen, dann weiterrechnen:
  ++i;
   
  //Erst weiterrechnen, dann erhöhen:
  i++;
  //Hier wird zuerst eine Kopie angelegt,
  // daher ist dies Variante leicht langsamer!
   

• Schleifen
  • for

    for (int i=5; i<12; i++)
    {
      //Mach was!
    }
     

  • while

    while(Fehler==0)//!SOLANGE! (Fehler gleich Null ist)
                    // {wird das Kommando ausgeführt.}
                    //(Mit zwei "="!!!)
    {
     //Kommando
    }
     

  • do while

    do
    {
     //Anweisungen...
    } while(/*Bedingung*/);
     

• Bedingte Ausführung
  • if

    if (/*bedingung*/)
    {
     //Wenn Bedingung erfüllt...
    }
    else
    {
     //Ansonsten: (optional)
    }
     

  • switch case

    switch(/*Variable*/)
    {
     case /*==*/:
      /*Anweisungen*/;
      break; //Die anderen wollen wir nicht überprüfen...
     case /*==(2)*/:
      /*Anweisungen*/;
    //[...]
     default: //optional
      /*Anweisungen, falls nicht anderes wahr war...*/
    }
     
    //Beispiel:
    switch (integer_val)
    {
     case 0:
     case 1:
      //MachDochWas! (Bei 0 oder 1)
      break;
     case 2:
      //vllt. beenden?
      break;
     default:
      std::cout << "Fehler!" << std::endl;
    }
     

  • ?:

    bool test=(x>5)?true:false;
    //Bedingte Wertzuweisung...
     

Funktionen

• Strukturieren das Programm
• Wiederkehrende Abläufe zusammenfassen
• haben einen Rückgabetyp, einen Namen und ggf. Parameter
• Der Rückgabetyp kann ein beliebiger Datentyp oder "void" sein, bei void wird nichts zurückgegeben
• Die Parameter bringen beliebige Daten in die Funktion, damit diese dort verarbeitet werden können, zurückgegeben werden kann nur einer, dies geschieht mit "return"!
• Die Parameter haben ebenfalls einen Namen und Typ, wie "normale" variablen auch
• Ein Prototyp ist ein Funktionsrohling, der Rückgabetyp, Parameteranzahl und Typ, sowie den Funktionsnamen beinhaltet. Dadurch können Funktionen aus anderen Dateien/von weiter unten "angemeldet" werden, damit der Compiler sie kennt. Dies muss _vor_ dem ersten Aufruf erfolgen! Prototypen schrebt man über die main-Funktion!
  

  int quadrat(int);   //Prototyp
   
  //Noch ein Prototyp:
  int quadrat(int i); //Name des Parameters
  //kann angegeben werden, muss aber nicht...
   

• Funktionen müssen immer außerhalb einer anderen, wie der main() Funktion definiert werden!
• Sie sollten, wie auch Variablen, einen sinnvollen Namen bekommen
• Man kann mehrere Funktionen mit dem gleichen Namen schreiben, solange ihre Parameter sich voneinander durch Anzahl oder Typ unterscheiden. Dies nennt man "Überladen", oder "Polymorphie" ("Vielgestaltigkeit"). Der Rückgabewert ist beim Überladen übrigens egal! Nur sich unterscheidende Rückgabetypen können nicht zur Unterscheidung genutzt werden!

  bool saghallo()
  void saghallo(int i)
  int saghallo(float f)
   
  //aber nicht:
  int test()
  void test()
  float test()
   

• Rekursion: Rekursive Funktionen sind Funktionen, die sich immer wieder mit veränderter Parameteranzahl aufrufen. Gleich mehr... (nächster Abschnitt!)
• Default-Parameter: Wenn du einem Parameter innerhalb des Prototypen/des Funktionskopfes einen Wert zuweist, kann dieser beim Funktionsaufruf weggelassen werden. Geschieht dies, so wird der Standardwert genommen, den du festgelegt hast. Wichtig: Solche default-Parameter dürfen nur am Ende stehen, normale Parameter dürfen dann nicht mehr folgen, damit die Reihenfolge nicht durcheinander gebracht wird. Weitere default-Parameter dürfen folgen, allerdings kann nicht der vorletzte Parameter weggelassen werden, der letzte aber nicht...!
  

  int test1 (int i=0);               //Geht
  int test2 (int i=0, int k);        //Geht nicht
  int test3 (int i, int k=5);        //Geht
  int test4 (int i=0, int k=9);      //Geht
   
  //  [...]
   
  test1();            //Geht: i=0
  test1(3);           //Geht: i=3
   
  test3(2);           //Geht: i=2, k=5
  test3(2,-19);       //Geht: i=2, k=-19
   
  test4();            //Geht: i=0, k=9
  test4(1);           //Geht: i=1, k=9
  test4(-19,8);       //Geht: i=-19, k=8
   
  test4(/*nur k angeben woll*/); //Geht nicht
   

• static: Lokale Variablen, die ihren Wert nach Verlassen einer Funktion bis zum nächsten Aufruf behalten, nennt man "static": "static int beispiel;"
• Es gibt auch "inline"-Funktionen: Inline Funktionen werden automatisch an alle Stellen kopiert, wo sie vorkommen. Dadurch wird Speicher (RAM) gespart (Der Computer muss sich nicht merken, von wo er die Funktion aufgerufen hat!) und die binäre, ausführbare Datei größer. Daher nutzt man sie meist bei kleinen, kurzen Funktionen, da sie "inline" schneller sind, aber die Übersichtlichkeit von Funktionen bleibt! Inlinefunktionen werden mit dem Wort "inline" gekennzeichnet, aber ganz normal aufgerufen:

  inline int saghallo() {/*...*/};
   

• Funktionen, die sich immer mit verschiedenen Parametern selbst aufrufen, arbeiten rekursiv, die alternative Schreibweise (mit Schleifen) nennt man iterativ!