Twitter und Facebook-Anbindung
X
Tweet Follow @twitterapi
!!! Anbindung an twitter und facebook öffnen !!!

Wenn Ihnen mein Online-Buch gefällt,
dann bedanken Sie sich doch mit einer kleinen Spende...

16.2 Die Datei TestKlasse.cpp

16.2 Die Datei TestKlasse.cpp

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
					
#include <stdio.h>
#include "TestKlasse.h"



// Standardkonstruktor ////////////////////////////////////////////////////////
CTestKlasse::CTestKlasse()
	:m_iZahl1(0)
	,m_iZahl2(0)
{} // CTestKlasse /////////////////////////////////////////////////////////////



// 1. Benutzerdefinierter Konstruktor /////////////////////////////////////////
CTestKlasse::CTestKlasse(int iValue)
	:m_iZahl1(iValue)
	,m_iZahl2(iValue)
{} // CTestKlasse /////////////////////////////////////////////////////////////



// 2. Benutzerdefinierter Konstruktor /////////////////////////////////////////
CTestKlasse::CTestKlasse(int iValue1, int iValue2)
	:m_iZahl1(iValue1)
	,m_iZahl2(iValue2)
{} // CTestKlasse /////////////////////////////////////////////////////////////



// Kopierkonstruktor //////////////////////////////////////////////////////////
CTestKlasse::CTestKlasse(const CTestKLasse& oTestObjekt)
	:m_iZahl1(oTestObjekt.m_iZahl1)
	,m_iZahl2(oTestObjekt.m_iZahl1)
{} // CTestKlasse /////////////////////////////////////////////////////////////



// Destruktor /////////////////////////////////////////////////////////////////
CTestKlasse::~CTestKlasse() {
} // ~CTestKlasse /////////////////////////////////////////////////////////////



// Gibt interne Werte aus /////////////////////////////////////////////////////
void CTestKlasse::Ausgabe(void) {
	// Variante 1
	printf("%i"\n, m_iZahl1);

	// Variante 2
	printf("%i"\n, this->m_iZahl2);
} // Ausgabe //////////////////////////////////////////////////////////////////
					

Ab Zeile 7 sehen Sie jetzt die Implementierungen, der zuvor definierten Methoden. Auffällig ist hier der s.g. Namespace vor den Methodennamen. Dies ist zwingend notwendig, damit der Compiler später weiß, welche Methode zu welcher Klassendefinition gehört. Es könnte ja sein, dass es noch eine andere Klasse im Projekt gibt, die eine Methode mit dem gleichen Namen hat und spätestens dann würde es zu Verwirrungen kommen.

Das Schema sieht so aus:
<Rückgabewert> <Klassenname>::<Methodenname>([<Parameterliste>]) {<Anweisung>}

Weiterhin auffällig ist Zeile 8 und 9. Hier tritt etwas auf, was Sie so noch nicht gesehen haben und was auch nur bei Konstruktoren funktioniert. Wie Sie vielleicht schon erahnen können, werden so die Attribute einer Klasse initialisiert. Sie werden später noch sehen, dass dies Teilweise sogar notwendig ist (Stichwort statische Klassenvariablen oder Basisklassenaufrufe).

Eine weitere Auffälligkeit ist, dass ich, wie Sie in den Zeilen 7, 16, 25 und 34 sehen, gleich vier verschiedene Konstruktoren gebaut habe, welche sich, so sagt man, gegenseitig überladen. Dem Standardkonstruktor erkennt man daran, dass ihm keine Werte übergeben werden. Jener kann vom Compiler automatisch erstellt werden, allerdings werden dann keine Membervariablen initialisiert. Falls Sie also sicherstellen wollen, dass vernünftige Startwerte vorliegen, müssen Sie selber einen Konstruktor bauen. Die Benutzerdefinierten Konstruktoren sind dafür da, dass Sie von außen sinnvolle Startwerte übergeben können. Der Kopierkonstruktor spielt eine Besondere Rolle. Für kleinere Sachen benötigt man ihn meistens nicht, aber spätestens, wenn man Operatoren überladen will, ist er notwendig. Wie der Name schon sagt, ist er dafür da, sich anhand eines anderen Objektes zu erzeugen.

Bis zur Zeile 51 sollte jetzt alles klar sein, aber ab dieser Zeile möchte ich Ihnen zeigen, wie Klassen auf ihre eigenen Attribute zugreifen können (das Gleiche gilt dann auch für die Methoden). Wie Sie sehen, gibt es zwei verschiedene Varianten. Variante 1 spart Code, aber Variante 2 ist eindeutiger und in anderen Sprachen sogar Vorschrift. Hier sehen Sie das erste mal den s.g. "this" Pointer, welcher eine Referenz auf die Klasse selbst darstellt. Prinzipiell kann man sich dies in C++ sparen, weil man an dem "m_" bereits erkennt, dass es sich um ein Attribut und keine lokale Variable handelt und somit das "this" doppelt gemoppelt wäre. Aber wie gesagt, in anderen Sprache ist dies sogar Pflicht und gerade für Anfänger ist es ratsam, das "this" immer mit hinzuschreiben (es sticht mehr ins Auge).

Zum Seitenanfang
Zum Inhaltsverzeichnis

© Copyright by Thomas Weiß, 2009 - 2012