Schlagwort: Klassen

Swift: Vererbung

  • Alle Swift Objekte sind Subklassen der Klasse NSObjekt oder einer ihrer Subklassen. Die Superklasse wird mit : in der Definition angegeben
    class A: Superklasse.
  • Das Init muss alle Paramter der Superklasse enthalten und weist dieser mit super.init(variable1 = variable1) einen Wert zu
  • Variablen der Superklasse können (ohne super) im init überschrieben werden.  variable2 = 5;
  • Funktionen werden ausserhalb des init() überschrieben und brauchend das keyword override.Bsp der iOS Developper Site
    class NamedShape {
        var numberOfSides = 0
        var name: String
        
        init(name: String) {
            self.name = name     // self für eigene Klassenvariable
        }
        
        func simpleDescription() -> String {
            return "A shape with \(numberOfSides) sides."
        }
    }


    class Square: NamedShape {
        var sideLength: Double
        
        init(sideLength: Double, name: String) {
            self.sideLength = sideLength   // eigene Klassenvariable
            super.init(name: name)    // Variable der Superklasse
            numberOfSides = 4 // Überschreibt Variable der Superklasse
        }
        
        func area() ->  Double {
            return sideLength * sideLength
        }
        
        override func simpleDescription() -> String {
            return "A square with sides of length \(sideLength)."
        }
    }
    let testSquare = Square(sideLength: 5.2, name: "my test square")
    testSquare.area()
    testSquare.simpleDescription()

..

Klasse aufbauen

Die Klasse dient zum spezifischen Verarbeiten eines Objektes.

Das Objekt wird mit em Konstruktor gebildet Klasse::Klasse()

klasse

Um auf das Objekt zuzugreifen, es zu verändern oder den Zustand seiner Variablen zu kennen braucht man Klassen-Funktionen Klasse::funktion() .

Auf alle Klassenvariablen kann man nur über das Objekt zugreifen objekt.variable .

Bsp Huffman Map
– Konstruktor bildet die Map- hm.readToken(„stream.txt“)  Daten werden von aussen eingegeben und lokal im Objekt gespeichert
– hm.getBitValue()    Lokale Varibale wird verarbeitet und ausgegeben
– hm.getZeros()         Andere Variable wird verabeitet und ausgegeben

 

Objekt bearbeiten

Klasse

class MidiData {
.     public: 
.            // varibale
.            int pin;
.            double version;
.            int wait;        // in ms
.
.            // functions
.            MidiData(int pin, double version, int wait);   
.            string readStream( steam io);
.            string extractdata( string s);
}

Objekt definieren

MidiData system_2{ 8, 14.04, 5 }

system_2 ist ein Objekt der Klasse MidireadData. Im Objekt ist definiert, wo und mit welcher Version Midi gelesen wird.

Objeket bearbeiten

system_2.pin = 10;    // change data pin
system_2.wait = 10;   // change wait time

Zur Verarbeitung der Klasse wurden extra Memberfunktionen definiert.

string in_pin8 = system_2.readStream( input_8);
string data_pin8 = system_2.extractdata( in_pin8);

Über die Objektvariable system_2 können die Memberfunktionen aufgerufen werden.

 

Defintion Member functions

class MidiData {
.     public: 
.            // varibale
.            int pin;
.            double version;
.            int wait;        // in ms
.
.            // functions
.            MidiData(int pin, double version, int wait);   
.            string readStream( steam io);
.            string extractdata( string s);
}

Im public-Teil einer Funktion, wird die member-Funktion nur deklariert. Die Definition folgt ausserhalb.
Das gilt auch, wenn pro Klasse eine Datei erstellt wird.

Definition Member Function

<class>::<member-function>( <type> <argument> ) {
.      // Code
}
void Date::add_day( int n){
.      // Code
}
void Date:: month(){
.     // Code
}

..

Nested Klassen

Wenn innerhalb einer Klasse, eine andere Klasse gebraucht wird. Es entsteht dadurch eine Verschachtelung aus Klassen.

class C{
.     public:
.           struct M {
.                      //
.           };
};

 

C++ Geltungsbereich (Scope) von Variablen

lokale Variabeln überschreiben globale 8.4

Bjarne nennt in 8.4 unterschiedlichen Geltungsbereiche von Variablen
– global
– lokal
– in Klasse allein (siehe vektor unten)
– in Namensgebeit (z. B. struct, enum, …)
– in Aussagen (z. B. innerhalb eines for)

Der Geltungsbereich hat mit dem Datentyp etwas zu tun, und auf welchem RAM-Segment der Code abgelegt wird.

extern

extern int aktuelle_Version;

Die Variable wird nur deklariert und ist überall sichtbar.
Sie kann (theoretisch) in jedem File neu definiert und mit neuen Werten zugewiesen werden, das ist jedoch gefährlich. Besser ist es, nur in 1 File die Variable zu definieren und dann für alle anderen Files nur sichtbar zu machen.

Klasse

class MyVector{
.    // Klassenvariable. Gültigkeit in der Klasse 
.    vector <int> v      
.
.    public:
.          // öffentliche Funktion
.          int largest(){
.             int max = 0;
.             for (int i = 0; i < v.size(); i++) {
.               max = max( x, abs(v[i]) );
.             return max;  
.          }
.         // öffentliche Variable
.         int i;
.
};

Der Vektor v ist nur in der Klasse sichtbar. Ausserhalb exstiert er nicht und kann auch nicht angesprochen werden.

Argumente sind lokal

int funcition_b (int value_1){  
.  
.    //
}

Die Funktion ist global, aber der Parameter value_1  ist lokal bezüglich der function_b .

 

constexpr <function>
Lokale Variablen liegen FIFO im Stack. Man kann nicht auf sie zugreifen (Bjarne 8.5.9). Soll eine Funktion während dem Kompilieren definiert werden, braucht sie das Schlüsselwort constexpr bei all ihren Variablen und für die Funktion.

constexpr int scale_x = 3;
constexpr int scale_y = 2;
constexpr Point scale( Point P){
.
.     return { scale_x * P.x, scale_y * P.y };
}