unsigned → ohne Vorzeicehn, es lassen sich nur positive Werte abbilden

• Variablen denen nur bei der Deklaration ein Wert zugewiesen werden kann
• Im Programmverlauf können sie nicht mehr geändert werden

const Typ Bezeichner = Wert

• Ersetzt if-Anweisung wenn nur entweder ein Wert oder ein anderer zurückgegeben werden soll (Abhängig von der Bedingung)
• Liefert je nach dem ob der Ausdruck wahr ist Wert1 oder Wert2 zurück

Syntax: (Bedingung)?Wert wenn True:Wert wenn false;

• Definieren neue Typen
  • ähnlich Variablentypen oder struct - nur das Klassen auch Methoden umfassen können
• können Methoden und andere Typen umfassen

Deklaration:

class //Klassenname//
{
      Private:
                //Variablen-Deklaration1//;
                //Methoden-Deklaration1//;
      Public:
               //Variablen-Deklaration2//;
               //Methoden-Deklaration2//;
};

//Rückgabetyp// //Klassenname//:://Methodenname(//Parameterliste//)
{
         Code;
}

class Testklasse
{
     Private:
               int rechnen(int, int);
               int ergebnis;
     Public:
               void ausgabe ()
};

int Testklasse::rechnen(int a, int b)
{
       int p_return;
       p_return=a+b;
       return(p_return);
}

• Klassenname: Name der Klasse
• Private/Public: Definiert ob die dahinter/darunter definierten Methoden und Variablen als von außerhalb der Klasse zugänglich (public) oder für nur von der Klasse zugänglich (private). Hinweis: Public/Private kann auch direkt vor einer Variablen-Deklaration angegeben werden - muss aber immer mit : enden, also Private: oder Public:
  • Nur auf Methoden und Attribute/Variablen die public sind kann von außerhalb des Objektes zugegriffen werden - private Methoden und Attribute können von außerhalb des Objektes nicht aufgerufen werden
  • Ausnahme: Objekte des gleichen Typs können auf private Elemente der jeweils anderen des gleichen Typs zugreifen → 2 Objekte der Klasse Car, können gegenseitig auf ihre privaten Elemente zugreifen
• Variablen-Deklaration: Deklaration von Variablen - genauso wie außerhalb einer Klasse auch → man kann vor jeder einzelnen Variable private/public angeben
• Methoden-Deklaration - (nicht Definition → es steht also nicht der Code der Methode an dieser Stelle) - Deklaration wie außerhalb einer Klasse auch → Rückgabetyp Methodenname (Übergabety1, Übergabetyp2)
  • bei der Deklaration werden für die Übergabevariablen keine Namen angegeben, nur Typen
  • vor jeder Methode kann private bzw. public angegeben werden
• Definition Methode:
  • Definition Methode erfolgt wie bei normalen Methoden außerhalb von Klassen
  • vor den Methodenname wird durch : getrennt der Klassenname gesetzt
  • Methoden von Klassen müsen innerhalb der Klasse deklariert worden sein

Achtung: KLassendefinitionen müssen nach der letzten Klammer } mit ; abgeschlossen werden (Klassenmethoden nicht).

• Methode die automatisch beim erschaffen eines Objektes aufgerufen wird
• hat jede Klasse automatisch
• verfügt standardmäßig über keinen Code
• kann durch Programmierer mit Code, der beim Erstellen eines Objektes aus der Klasse ausgeführt werden soll, gefüllt werden
• Methode hat den gleichen Namen wie die Klasse

Syntax:

class Klassenname
{
      public: Klassenname();
      KLassendefinitioon;
};

Klassenname::Klassenname ()
{
    Code;
}

• Methode wird automatisch aufgerufen wenn ein Objekt aufgelöst wird
• jede Klasse hat automatisch diese Methode → ist leer
  • Programmierer kann Code definieren der beim auflösen eines Objektes ausgeführt werden soll
• hat den gleichen Namen wie die Klasse, mit vorangestellter ~

Syntax:

class Klassenname
{
          public: ~KLassenname
}

Klassenname::~KLassenname()
{
         Code;
}

• nicht zu verwechseln mit static
• konstante Methoden können keine Elementvariablen ändern und auch keine Parameter übernehmen
• soll Programmierern helfen Methoden sauber zu deklarieren die keine Variablen ändern sollen
  • zum Beispiel Abfragemethoden, die nur Werte an den Clienten (Aufrufer) zurückgeben sollen → durch das const wird sicher gestellt, dass keine Implementierungsfehler unterlaufen, weil der Compiler dann weiß was der Programmier bezwecken will

Syntax:

class Klasse
{
        public:
                 Rückgabetyp Methode() const;
}

Rückgabetyp Klasse::Methode() const
{
     Code;
}

• Wird durchlaufen solange die Bedingung im Schleifenkopf wahr (gegeben) ist
• Ist die Bedingung bereits beim ersten Durchlauf nicht gegeben, wir der Code innerhalb der Schleife nicht durchlaufen

Syntax:

while (Bedingung)
{
       Code;
}

while (i<8)
{
        cout << "Der Wert des Zählers ist: " << i;
}

Eine Sonderbedingung ist true, sie führt zu einer Endlosschleife, die mit break abgebrochen werden muss.

* stellen dem Programmierer fertige Funktionen/Klassen/Methoden zur Verfügung, die er nicht selbst erstellen muss * 3 Arten von Bibliotheken

Namenskonvention ist nicht vorgeschrieben und jeder kann seine eigene haben → aber man sollte eine haben, da man sonst nicht mehr durchsieht was ein Objekt ist, was eine Variable welchen Typs ist und in welchen Rahmen eine Variable gültig ist.

Folgendes passiert nacheinander:

• Auf dem Stack wird die Speicherposition des ersten Befehls nach der Funktion abgelegt (Rücksprungadresse)
• Auf dem Stack wird Speicher für den Rückgabewert freigehalten
• Der Befehlszeiger wird inkrementiert und verweist auf den Beginn der Funktion
• Die höchste Position des Stacks wird gespeichert (alle was danach gespeichert sind lokale Variablen innerhalb der Funktion)
• Die lokalen Variablen innerhalb der Funktion werden auf dem Stack abgelegt
• die Funktion wird ausgeführt

Ist die Funktion durchgelaufen passiert folgendes:

• lokale Variablen werden vom Stack gelöscht
• Rückgabewert wird in Zielvariable gespeichert und vom Stack gelöscht
• Codezeiger wird auf Rücksprungadresse gesetzt
• Rücksprungadresse wird vom Stack gelöscht

Alle Daten der Funktion sind vom Stack entfernt.
Der Stack wird immer der Reihenfolge nach belegt und wieder gelöscht.