====== Programmieren in C++ ======
\\
* [[:Programmieren| Programmieren in C++| Schleifen]]\\

\\
==== Grundaufbau eines Programmes  ====

      #include <iostream> 
      using namespace std;
      int main ()
      {
           beliebige Variablen definieren ... z.B. int x;
    
           Hauptprogramm
           ...
      }

Alternativ dazu kann man man auch einfach am Schluß des Main-Programms "return 0;" schreiben, dazu muss man oben aber oben noch "#include <conio.h>" hinzufügen und vor "return 0" "getch()". Das sieht dann so aus:

      #include <iostream>
      #include <conio.h>
      using namespace std;
      int main ()
      {
          Variablen definieren ...
          
          Hauptprogramm
          ...
          
          getch();
          return 0;
      }
Je nach Situation ist die eine oder die andere Variante brauchbar, weil manchmal die jeweils andere buggt.
\\
\\
==== Grundlegende Befehle ====
\\
Am Ende jedes Befehls bzw. Befehlblocks wird ein **;** geschrieben.

Beispiele:
     int x;
     cin >> x;
     cout << x << endl;

\\
Ausgabe eines Textes:
      cout << "TEXT";

Einlesen einer Variable:
      cin >> var;

<note tip>**Faustregel** \\
 Damit man nicht die Richtung der Pfeile vergisst kann man sich einprägen dass man nach cin Shift gedrückt hält und nach cout nicht.</note> 
\\
Mit diesem Befehl springt das Programm bei der Ausgabe in die nächste Zeile:
      cout << endl;

\\
Alternativ dazu kann man in der Ausgabe selbst \n schreiben. (Ohne Abstand oder irgendwas anderes, einfach nur \n da wo man einen Zeilenumbruch will.) Nachfolgend einige Beispiele, damit es auch wirklich jeder versteht:
      "\nDas ist ein Satz."
      "Das ist auch ein Satz.\n"
      "\nDas ist ein Satz mit je einer Zeile Abstand nach oben oder unten.\n"
      "\n\n\n\n\nUnd dieser Satz ist weeeeeeiiiit unten."
      "Der nachfolgende Satz wird auch weeeeeiiit unten sein.\n\n\n\n\n."
Man kann auch mehrere Ausgaben aneinanderreihen:
      cout << "Die Variable" << x << "ist kleiner als" << y << "." << endl;
\\
Mit Doppelschrägstrich am Ende einer Zeile schreibt man einen Kommentar der vom Programm ignoriert wird.
      int >> blub; //Das hier ist ein Kommentar, in dem ich zum Beispiel erklären kann wozu blub da ist.

\\
Mit Schrägstrich und Stern kann man einen mehrzeiligen Kommentar schreiben. Dieser wird wieder mit Stern und Schrägstrich geschlossen.
      cin >> blub; /*Dies hier ist ein Kommentar den ich so lang ich will machen kann.
      Auch über mehrere Zeilen.
      Aber man sollte ihn auch mal wieder beenden.*/ cout << blub;
      cout << /*Man kann einen solchen Kommentar auch irgendwo im Nirgendwo einfügen.*/ blub+1;

===== Schleifen =====

==== DO/WHILE - Schleife ====
      do
      {
         Programmcode             
         ...
      } while (Bedingung);  -  z.B. while (antwort == 'j'); 


Es gibt noch eine zweite Möglichkeit, eine DO/WHILE - Schleife zu schreiben. Hierbei wird das DO nicht benötigt.
\\

      while(Bedingung)
      {
         Programmcode             
         ...
      } 

\\

Der Unterschied zwischen einer DO/WHILE – Schleife und einer WHILE – Schleife  ist, dass bei einer DO/WHILE – Schleife die Abbruchbedingung erst nach dem Durchlauf des Programmcodes überprüft wird.
\\

  * WHILE-Schleife = kopfgesteuert \\
  * DO/WHILE-Schleife = fußgesteuert, dh. dass die Schleife mind. 1x durchgelaufen wird

\\
==== FOR - Schleife ====

      int i; // Laufvariable definieren

      for(i=0;i<10;i=i+1)
      {
         Programmcode 
         ...            
      }

i = 0 ... Anfangswert der Laufvariable \\
 i < 10 ... Bedingung, wie weit die Laufvariable (in diesem Bsp) erhöht wird \\
i = i+1 ... Veränderung der Laufvariable i \\
**Tipp:** %%i++%% ist adäquat zu i = i+1 

<note>**Beispiele:** \\ Tannenbaum, kleines 1x1; siehe I:\Schule \6B \Info_Kl </note> 


===== Bedingungen / Verzweigungen =====

==== IF - Anweisung ====
\\
Man fragt eine Bedingung ab. Wenn diese erfüllt ist, werden die Anweisungen des IF-Zweiges ausgeführt. Wird die Bedingung nicht erfüllt, wird der IF-Zweig übersprungen und arbeitet den ELSE-Zweig und dessen Anweisungen ab. Der ELSE-Block muss nicht explizit angeführt werden. Wenn es z.B. bei Nichterfüllen der Bedingung keine Alternativen Anweisungen gibt, muss kein unnötiger Quellcode geschrieben werden.

Aufbau einer IF/ELSE - Anweisung:
\\ 
      if(Bedingung)
      {
         Anweisungen          
      }
      else
      {
         Anweisungen
      }
\\

==== SWITCH - Anweisung ====

Neben der IF - Abfrage gibt es noch die SWITCH - Abfrage. \\ 
Wenn man in einem Programm sehr viele IF - Abfragen bezüglich einer Variable hat, ist es einfacher und kürzer diese in Form einer SWITCH - Abfrage zu schreiben.

      switch(Variable)
      {
         case 1: Anweisung; break;
         case 2: Anweisung; break;
         case 3: Anweisung; break;
         ...
         default: Anweisung; break;
      }  

switch(Variable) ... in der Klammer steht der Name der abzufragenden Variable \\
case MöglicherWertDerVariable ... Wenn die Variable den Wert 1 hat, geht das Programm zum case 1 und führt die dort angeführten Anweisungen aus. \\
Mit "break" wird der jeweilige Fall beendet und das Programm wird am Ende der Switch-Case-Anweisung fortgesetzt. \\
Das "default" (engl. "Standard") ist ähnlich dem "ELSE" der IF-Anweisung. Wenn keine eingegebene Zahl einem Fall entspricht, so werden die Anweisungen im default - Zweig ausgeführt.  
\\
\\

====== Arrays ======

Du verwendest array um **verschiedene Symbole oder Zahlen auf einer "Variable"** zu speichern. Man spricht dabei nicht mehr von einer Variable sondern von einem Feld, sprich Array. Zu Beginn beschäftigen wir uns mit eindimensionalen Feldern bzw. Arrays.\\

Bei der Definition eines Arrays muss man die Anzahl der Elemente angeben. Das macht man so:\\

    int x, a, testarray[10]

Die Variable testarray ist eindimensional und hat 10 Elemente. Adressiert wird jedoch von 0,1,2,3,...,8,9
\\

**Ein Array wird über eine [[#FOR-Schleifen|FOR-Schleife]] kontrolliert (speichern, abfragen, usw.).**

\\
Hier werden 10 Felder benutzt. Bei der Addressierung wird bei 0 begonnen, d.h. die 10 Elemente werden von 0 bis 9 adressiert.

    for (a=0;a<10;a=a+1) 
    {
       cout << "Geben Sie eine Zahl ein: "; 
       cin  >> variable[a];
    }

\\
Nun werden die Zahlen ausgegeben, dafür verwendet man wieder die [[#FOR-Schleifen|FOR-Schleife]]!
\\

    for (a=0;a<10;a=a+1)
    {
       cout << zahl[a];
    }


Man kann in diesen **For-Schleifen** noch zusätzliche Funktionen einbauen, z.B.:
  * Sortieren der Zahlen nach der Größe
  * Die größte Zahl aussuchen
  * usw.

**Siehe:** Array Hausübung!\\
   
==== Arrays 2-dimensiolal ====

      int array [x][y];         // x ist die Zeile, y ist die Spalte!
      
Wenn du einen String-Array willst: \\
\\ 
      
      string array [x][y];     //So kannst du eine 2-dimensionale Zeichenkette erstellen.


===== Zufallszahlen =====

Um Zufallszahlen zwischen 1-100 zu erzeugen benötigt man den Befehl: rand()%100+1.
Das %100 bedeutet, dass die Zufallszahlen zwischen 0-100 liegen, das +1 das die Zahlen mit 1 beginnen.
Dies kann natürlich beliebig verändert werden. \\
So hat man aber immer nur die gleichen Zufallszahlen.
Um verschiedene Zufallszahlen zu erzeugen, braucht man den Befehl: srand(time(NULL)). Hier verändern
sich die Zufallszahlen mit der aktuellen Zeit.\\

**Bespielprogramm:**\\

    #include <iostream>
    #include <time.h>
    using namespace std;
    
    int main ()
    {   
      int zahl[10], i, x;
      srand (time(NULL));   
    
      for (i=0; i<10; i++) 
      {  
          zahl[i] = rand () % 100+1;         
          cout << zahl[i] << " ";      
      }
       
      cin >> x; 
    }

\\
====== Strings / Zeichenketten ======


Die CPLUSPLUS Standardbibliothek stellt den Datentyp (Klasse) string zur einfach Verarbeitung von Zeichenketten zur Verfügung. Um diesen Datentyp und dessen Funktionen/Methoden zu verwenden, muss die Headerdatei <string> inkludiert werden.

#include <string>

===== Definitionen von Strings =====

  string s1;                                erzeugt einen leeren String
  
  string s2("InhalteinesStrings");
  string s3 = "InhalteinesStrings";         initalisiert eine Zeichenkette/String mit "Inhalt"
  
  char wort[100] = ...;                     erzeugt ein Char-Feld mit der Größe 100 und muss einen String enthalten
  string s4(w);
  string s5 = w;                            initalisiert einen String mit dem Charfeld w
  
  char *zeiger = ...;                       erzeugt einen Char-Zeiger, der auf einen String zeigt
  string s6(zeiger);
  string s7 = zeiger;                       initialisiert einen String mit einem char-Zeiger
  
  const string s = "festerInhaltdesStrings" initalisiert einen konstanten String (der Inhalt dieser Varialbe soll später nicht mehr geändert werden -> const)
  
  string stringfeld[10];                    initalisiert ein Stringfeld mit 10 Elementen;
    

===== Operatoren und Methoden von Strings =====

Eine Methode ist eine Funktion, die mit einem Objekt oder einem Klassennamen (z.B. string,...) und "." aufgerufen wird. 
Methoden helfen auch dabei, ein Programm kürzer zu schreiben.

**Länge von Strings**

Die Methode "size()" liefert die Anzahl der Zeichen eines String.
\\ "string::size_type" ist ein Datentyp, genauso wie z.B. "int", dessen Größe der Compiler passend wählen kann. 
\\ Der Typ "int" kann auch gewählt werden, aber bei riesigen Strings können Probleme entstehen, da das Ergebnis den maximalen Wert vom Typ "int" übersteigen kann.     
      
      string::size_type anz; 
      string s1;
	
     
      anz = s1.size();      //anz == 0

      s1 = "Das ist ein Text";
      anz= s1.size();       //anz == 16

      s1 = "ab c";
      anz= s1.size();       //anz == 4 

**Vergleichen von Strings:**

Strings kann man mit "==" vergleichen. Es ist auch möglich, char-Arrays bei einem Vergleich zu benutzen.

2 Strings:

     string s1 = "Text", s2;
     if (s1 == s2)  
     {         
        cout << "Strings sind gleich!" << endl;
     }

char-Array mit String:

     char name[5] = "Text";
     if (s1 == name)
     {                 
        cout << "Strings sind gleich!" << endl;
     }
     
**Durchsuchen von Strings:**

Mit der Methode "find()" kann man einen String durchsuchen. 

     string::size_type find(char c) 
     
     string s = "Rechner";
     string::size_type pos;
     
     pos = s.find('e');         // Suche nach 1. 'e'; ab pos == 0; pos == 1
     pos = s.find('e', pos+1);  // Suche nach 2. 'e'; ab pos == 2; pos == 5


**Zusammenfügen zweier Strings:**
     
     string text1, text2;
     text1 = "Morgen ";             
     text2 = "ist Montag!";
     
     text1 = text1 + text2;
     text1 += text2;            //Die Stringvariable text1 enthält nun: "Morgen ist Montag!"

oder

     text1 +="ist Mittwoch!";   //Morgen ist Mittwoch!



==== Zugreifen auf einzelne Stringelemente ====

Zuerst definiert man einen String mit einem Text. Dann greift man an den einzelnen Buchstaben zu, in dem man einzelne Nummern der Buchstaben von definiertem String angibt.

**z.B.:**

    #include<iostream>
    #include<string>
    using namespace std;
    
    int main()
      { int x;
        string text="Haloo C++"; //Der String wird mit einem Text definiert
    
        cout<<"Der Text lautet: "<<text<<endl; //Der Text wir ausgegeben
        cout<<"Ein neuer Text: "<<text[6]<<text[3]<<text[2]<<text[1]; //Ein neuer Text entsteht durch Zugreifen an einzelnen Buchstaben von vorher angegebenen Text
  
        cin >>x;
  
      }

==== Merhdimensionale Strings ====

Um mit mehrdimensionalen Strings zu arbeiten, muss man zuerst in String den Dimension angeben. Dann wird ein Text durch einem Array zugewiesen und dann wieder mit einem Array ausgegeben.
 
     **z.B.:**
     #include <iostream>
     #include <string>
     using namespace std;
    
     int main ()
       {  
         string platz[x][y]; //Definition von String
           
         platz[x][y]="Text"; //Ein Text wird zugewiesen
         
         cout <<plazt[x][y]; //Ausgegeben wird der Text an Stelle x und y (Strings definiert man mit Zahlen!! In x und y kann man beliebige Zahlen eingeben!)
         
       }


===Unterprogramme===

Unterprogramme sind abgetrennt Programmteile ( Bausteine), welche es erlauben, bestimmte
Aufgaben immer wieder durchführen zu können. Dies klingt so ähnlich wie Schleifen diese aber arbeiten nur bis sie einen gewissen Wert erreicht haben. 
Unterprogramme werden in aufgerufen in CPUSPLUS mit **"void"**.

__SINN:__ Mit deren Hilfe kann die Konstruktion eines Programms vereinfacht werden kann.

Prinzipiell unterscheidet man zwischen zwei Arten von Unterprogrammen:

1)Unterprogramme mit Funktionen

2)Unterprogramme mit Prozeduren

Der wesentliche Unterschied zwischen diesen beiden Arten liegt in der [[http://www.epinasoft.com/delphikurs/dkk_parpassing.html.|Parameterübergabe]].

__zu 1:__ 
Funktionen ohne Übergabeparameter und Rückgabewerte:

Die einfachste Art einer Funktion hat keine Übergabeparameter und keine Rückgabewerte. Ein Unterprogramm muss immer einen Namen bekommen, der möglichst aussagekräftig ist, also beschreibt, was die Funktion tut. Gibt die Funktion keinen Wert zurück, wird als Datentyp **void** notiert. Die Übergabeparameter stehen in runden Klammern hinter dem Funktionsnamen. Bei einer Funktion ohne Parameter müssen die Klammern auch stehen, nur sind sie leer. Die Funktion sieht also folgendermaßen aus:

void meineErsteFunktion()


{

Anweisung

}

__zu 2:__


//
//


====== Links ======
[[http://www.highscore.de/cpp/einfuehrung/titelseite.html|C++ Einführung]] <- empfehle dieses Tutorial als einfachen und schnellen Einstieg; ist in mehrere Kapitel unterteilt, die nicht zusehr ins Detail gehen!

[[http://www.cpp-entwicklung.de/cpplinux/cpp_main/node5.html|Programmieren mit C++ ]] <- 8-)

[[http://www.c-programmieren.com/C-Lernen.html|Hilfe beim C++ Programmieren]] <- wird grafisch erklärt

[[http://www.cplusplus.com/doc/tutorial/|C++ Tutorials in Englisch]] <- alles auf einer Seite

[[http://www.bloodshed.net/devcpp.html|Download von Dev-C++]]

[[http://www.baumann.info/public/cpp_lernaufgabe_zeichenketten.pdf|Lernaufgaben Zeichenketten]] <- gute Vorbereitung um Strings zu verstehen.

[[http://www.desy.de/~blist/oo-get-together/grell-061002.pdf|Befehle der Strings]] <- Hier findest du alle Befehle der Strings

[[http://de.wikibooks.org/wiki/C%2B%2B-Programmierung:_Kontrollstrukturen#Vergleichsoperatoren|Gute Seite (Zusammenfassung)]]

[[http://www.math.uni-bayreuth.de/~rbaier/lectures/c/html/node62.html|Methoden von Strings]]

[[http://freebits.de/cpp/uebung5/karras_ueb5.pdf|Unterprogramme: Fkt.]] <- Umbedingt Anschauen                                                    
\\

====== Quellen ======