Objekte wie Hund und Katz

Transkript

1 Objekte wie Hund und Katz Wir wollen den Titel wörtlich nehmen und Hunde sowie Katzen als neue C++ Objekte (= eigener Datentyp) definieren. Dazu gibt es in C die Struktur (struct), in C++ zusätzlich die Klasse (class). In C++ ist der Unterschied zwischen beiden Varianten nicht sehr groß! Objekte in C können nur Daten (sog. Attribute) als Bestandteile haben (etwa den Namen des Hundes), in C++ können auch Funktionen zum Objekt gehören. Solche Funktionen nennt man Methoden. Unser Objekt Hund soll einen Namen besitzen (Attribut std::string name), sowie "sprechen" können (Methode void spricht()). Ein erster Versuch wäre class Hund bzw. struct Hund std::string name; std::string name; void spricht(); void spricht(); // der Strichpunkt ist Wichtig!!!! // der Strichpunkt ist Wichtig!!!! Damit ist das Objekt schon definiert, obwohl der Code für die Methode spricht() noch gar nicht programmiert wurde. Solange diese Methode nicht verwendet wird, beschwert C++ sich nicht. Ein kleines Hauptprogramm dazu könnte lauten: int main() Hund h; h.name = "Waldi"; return EXIT_SUCCESS; Man sieht, dass auf die Bestandteile der Objektinstanz h vom Typ Hund mit dem Punkt- Operator zugegriffen wird (h.name = ). Definiert man das Objekt als Klasse (linke Variante), gibt C++ eine Fehlermeldung aus (name ist private). Verwendet man ein struct (rechte Variante), ist alles in Ordnung! Konvention: Klassennamen und Strukturnamen sollten mit einem Großbuchstaben beginnen, Attribute und Methoden mit einem Kleinbuchstaben. Das ist kein Muss sondern anerkannte Praxis. Zugriffsschutz und Zugriffsrechte: Die Bestandteile eines Objekts (struct wie class, Attribute wie Methoden) besitzen immer einen Zugriffsschutz, der eine der 3 Stufen public, private, protected ist.

2 Jede Funktion im gesamten Programm kann das Attribut lesen und schreiben bzw. die Methode aufrufen. Nur die Methoden der Klasse sowie Funktionen, die in der Klasse als Freund (friend) deklariert sind, dürfen diese Attribute verwenden/methoden aufrufen. protected: Nur die Methoden der Klasse und deren Nachkommen sowie Funktionen, die in der Klasse als Freund (friend) deklariert sind, dürfen diese Attribute verwenden bzw. diese Methoden aufrufen. Beim Zugriff auf die Attribute unterscheidet man nicht zwischen Lesen und Schreiben, d.h. man kann nicht eines erlauben und das andere verbieten. struct und class unterscheiden sich nur in der Default-Einstellung des Zugriffsschutzes. Beim struct ist der Defaultwert public (deshalb hier auch keine Fehlermeldung), bei class ist der Defaultwert private. Die meist richtige Empfehlung lautet: Attribute sollen private, Methoden public sein. Außerdem sollten alle Berechtigungen explizit vergeben werden: class Hund bzw. struct Hund std::string name; std::string name; void spricht(); void spricht(); Eine explizite Berechtigung (wie ) gilt so lange, bis sie durch eine andere Berechtigungsangabe widerrufen wird. Theoretisch könnte man beliebig viele etc. in der Klasse haben, in der Praxis sollte jede Berechtigung maximal einmal vorkommen (wobei protected: meistens fehlt). Mit diesen Änderungen verhalten sich nun struct und class gleich, sodass ab jetzt nur noch die class Version weiter ausgebaut wird. Beide erzeugen nun dieselbe Fehlermeldung (name ist private, d.h. main() darf nicht darauf zugreifen).

3 Zugriff auf die "verbotenen" Attribute: Da nur Klassenmethoden (und als friend deklarierte Funktionen) auf die privaten Attribute zugreifen können, muss man solche Methoden schreiben, um auch von außerhalb zugreifen zu können. Man wählt oft die Namen get für Lesezugriffe, set für Schreibzugriffe. In unserem Fall bräuchten wir eine Methode std::string getname(), die den Namen des Objekts zurückgibt, und eine Methode void setname(const char* neuername), die den Namen des Objektes setzt. Unser Programm lautet nun class Hund std::string name; void spricht(); std::string getname(); void setname(const char* neuername); int main() Hund h; h.setname("waldi"); h.spricht(); return EXIT_SUCCESS; C++ beanstandet jetzt "nur noch", dass die zwei in main() verwendeten Klassenmethoden noch gar nicht programmiert sind. Wo und wie programmiert man die Klassenmethoden? 1) (von Stil-Puristen verschmäht!): innerhalb der Klassendefinition. Man ersetzt die Deklaration der Methoden durch deren Programmcode. Das ist nur bei sehr kurzen Funktionen sinnvoll, Puristen wollen selbst das nicht. 2) Außerhalb der Klassendefinition (für Stil-Puristen das einzig Wahre), bei größeren Projekten in einer eigenen.cpp Datei. Damit C++ weiß, dass es sich um die Methode setname() der Klasse Hund handelt (und nicht um eine Klassenmethode der Klasse Katze oder um eine normale Funktion, die zu keiner Klasse gehört), muss man hier die Funktion mit ihrem Scope angeben: Hund::setName():

4 Variante 1 führt zu: class Hund string name; void spricht() cout << name << " bellt wauwau!\n"; string getname() return name; void setname(const char* neuername) name = neuername; Variante 2 führt zu: class Hund string name; void spricht(); string getname(); void setname(const char* neuername); void Hund::spricht() cout << name << " bellt wauwau!\n"; void Hund::setName(const char* neuername) name = neuername; string Hund::getName() return name; Konstante Klassenmethoden: Methoden, die das Objekt nicht verändern, sollten als konstante Klassenmethoden definiert. Von unseren 3 Methoden kommen getname() und spricht() dafür in Frage. Ihnen

5 stellt man ein const nach. Diesen Zusatz muss man sowohl in der Klasse als auch (bei Variante 2) bei der Funktionsdefinition machen. Vergisst man das, erinnert C++ mit einigen Fehlermeldungen daran! Variante 1: class Hund string name; void spricht() const cout<<name << " bellt wauwau!\n"; string getname() const return name; void setname(const char* neuername) name = neuername; Variante 2: class Hund string name; void spricht() const; string getname() const; void setname(const char* neuername); void Hund::spricht() const cout << name << " bellt wauwau!\n"; void Hund::setName(const char* neuername) name = neuername; string Hund::getName() const return name;

6 Konstruktoren und Destruktoren Wann immer man in C++ ein Objekt definiert, d.h. eine Variable vom Typ des Objekts anlegt (der Fachausdruck dafür ist instanziert), ruft C++ an genau dieser Stelle eine spezielle Klassenmethode auf, einen Konstruktor. Jeder Konstruktor heißt gleich wie die Klasse, verschiedene Konstruktoren müssen sich daher in der Argumentliste unterscheiden. Wann immer in C++ ein Objekt vernichtet wird, ruft C++ an genau dieser Stelle eine spezielle Klassenmethoden auf, den Destruktor. Der Destruktor (es gibt nur einen) hat den Namen ~Klasse() und keine Argumente. Sehen wir uns das Hauptprogramm an: int main() Hund h; // Konstruktoraufruf h.hund() h.setname("waldi"); h.spricht(); return EXIT_SUCCESS; // Destruktoraufruf h.~hund() Bis jetzt haben wir weder Konstruktoren noch den Destruktor deklariert oder programmiert. Aber hier hilft C++ weiter: 1) besitzt ein Objekt keinen einzigen Konstruktor (und es wird einer benötigt), so fügt C++ einen ganz einfachen public Konstruktor zur Klasse hinzu: Hund() 2) besitzt ein Objekt keinen Destruktor (und es wird einer benötigt), so fügt C++ einen ganz einfachen public Destruktor zur Klasse hinzu: ~Hund() Konstruktoren haben weder einen Typ (also kein void voranstellen), noch hat ein Destruktor ein Argument (auch hier bitte kein void). Natürlich könnte man selbst solche einfachen Methoden schreiben, aber wozu, wenn die C++ Varianten ausreichend sind.

7 Wozu benötigt man überhaupt Konstruktoren und Destruktoren? Man benutzt die Automatik von C++, um Objekte richtig zu initialisieren oder um Ressourcen zu allozieren oder zu deallozieren, ohne dass diese Funktionen explizit aufgerufen werden müssen. Hier könnte man z.b. einen Konstruktor schreiben, der einen Namen vollautomatisch setzt (dann könnte man z.b. die setname()-methode einsparen, außer man möchte einen Hund später umbenennen). Dieser Konstruktor lautet folgerichtig Hund(const char* neuername). Variante 1: (in der Klasse) Hund(const char* neuername) name = neuername; Variante 2: In der Klasse Außerhalb: Hund(const char* neuername); Hund::Hund(const char* neuername) name = neuername; Allerdings erzeugen beide Varianten nun eine Fehlermeldung in der Zeile Hund h; C++ will/muss hier einen Konstruktor aufrufen, und zwar den Konstruktor ohne Argumente. Und diesen gibt es nun nicht mehr, da die Klasse einen selbstgeschriebenen Konstruktor besitzt und C++ daher diesen nicht mehr dazugibt. 2 Auswege: Man fügt zur Klasse den Konstruktor ohne Argumente (= Default Konstruktor) selbst hinzu oder aber man erzeugt h mit dem einzigen jetzt existierenden Konstruktor. Folgende Varianten sind hier möglich und fast immer äquivalent: Hund h("waldi"); // String-Argument in Klammern () Hund h = "Waldi"; // das ist keine Zuweisung Hund h = "Waldi" // das ist keine Zuweisung (C++11) Hund h "Waldi" // String-Argument in Klammern (C++11)

8 Rekursive Konstruktor- und Destruktoraufrufe: Alle Konstruktoren und auch der Destruktor haben folgende Automatik eingebaut: Ist ein Klassenattribut selbst ein Objekt (also kein Pod = plain old data, wie int, double, Pointer ), so wird VOR dem Konstruktorcode ein Konstruktor für dieses Attribut aufgerufen (Im Destruktor wird NACH dem Destruktorcode der Destruktor für dieses Attribut aufgerufen). Enthalten diese Attribute selbst wieder Objekte, setzt sich die Aufrufkette fort. Unser Hund besitzt ein solches Attribut (std::string ist selbst eine Klasse), sodass vor dem Konstruktorcode von Hund() der std::string-konstruktor für name aufgerufen wird (der name als leeren String erzeugt). Wenn der Programmierer nichts anderes vorsieht, wird jeweils der Default Konstruktor der Attribute aufgerufen (s.u.) Der Destruktor ~Hund()ruft nach seinem Code den std::string-destruktor für name auf, der den dafür reservierten Speicher zurückgibt. Initialisierungslisten: Bei Konstruktoren kann der Programmierer selbst bestimmen, welchen Konstruktor er für seine Attribute aufrufen will (er kann aber den Konstruktoraufruf NIE verhindern!). Das geschieht durch sog. Initialisierungslisten. Nach einem Doppelpunkt listet man alle Attribute und den dafür vorgesehenen Konstruktoraufruf auf, bei mehreren Attributen mit Beistrich getrennt. Für fehlende Attribute wird, wie gehabt, deren Defaultkonstruktor aufgerufen. Variante 1: (in der Klasse): Es gibt 2 Syntax-Varianten Hund(const char* neuername) : name(neuername) Hund(const char* neuername) : nameneuername Variante 2: (außerhalb der Klasse): Es gibt 2 Syntax-Varianten Hund::Hund(const char* neuername) : name(neuername) Hund::Hund(const char* neuername) : nameneuername Selbst Pods können mit dieser Syntax initialisiert werden. Hätte unser Hund ein Attribut int kinder, so könnte man z.b. den Konstruktor so schreiben: Hund::Hund(const char* neuername) : name(neuername), kinder0 oder auch: Hund::Hund(const char* neuername) : name(neuername), kinder

9 Konventionen: Die Verwendung von Initialisierungslisten ist der Verwendung von Zuweisungen vorzuziehen. Verwendet man eine Initialisierungsliste, sollte man möglichst alle Attribute explizit anführen, also auch jene, für die man den Default-Konstruktor aufrufen möchte: meinattibut() oder besser meinattribut Verpflichtend: Verwendet man eine Initialisierungliste, so sind die Attribute in derselben Reihenfolge anzugeben, wie sie in der Klassendefinition deklariert sind. Wir füttern unseren Hund Wir wollen unseren Hund auch noch füttern. Dazu schreiben wir eine Funktion void fuettere(const Hund& h), in der wir unserem Hund sein Lieblingsfutter verabreichen. Da verschiedene Hunde verschiedene Vorlieben haben, speichern wir im neuen Attribut std::string futter die Lieblingsmarke unseres Hundes. Das Setzen dieses Attributs übernehmen wir im Konstruktor, der nun ein zweites Argument wieder ein String-Literal - bekommt. Aus der Werbung wissen wir, dass Hunde am liebsten Chappy futtern, sodass wir diese Marke als Default-Argument einrichten. Außerdem geben wir aus, dass der Hund kreiert wurde. Zudem schreiben wir noch einen Destruktor für die Klasse. Dieser heißt wie die Klasse mit einer Tilde vorangestellt und hat KEINE Argumente: ~Hund(). Dafür entfernen wir die eigentlich nicht mehr benötigte Methode setname(). Ab jetzt aus Platzgründen nur mehr die Variante a: class Hund string name, futter; Hund(const char* Name, const char* Futter = "Chappy") : namename, futterfutter cout << "Hund " << name << "betritt das Programm.\n"; ~Hund() cout << "Hund " <<name<< " verlaesst das Programm.\n"; void spricht() const cout<< name<< " bellt wauwau!\n"; string getname() const return name; void fuettere(const Hund& h) cout << h.getname() << " bekommt " << h.futter << '\n'; h.spricht(); // Als Dank bellt er dann

10 int main() Hund h1"pongo", // "Pongo" mag "Chappy" h2"perdita", "Pedigree" // "Perdita" steht auf "Pedigree" fuettere(h1); fuettere(h2); return EXIT_SUCCESS; Das Füttern funktioniert noch nicht, da ich hier auf das private Attribut futter zugreife. Man beachte, dass ich statt des (ebenfalls nicht erlaubten) Zugriffs auf name die Methode getname() verwende, die ist. Man könnte (und sollte) natürlich eine analoge Funktion getfutter() schreiben. Aus didaktischen Gründen (um dieses Feature zu demonstrieren) mache ich die Funktion fuettere() zu einem Freund der Klasse Hund, sodass sie tatsächlich auch auf die privaten Dinge zugreifen darf. Die Klassendefinition wird nun zu: class Hund string name, futter; friend void fuettere(const Hund& h); Hund(const char* Name, const char* Futter = "Chappy") : namename, futterfutter cout << "Hund " << name << "betritt das Programm.\n"; ~Hund() cout << "Hund " <<name<< " verlaesst das Programm.\n"; void spricht() const cout<< name<< " bellt wauwau!\n"; string getname() const return name; Natürlich dürfte die Funktion void fuettere() jetzt auch auf name direkt zugreifen, ohne dafür getname() zu verwenden. Achtung: Bei der friend-definition muss der Funktionskopf exakt übereinstimmen, selbst das const ist wichtig! (die Funktionen void fuettere(const Hund& h) und void fuettere(hund& h) sind unterschiedlich!!!!)

11 Konstruktoren sind manchmal unerwünschte Typumwandler Konstruktoren mit nur einem Argument (oder die für die restlichen Argumente Defaultwerte vereinbart haben) werden von C++ auch als Typumwandlungsfunktionen verwendet. Hund(const char* neuername, const char* neuesfutter = "Chappy") Dieser Konstruktor erfüllt genau diese Voraussetzungen (das Futter hat einen Defaultwert) und ist deshalb auch eine Typumwandlung von const char* nach Hund. Die Anweisung in z.b. main(): h1 = "Kunigunde"; würde funktionieren: Zunächst handelt es sich dabei um den Zuweisungsoperator der Klasse Hund, den C++ automatisch erstellt, wenn keiner definiert wurde und wenn einer verwendet wird. Dieser weist einer Instanz vom Typ Hund einen Ausdruck vom Typ Hund zu. Rechts vom = steht zwar kein Ausdruck vom Typ Hund sondern ein C-String. Durch obigen Konstruktor kann dieser jedoch in einen Hund umgewandelt und zugewiesen werden, was C++ auch macht. C++ führt hier also die Anweisung h1 = Hund"Kunigunde" aus. Ebenso würde fuettere("reinhard Stix"); in fuettere( Hund"Reinhard Stix" ); umgewandelt und ausgeführt werden. Ein solches Verhalten ist oft unerwünscht (ich bin definitiv kein Hund). Verhindern kann man das mit dem Schlüsselwort explicit bei der Konstruktordefinition: explicit Hund(const char* neuername, Obiger Konstruktor wird nicht mehr implicit eingesetzt: h1 = Hund"Kunigunde" // erlaubt, da expliziter Aufruf h1 = "Kunigunde"; // Fehler, rechts steht kein Hund Zum Hund eine Katz Wenn zu unseren Hunden noch eine Katze (etwa "Garfield", der "Lasagne" mag) hinzukommt, wird unser Programm kompliziert. Am einfachsten ist noch das Hauptprogramm:

12 int main() Hund h1"pongo", // "Pongo" mag "Chappy" h2"perdita", "Pedigree" // "Perdita" steht auf "Pedigree" Katze k"garfield", "Lasagna" // was sonst fuettere(h1); fuettere(h2); fuettere(k); return EXIT_SUCCESS; Damit das alles funktioniert, müssen wir 1) entweder die Klasse Katze analog zur Klasse Hund erstellen sowie die neue Funktion void fuettere(const Katze& g) schreiben, die bis auf die Typangaben absolut gleich aussieht. Überhaupt stellt man fest, dass der Code der beiden Klassen fast völlig übereinstimmt. 2) versuchen, möglichst wenig Code zu duplizieren. Dazu kreieren wir eine neue Superklasse Haustier, die den gemeinsamen Code enthält und konstruieren die Klassen Hund und Katze als Varianten davon: Variante 1: class Hund string name, futter; friend void fuettere(const Hund& h); Hund(const char* Name, const char* Futter = "Chappy") : namename, futterfutter class Katze string name, futter; friend void fuettere(const Katze& h); Katze(const char* Name, const char* Futter = "Chappy") : namename, futterfutter

13 void fuettere(const Hund& h) cout << h.name << " bekommt " << h.futter << '\n'; h.spricht(); // Als Dank bellt er dann void fuettere(const Katze& k) cout << k.name << " bekommt " << k.futter << '\n'; k.spricht(); // Als Dank miaut sie dann Variante 2: (funktioniert noch nicht ganz) Zunächst bestimmen wir die Gemeinsamkeiten von Hund und Katze und machen daraus das Haustier. Diese Teile entfernen wir aus unseren 2 alten Klassen und ersetzen das durch die Vererbung: class Hund : public Haustier etc. class Haustier string name, futter; friend void fuettere(const Haustier& h); Haustier(const char* Name, const char* Futter = "Chappy") : namename, futterfutter cout << "HT " << name << "betritt das Programm.\n"; ~Haustier() cout << "HT " << name << " verlaesst das Programm.\n"; void spricht() const cout << name << "???????!\n"; string getname() const return name; class Hund : public Haustier // Hund IST EIN Haustier: Vererbung explicit Hund(const char* Name, const char* Futter = "Chappy"): namename, futterfutter cout << "Hund " << name << "betritt das Programm.\n"; ~Hund() cout << "Hund " <<name<< " verlaesst das Programm.\n";

14 class Katze : public Haustier // Katze IST EIN Haustier: Vererbung explicit Katze(const char* Name, const char* Futter = "Kitekat") : HaustierName, Futter cout << "Katze " << name << "betritt das Programm.\n"; ~Katze() cout << "Katze "<<name<< " verlaesst das Programm.\n"; Dass Hund von Haustier abgeleitet ist, bedeutet dass Hund ein Haustier ist und alle dessen Teile erbt: name, futter, getname(). Insbesondere sind die Aufrufe fuettere(h1) und fuettere(k) korrekt, da Hunde (und Katzen) eben auch Haustiere sind. Trotzdem erhalten wir Fehlermeldungen: Hund::spricht()greift auf name zu, welches jetzt aber ein Attribut von Haustier ist. Abgeleitete Klassen dürfen nicht auf die privaten Dinge der Basisklasse zugreifen! (Wäre das schön, wenn Kinder nicht auf die privaten Dinge der Eltern zugreifen dürften ). Wir ändern daher diese Berechtigungen auf protected: class Haustier protected: // jetzt duerfen auch Hund und Katze darauf zugreifen string name, futter; friend void fuettere(const Haustier& h); Allerdings bellen und miauen unsere Tiere nicht, sondern zeigen nur Fragezeichen??????? an. Sollen Methoden in den abgeleiteten Klassen anders funktionieren als in der Basisklasse, muss man sie dort neu definieren. Wir fügen also unsere alten spricht()- Methoden wieder zu den Klassen Hund und Katze hinzu. Das funktioniert zwar in expliziten Aufrufen (z.b. in main(): h1.spricht(); ) Allerdings bellen und miauen unsere Tiere nicht nach dem Füttern und zeigen dort nur Fragezeichen???????. fuettere() ruft natürlich die Methode Haustier::spricht() und nicht etwa Hunde::spricht() oder Katze::spricht() auf, da das Argument ja eine Haustier-Referenz ist. Das ändern wir, indem wir in der Klassendefinition von Haustier diese Methode als virtual definieren.

15 Da das mit den virtuellen Methoden eine ziemlich schwierige Sache ist, empfiehlt C++11, in den abgeleiteten Klassen diese Methoden mit override zu kennzeichnen. Dann überprüft C++ auch, ob diese tatsächlich die virtuelle Basismethode überlagern. Technische Erläuterung: Virtuelle Methoden werden nicht direkt aufgerufen sondern durch einen Aufruf über eine Sprungtabelle. Diese Sprungtabelle wird nur erzeugt, wenn virtuelle Funktionen in der Basisklasse vorhanden sind und sie enthält auch nur diese virtuellen Funktionen. In unserem Beispiel ist es nur die Funktion spricht(), die virtuell ist. Wird ein Haustier-Objekt erzeugt, zeigt der Eintrag in der Sprungtabelle auf Haustier::spricht(), bei einem Hund aber auf Hund::spricht(),bei einer Katze auf Katze::spricht(). So wird selbst bei einer Referenz auf die Basisklasse die Methode der abgeleiteten Klasse aufgerufen. Klassenhierarchien mit virtuellen Methoden (und auch andere Klassenhierarchien ebenso) sollten immer auch den Destruktor der Basisklasse virtuell machen. Man kann dieses Problem so demonstrieren: Haustier* h = new Hund"Waldi" delete(h); Dadurch würde h zu einem Pointer auf ein Haustier werden, der aber eigentlich auf einen frisch erzeugten Hund zeigt. Der Aufruf delete(h) verwendet den Typ von h und würde daher den Destruktor von Haustier ( h->~haustier()) aufrufen und nicht den eigentlich richtigen Destruktor von Hund ( h->~hund()). Diesen Fehler vermeidet man durch die Definition eines virtuellen Destruktors. Der Aufwand ist nur dann nötig, wenn der Destruktor der abgeleiteten Klasse wirklich etwas anderes machen muss als jener der Basisklasse. Ich will hier noch daran erinnern, dass der Destruktor von Hund auch jenen der Basisklasse Haustier aufruft, d.h. es werden jetzt beide Destruktoren nacheinander abgearbeitet. Abstrakte Klassen Wollen wir zudem verhindern, dass Objekte vom Typ Haustier erzeugt werden können, können wir die Basisklasse zu einer "abstrakten Klasse" machen. Diese lässt sich nicht instanzieren. Das erreicht man, indem man eine Methode der Basisklasse als "= 0", definiert, hier am besten die eh nicht benötigte virtuelle Methode Haustier::spricht(). Die endgültigen Klassen Haustier und Hund: class Haustier protected: // jetzt duerfen auch Hund und Katze zugreifen string name, futter; friend void fuettere(const Haustier& h);

16 Haustier(const char* Name, const char* Futter = "Chappy") : namename, futterfutter cout << "HT " << name << "betritt das Programm.\n"; virtual ~Haustier() cout << "HT " << name << " verlaesst das Programm.\n"; virtual void spricht() const = 0; // dadurch abstrakte Klasse string getname() const return name; class Hund : public Haustier // Hund IST EIN Haustier: Vererbung explicit Hund(const char* Name, const char* Futter = "Chappy") : namename, futterfutter cout << "Hund " << name << "betritt das Programm.\n"; ~Hund() cout << "Hund " <<name<< " verlaesst das Programm.\n"; void spricht() const override cout << name << " bellt wauwau!\n"; // Katze analog