C++ Klassen weitere Funktionen

Transkript

1 C++ Klassen weitere Funktionen

2 Übersicht static Elemente const Elemente Zusätzliches zu Konstruktoren Kopier-Konstruktor Konvertierung-Konstruktor Initialisierungslisten Friend Funktionen 2

3 Statische Klassenkomponenten Alle Objekte einer Klasse erhalten bei der Instanzierung ihre eigenen Member-Variablen. Alternativ dazu können statische (static) Member- Variablen deklariert werden, die dann für alle Objekte der Klasse gemeinsam zur Verfügung stehen. Gründe für die Verwendung können sein: Ein Zähler, der die Anzahl der gerade aktiven Objekte der Klasse wiederspiegelt. Ein Zeiger auf einen dynamisch allokierten Speicherbereich, der von allen Objekten der Klasse geteilt wird. Eine Testvariable, die objektübergreifend gemeinsame Informationen aufnehmen kann. Vorteile gegenüber der Verwendung globaler Variablen sind: Durch die private-deklaration kann der Zugriff auf Member-Funktionen beschränkt werden. Der Bezugsrahmen bleibt innerhalb der Klasse. Damit können keine Kollisionen mit anderen Variablen gleichen Namens entstehen. 3

4 Statische Member-Variablen Regeln für die Initialisierung von static-member-variablen: Die Initialisierung darf nur außerhalb der Klassen-Definition vorgenommen werden und wird vom Compiler ohne Instanzierung von Objekten durchgeführt. Bei der Initialisierung muss der Datentyp angegeben und der Klassenbezug hergestellt werden. Das Schlüsselwort static darf nur bei der Definition und nicht bei der Initialisierung stehen. Die Variable kann initialisiert werden, auch wenn sie in der Klasse als private deklariert wurde. Eine Variable darf nur einmal initialisiert werden. Wird die Variable nur definiert und nicht initialisiert, so wird sie vom Compiler vorbelegt. 4

5 Statische Member-Variablen Beispiel für die Initialisierung von static-member-variablen: class Demo private: static double stv; //Initialisierung hier nicht möglich... double Demo::stv = 10.; //Initialisierung trotz private Demo::stv = 10.: //Fehler: Typangabe fehlt static double Demo::stv = 10.; //Fehler: static nicht erlaubt double stv = 10.; //Fehler: Klassenbezug notwendig double Demo::stv = 20.; //Fehler: Variable bereits initialisiert Empfehlung: Initialisierung von static-member-variablen nicht in Header-Dateien vornehmen, sondern zusammen mit der Definition der Member-Funktionen. 5

6 Statische Member-Variablen Regeln für den Zugriff auf static-member-variablen: Elementfunktionen der Klasse haben Zugriff auf static-member-variablen wie auf alle anderen Member-Variablen. Objekte der Klasse haben Zugriff auf static-member-variablen wie auf alle anderen Member-Variablen incl. aller Einschränkungen (Zugriffsschutz). Auf die static-member-variablen kann direkt unter Verwendung des Bezugsoperators und des Klassennamens zugegriffen werden. Allerdings greift auch hier der Zugriffsschutz. Empfehlung: Greifen Sie auf static-member-variablen nicht über die Instanzierung von Objekten sondern besser direkt zu, da die Variable allen Objekten gemeinsam zur Verfügung steht. 6

7 Statische Member-Variablen Beispiel für den Zugriff auf static-member-variablen: class Demo private: static int stvint; public: static double stvdbl;... int Demo::stvint = 10; double Demo::stvdbl = 20.; int j = Demo::stvint; Demo::stvint = 100; double x = Demo::stvdbl; Demo::stvdbl = 200.; Demo doobj; int k = doobj.stvint; doobj.stvint = 100; double y = doobj.stvdbl; doobj.stvdbl = 200.; //Initialisierung trotz private //OK //Fehler: Zugriffsverletzung //Fehler: Zugriffsverletzung //OK //OK //Instanziiere Objekt //Fehler: Zugriffsverletzung //Fehler: Zugriffsverletzung //erlaubt, aber nicht empfohlen //erlaubt, aber nicht empfohlen 7

8 Statische Member-Funktionen Problem: Eine Variable, die sowohl static als auch private deklariert ist, kann zwar direkt initialisiert werden, aber für den sonstigen Zugriff über eine gewöhnliche Elementfunktion muss immer ein Objekt instanziert werden. Nach den Ausführungen über static- Member-Variablen sollte genau dies aber vermieden werden. class Demo private: static int stv; public: int GetNumber(void) return stv;} //inline-definition... Demo doobj; //Instanziiere Objekt int j = doobj.getnumber( ); //Der einzige Weg zum Datum 8

9 Statische Member-Funktionen Lösung: Deklariere eine static-member-funktion, die folgende Eigenschaften aufweist: Die static-member-funktion wird definiert wie eine normale Element-Funktion. Die static-member-funktion kann direkt unter Verwendung des Bezugsoperators und des Klassennamens auf die static-member-variablen zugreifen, ohne ein Objekt instanzieren zu müssen. Allerdings greift auch hier der Zugriffsschutz. Der Compiler ergänzt keinen this-zeiger. Daher kann die static-member- Funktion ohne weitere Maßnahmen nur auf static-member-variablen zugreifen. Für Nicht-static-Member-Variablen müssen Objekte instanziert werden. Der Aufruf als normale Funktion über die Instanzierung von Objekten ist möglich, sollte jedoch vermieden werden. 9

10 Beispiel: Statische Member-Funktionen class Demo private: double nstvdbl; //non-static-variable static int stvint; //static-variable static void SetNumber(int i, double x); //Deklaration public: static int GetNumber(void) return stvint; //inline-definition void Demo::SetNumber(int i, double x) stvint = i; nstvdbl = x; }... Demo::SetNumber(2, 3.); int j = Demo::GetNumber( ); Demo doobj; int k = doobj.getnumber( ); //Definition //OK: static //Fehler: non-static //Fehler: Zugriffsverletzung //OK: direkter Zugriff //Instanziiere Objekt //erlaubt, aber nicht empfohlen 10

11 Konstante Klassenkomponenten Bei der Instanzierung eines Objektes einer Klasse kann diesem die Eigenschaft const zugeordnet werden. Damit darf das Objekt die Datenelemente seiner Klasse weder direkt (soweit public) noch indirekt über seine Elementfunktionen modifizieren. Für den lesenden Zugriff auf die Datenelemente muss die Elementfunktion ebenfalls als const deklariert sein. Regeln für const-deklarierte Elementfunktionen: Eine const-deklarierte Elementfunktion darf nur von const-deklarierten Objekten einer Klasse aufgerufen werden. Das Schlüsselwort const muss sowohl bei der Deklaration als auch bei der Definition angegeben werden. Eine const-deklarierte Elementfunktion kann von einer nicht-const-deklarierten Elementfunktion gleichen Namens überladen werden. Empfehlung: Verwenden Sie const-deklarierte Objekte insbesondere dort, wo große Objekte zur Einsparung von Kopieraufwand beim call-by-value als Zeiger oder Referenz übergeben werden. 11

12 Beispiel für const-deklarierte Elementfunktionen: class Demo private: int i; double *ptdbl; public: int GetNumber(void) const; void SetNumber1(double x) const; void SetNumber1(double x); void SetNumber2(double *y) const; void Demo::SetNumber1(double x) const *ptdbl = x;} void Demo::SetNumber1(double x) *ptdbl = x; i = 10} void Demo::SetNumber2(double *y) const ptdbl = y;}... const Demo conobj; Demo varobj; conobj.setnumber1(10.); varobj.setnumber1(20.); //Zeiger //Deklaration //const-elementfunktion //überladene Elementfunktion //Deklaration //Definition //OK: Zeiger bleibt unverändert //überladene Elementfunktion //OK: Funktion darf alles //Definition //Fehler: Zeiger darf nicht //verändert werden //const-objekt //verwendet SetNumber1 const //verwendet SetNumber1 non-const 12

13 Konstruktoren Spezielle Konstruktoren Standard Konstruktor (siehe vorh. Abschnitt) o KlassenName (void)..} o KlassenName (int k=0)..} Kopier-Konstruktor o KlassenName (const KlassenName &Objekt) Konversions-Konstruktor o KlassenName (const AndereKlasse &Objekt) 13

14 Kopier-Konstruktor Wird ein Objekt bei der Instanzierung durch ein anderes Objekt der gleichen Klasse initialisiert, und fehlt die explizite Definition eines Kopier- Konstruktors, so generiert der Compiler einen einfachen Kopier- Konstruktor, der die Inhalte der Member-Variablen elementweise kopiert: Problem: Beide Objekte haben zwar unterschiedliche Zeiger aber sie zeigen auf die identische Speicheradresse. class Demo private: int Test; int *Point; public: Demo() Test=10; Point=&Test;} void print () cout << "Test = " << Test << endl << "*Point = " << *Point << " at Adr : " << Point << endl; } int main () Demo obj; Demo obj1(obj); obj.print(); obj1.print(); return 0;} 14

15 Kopier-Konstruktor Führt eine "flache" Kopie aller Variablen (Standard Kopier- Konstruktor) zu falschen Ergebnissen: Eigenen Kopier-Konstruktor schreiben Eigenschaften genau ein Referenzparameter derselben Klasse normalerweise const Evtl. noch zusätzliche Default- Parameter kein normaler Parameter derselben Klasse o da call by value sonst zum rekursiven Aufruf führt class Demo private: int elemente; double *vektor; public: Demo(void); //Standard-Konst. Demo(int k);//überl.konstruktor Demo(const Demo &obj); //Kopier-Konstruktors Demo::Demo(const Demo &obj) elemente = obj.elemente; vektor = new double [elemente]; for (int i = 0, i < elemente, i++) vektor[i] = obj.vektor[i]; }... Demo obj1(10); // Demo(int) Demo obj2 = obj1; // Kopie (obj1) Demo obj3(obj2); // Kopie (obj2) 15

16 Zusammenfassung Kopier-Konstruktor Der automatische Aufruf des Kopier-Konstruktors erfolgt, wenn ein Objekt einer Klasse instanziert und mit einem Objekt der gleichen Klasse initialisiert wird oder ein Objekt als Aktualparameter einer Funktion verwendet (call-by-value) wird oder ein Objekt Rückgabewert (call-by-value) einer Funktion ist. Ist der Kopier-Konstruktor nicht explizit definiert, so wird er vom Compiler generiert. Formen des Kopier-Konstruktors, wenn Demo die Klasse ist und obj ihr Objekt: Demo (const Demo &obj); Demo (Demo &obj); Demo (const Demo &obj, int i = 0, double x = 0.); Demo (Demo &obj, int i = 0, double x = 0.); Kopier-Konstruktor immer mit Referenzparameter (->Rekursiv) Falls man das Kopieren von Objekten geziehlt verhindern möchte Demo (Demo &obj) ; // deklarieren aber nicht definieren 16

17 Konversions-Konstruktor Wird ein Objekt bei der Instanzierung durch ein anderes Objekt einer anderen Klasse initialisiert, so bedarf es eines Konversions-Konstruktors. Ein solcher Konstruktor wird vom Compiler nicht automatisch generiert. Das Fehlen des Konversions- Konstruktors wird vom Compiler moniert. class Klasse... class Demo public: Demo(const Klasse &pp); //Deklaration des Konversions- Konstruktors Klasse objklasse(100); //Instanziiere + initialisiere Objekt aus Klasse Demo objdemo(objklasse); //Instanziiere Objekt aus Demo //und initialisiere mit objklasse 17

18 Initialisierungslisten Bisher wiesen die Member- Variablen von Klassen nur einfache Datentypen auf. Sind Objekte einer anderen Klasse Member-Variablen der zu definierenden Klasse, so werden diese mit dem Konstruktor der zu definierenden Klasse über Initialisierungslisten initialisiert. class Sample public: Sample(Sample &ss);// Kopier-K. // Sample muss definiert sein! class Demo private: Sample objsample; const double y; int k; public: Demo(int i, double x, const Sample &oo); Demo::Demo (int i, double x, const Sample &oo) : y(x), objsample(oo) k = i;} Sample obj; Demo odemo(1, 1.4, obj); 18

19 Initialisierungslisten Syntax der Initialisierungsliste: klassenname::klassenname(parameterliste) : initialisierungsliste Eigenschaften der Initialisierungsliste: Sie steht bei der Definition des Konstruktors, nicht bei der Deklaration. Bei einfachen Variablen wird der Wert in der Klammer zur Initialisierung der Variablen verwendet. Die Klammer kann auch einen komplexen Ausdruck ent-halten. Bei Objekten wird der Kopier-Konstruktor zur Initialisierung des Objektes verwendet. Hat die Klasse, zu der das Objekt gehört, keinen Kopier-Konstruk-tor, so wird einer vom Compiler generiert, der eine einfache Kopie der Daten durchführt. Empfehlung: Definieren Sie immer einen Kopier-Konstruktor. Variablen und Objekte erhalten ihre Werte aus der Initialisierungsliste, bevor der Konstruktor zur Ausführung kommt. Die Member-Variablen werden in der Reihenfolge initialisiert, wie sie in der Definition der Klasse aufgeführt sind, nicht in der Reihenfolge, wie sie in der Initialisierungsliste erscheinen. Normale Variablen können durch Initialisierung oder durch Zuweisung mit Werten versorgt werden. Objekte und const-variablen müssen initialisiert wer-den. 19

20 friend-klassenkomponenten Ergänzend zu dem bisherigen Zugriffschutz für das Innere von Objekten mit zwei Differenzierungen private (keiner darf von außen zugreifen, außer über Elementfunktionen) public (alle dürfen von außen zugreifen) kann es sinnvoll sein, besonders vertrauenswürdigen Elementen den freien Zugriff auf private-elemente zu gestatten. Solche Elemente können sein: globale Funktionen Elementfunktionen anderer Klassen ganze Klassen Syntax: - friend typ funktionsname(parameter); - friend class klassenname; - friend typ klassenname::elementfunktionsname(parameter); Empfehlung: Gehen Sie zurückhaltend mit dem Einsatz des friend-konzepts um, da hiermit indirekt der Zugriffsschutz (Datenkonsistenz) umgangen wird. 20

21 friend-klassenkomponenten Die friend-deklaration erfolgt innerhalb der Definition derjenigen Klasse, deren private-daten und private-elementfunktionen zum Zugriff freigegeben werden sollen. Die Deklaration der friend-klasse oder friend-funktion kann irgendwo innerhalb der Klassendefinition stehen. Empfehlung: Direkt hinter den Deklarationskopf der Klasse positionieren. class Klasse1;//Vorwärts-Deklaration class Klasse2;//Vorwärts-Deklaration class Demo friend class Klasse1; //Klasse private: friend void Funktion1(float x); //Funktion1 ist friend zu Demo //und globale Funktion public: friend int Klasse2::Funktion2 (int i); //Funktion2 ist friend zu Demo //und Elementfunkt. von Klasse2 21

22 friend-klassenkomponenten Ist eine ganze Klasse (B) friend-klasse einer anderen Klasse (A), dann können alle Elementfunktionen der friend-klasse (B) auf die private-daten und private- Elementfunktionen von Klasse (A) zugreifen. Umgekehrt gilt dies nicht. Ist die Klasse, die friend-klasse einer zu definierenden Klasse werden soll, bisher selbst noch nicht definiert, so ist wenigstens eine Vorwärts-Deklaration notwendig und ausreichend. Eine Funktion, die in einer Klasse als friend-funktion deklariert wurde, ist nicht Member- Funktion dieser Klasse, d.h. - die friend-funktion befindet sich nicht im Bezugsrahmen der Klasse - die friend-funktion selbst hat keinen direkten Zugriff auf die Member-Daten. Es sind die instanzierten Objekte der Klasse, die innerhalb der Definition der friend-funktion den Zugriff auf die Member-Daten ermöglichen. - der Klassenbezugsoperator darf bei der Definition der Funktion nicht verwendet werden. Eine friend-funktion kann mit einer anderen Funktion überladen werden. Falls alle Funktionen friend-funktion der Klasse sein sollen, so muss jede überladende Funktion entsprechend als friend-funktion deklariert sein. Eine Funktion oder Klasse kann friend mehrerer (anderer) Klassen sein. Bei abgeleiteten Klassen vererbt sich die friend-eigenschaft nicht. 22

23 Beispiel friend Aufruf Fkt() ist "normal" definiert (nicht Demo::Fkt() Funktion kann nur über ein Objekt (d.h. eine Instanz) auf Klassenvariablen zugreifen Dann aber auch auf "private" Die Funktion muss auch "normal" aufgerufen werden. Sie ist KEINE Member -Funktion class Demo... friend void Fkt(void); private: int ipriv; public: int ipub ; void Fkt(void) }... ipub = 1; //Fehler: Demo obj1; obj1.ipub = 2; obj1.ipriv = 3; Demo obj2; obj2.ipub = 2; obj2.ipriv = 3; //Fehler: Fkt( ); obj2.fkt( ); //Fehler: 23