Variablen

Um Daten kurzzeitig (oder auch längerfristig) speichern zu können muss zuerst Platz geschaffen werden und dann muss es noch einen Weg geben auf diesen Platz zuzugreifen. Hierfür gibt es Variablen. Sie stehen für den Inhalt eines Speicherplatzes (bzw. sind ein anderer Name für ihren Wert). Zuerst muss eine Variable definiert werden. Danach wird dieser ein Wert zugewiesen. Welcher Wert zugewiesen werden darf ist von ihrem Typ abhängig.

Bisher haben wir nur int als Variablentyp kennengelernt. Es gibt aber viel mehr Variablentypen: Neben den eingebauten Typen gibt es auch Userdefined Typen, die behandeln wir aber viel später.

Um einem char einen Buchstaben zuzuweisen darf man nicht char c="a"; schreiben, sondern man muss 'a' schreiben. Denn "a" ist ein String (Zeichenkette) und 'a' ein zeichen :)

Warum das so ist, behandeln wir später. Wichtig für uns ist: wenn wir einen String (Zeichenkette) verwenden wollen, dann verwenden wir string als Variablentyp:

    #include<string> //für string
    #include<iostream>
    using namespace std;

    int main()
    {
        string str="Hallo Welt";
        cout<<str<<"\n";
    }

In C ist jede Zeichenkette ("Hallo") ein char-Array welches mit einer 0 terminiert wird. Später dazu mehr.

Es gibt (außer bei bool und natürlich string) die Modifizierungen: signed bzw. unsigned. signed bedeutet dass die Variable auch negativ sein kann, unsigned bedeutet, dass sie nur positiv sein kann. Der Vorteil von unsigned ist, dass man dann natürlich höhere Werte speichern kann.

Bei int gibt es die Einteilung in short, int und long. short ist ein 'kleiner' int, während long ein 'großer' int ist.

Variablen haben auch einen Sichtbarkeitsbereich (zu englisch: Scope). Eine Variable existiert nur in ihrem Sichtbarkeitsbereich. Wie sieht so ein 'Scope' jetzt aber aus?

  #include<iostream>
  using namespace std;

  int main()
  {
    int a; //hier wird a erzeugt
    {
      int b; //hier wird b erzeugt
      //irgend ein wichtiger code
      int c; //hier wird c erzeugt
    } //hier werden b und c geloescht
    int d; //hier wird d erzeugt
  } //hier werden a und d geloescht
  

Wenn wir eine Variable definieren

    int var;

dann sagen wir dem Compiler: hey du! Ich will eine Variable mit Namen var vom Typ int haben.

Wenn wir eine Variable initialisieren (dies impliziert eine Definition)

    int var=7;
    //oder auch
    int var(7);
    //beide sind identisch!
    

dann sagen wir dem Compiler: ey, alter! Ich will dass diese Variable mit Namen var vom Typ int (bis hierher ist es eine Definition) mit dem Wert 7 vorbelegt werden soll.

Eine Zuweisung würde so aussehen

    var=7;

damit sagen wir dem Compiler, dass wir der bereits definierten (aber möglicherweise noch nicht initialisierten) Variablen var den Wert 5 zuweisen wollen.

Variablen sollten so spät wie möglich definiert werden - am Besten erst dann, wenn wir sie wirklich brauchen.

Es gibt zusätzlich auch noch eine Deklaration

    extern int var;

mit dieser sagen wir: es gibt irgendwo eine Variable mit Namen var vom Typ int. Aber wo verrate ich dir noch nicht. Hier wird kein Speicher angelegt, sondern nur lediglich bekanntgegeben, dass es diese Variable gibt. Eine Definition und eine Initialisierung implizieren somit auch eine Deklaration.

Mittels extern kann man eine Variable nur deklarieren, denn ohne extern wäre es ja eine Definition. Wo das Sinn macht erfahren wir aber erst später.

Mit Variablen lässt sich auch Rechnen:

Zu deiner Aufgabe:

  int main()
  {
    int a;
    {
      int b;
      {
        int c;
      }
      int d;
      {
        int e;
        int f;
      }
      int g;
    }
    int h;
    {
      {
        {
          int i;
        }
        int j;
      }
      int k;
    }
  }

top