Verwendung von Klassen in C++

Verwendung von Klassen in C++
•
•
Heute: Benutzerdefinierte Datentypen (Konkrete Klassen)
– Vektoren
– Komplexe Zahlen
– Adressdatei
Morgen: Objektorientierte Programmierung (Abstrakte Klassen)
– Vererbung
– Polymorphie
– Klassen-Hierarchien
Strukturen
In Strukturen können Daten (Elementvariablen) unterschiedlichen Typs
verwendet werden.
Beispiel:
// Definition der Struktur “Adresse”
struct Adresse {
string Vorname;
string Nachname;
int Telefonnummer;
};
…
Adresse
Strukturen
int main ()
{
Adresse A;
A.Vorname = “Issac”;
A.Nachname = “Newton”;
A.Telefonnummer = 12345;
…
// Definition einer Variablen vom Typ Adresse
cout << "Vorname: " << A.Vorname << endl;
cout << "Nachname: " << A.Nachname << endl;
cout << "Telefonnummer: " << A.Telefonnummer << endl << endl;
}
Adresse
Überschreiben von Funktionen
#include <iostream>
#include <conio.h>
double Summe (double a, double b) {return a+b;}
int Summe (int a, int b) {return a+b;}
int Summe (int a, int b, int c) {return a+b+c;}
void main () {
cout << Summe (1.0, 3.2) << endl;
cout << Summe (1,2) << endl;
cout << Summe (1,2,3) << endl;
getch();
}
Ueberschreib
Strukturen
Beispiel: 3-dimensionale Vektoren
struct Vektor {
// Deklaration der Struktur „Vektor“
double x, y, z;
// Elementvariablen
};
…
int main () {
Vektor a, b, c;
// Definition der Vektoren a, b und c
a.x = 0.0; a.y = 1.0; a.z = 2.0;
// Wertzuweisung an die Elementvariablen von a
b.x = 4.0; b.y = 5.0; b.z = 6.0;
// Wertzuweisung an die Elementvariablen von b
c.x = a.x + b.x;
c.y = a.y + b.y;
c.z = a.z + b.z;
// Wertzuweisung an die Elementvariablen von c
// Vektorsumme c = a + b
cout << c.x << ´\t´ << c.y << ´\t´ << c.z;
// Ausgabe von c
}
Vektor_als_Struktur
Strukturen: Elementfunktionen
Neben Elementvariablen können in Strukturen auch
Elementfunktionen definiert werden
struct Vektor {
double x, y, z;
double Betrag ();
};
double Vektor::Betrag ()
{
return sqrt (x*x+y*y+z*z);
}
int main () {
Vektor a;
a.x = 0.0; a.y = 1.0; a.z = 2.0;
// Elementvariablen x, y und z
// Deklaration der Elementfunktion Betrag
// Definition der Elementfunktion Betrag,
// die zur Struktur Vektor gehört
cout << a.Betrag();
}
Elementfunktion
Strukturen: Konstruktor
Beispiel: 3-dimensionale Vektoren
struct Vektor {
double x, y, z;
Vektor ();
Vektor (double, double, double);
// Deklaration der Struktur Vektor
// Elementvariablen x, y und z
// Deklaration des Default-Konstruktors
// (Ohne Parameter oder mit Default-Parametern)
// Deklaration eines Konstruktors mit 3 Parametern
};
Vektor::Vektor () {x=0.0; y=0.0; z=0.0;}
Vektor::Vektor (double a, double b, double c)
{x = a; y = b; z = c;}
int main () {
Vektor a (0.0, 1.0, 2.0);
Vektor b;
}
// Definition des Default-Konstruktors
// Definition von Konstruktor 2
// Konstruktor 2 wird verwendet
// Default-Konstruktor wird verwendet
Konstruktor
Zugriffskontrolle
Die Zugriffskontrolle erfolgt durch die Schlüsselwörter public, private und
protected
struct Vektor {
public:
double Betrag ();
…
private:
double x, y, z;
};
double Vektor::Betrag ()
{
return sqrt (x*x+y*y+z*z);
}
int main () {
Vektor a(1.0, 0.0, 1.0);
cout << a.Betrag();
}
// Deklaration der Elementfunktion Betrag
// Definition der Konstruktoren
// Elementvariablen x, y und z
// Definition der Elementfunktion Betrag,
// die zur Struktur Vektor gehört
Zugriffskontrolle
Rechenoperationen mit
Elementfunktionen
class Vektor {
public:
double x, y, z;
…
Vektor Summe (Vektor);
};
…
Vektor Vektor::Summe (Vektor v)
{return Vektor (x+v.x, y+v.y, z+v.z);}
// Deklaration der Struktur Vektor
// Elementvariablen x, y und z
// Deklaration der Konstruktoren
// Elementfunktion Summe
// Definition der Konstruktoren
// Definition der Elementfunktion Summe,
// die zur Klasse Vektor gehört
int main () {
Vektor a (0.0, 1.0, 2.0);
Vektor b (4.0, 5.0, 6.0);
Vektor c;
c = a.Summe (b);
cout << c.x << ´\t´ << c.y << ´\t´ << c.z;
// c = a + b
// Ausgabe des Ergenbnis
}
Rechenoperationen
Operatoren
Überschreiben von Operatoren: Der + Operator als Elementfunktion
class Vektor {
public:
double x, y, z;
…
Vektor operator + (Vektor);
};
…
Vektor Vektor::operator + (Vektor v)
{return Vektor (x+v.x, y+v.y, z+v.z);}
// Deklaration der Klasse Vektor
// Elementvariablen x, y und z
// Deklaration der Konstruktoren
// Deklaration des + Operators
// Definition der Konstruktoren
// Definition des + Operators,
// die zur Klasse Vektor gehört
int main () {
Vektor a (0.0, 1.0, 2.0);
Vektor b (4.0, 5.0, 6.0);
Vektor c;
c = a + b;
cout << c.x << ´\t´ << c.y << ´\t´ << c.z;
// c = a + b
// Ausgabe des Ergenbnis
}
PlusOperator
Übersicht: Wichtige Operatoren
+
-
Operatoren können als
• Elementfunktion
oder
• als globale Funktion
definiert werden
*
/
=
<<
>>
Globale Definition von Operatoren
class Vektor {
public:
double x, y, z;
…
// Deklaration der Klasse Vektor
// Elementvariablen x, y und z
// Deklaration der Konstruktoren
};
…
Vektor operator + (Vektor v, Vektor w)
{return Vektor (v.x+w.x, v.y+w.y, v.z+w.z);}
int main () {
Vektor a (0.0, 1.0, 2.0);
Vektor b (4.0, 5.0, 6.0);
Vektor c;
c = a + b;
cout << c.x << ´\t´ << c.y << ´\t´ << c.z;
// Definition der Konstruktoren
// Globale Definition des + Operators
// c = a + b
// Ausgabe des Ergenbnis
}
GlobaleOperatoren
Operatoren
Überschreiben von Operatoren: Der << Operator für die Ausgabe
class Vektor {
// Deklaration der Klasse Vektor
public:
double x, y, z;
// Elementvariablen x, y und z
…
// Deklaration der Konstruktoren
};
…
// Definition der Konstruktoren
ostream& operator << (ostream& f, Vektor v)
// Globale Definition des << Operators
{
f << “(“ << v.x << “ , “ << v.y << “ , “ << v.z << “) “;
return f;
}
int main () {
Vektor a (0.0, 1.0, 2.0);
cout << a;
// Ausgabe von c→ (0.0 , 1.0 , 2.0)
}
AusgabeOperator
Der Zuweisungsoperator =
class Vektor {
// Deklaration der Klasse Vektor
public:
double x, y, z;
// Elementvariablen x, y und z
…
// Deklaration der Konstruktoren
Vektor& operator = (&Vektor);
// Deklaration des = Operators
};
…
// Definition der Konstruktoren
Vektor& Vektor::operator = (&Vektor v) // Definition des = Operators,
{
x=v.x; y=v.y; z=v.z;
// Kopieren der Elementvariablen
return *this;
// die zur Klasse Vektor gehört
}
int main () {
Vektor a (0.0, 1.0, 2.0);
Vektor b (4.0, 5.0, 6.0);
Vektor c;
c = a + b;
// c = a + b
cout << c.x << ´\t´ << c.y << ´\t´ << c.z;
// Ausgabe des Ergenbnis
}
ZuweisungsOperator
Copy -Konstruktor
Beispiel: 3-dimensionale Vektoren
class Vektor {
public:
double x, y, z;
Vektor (&Vektor);
…
};
Vektor::Vektor (&Vektor v)
{
x = v.x; y = v.y; z = v.z;
}
int main () {
Vektor a (0.0, 1.0, 2.0);
Vektor b = a;
}
// Deklaration der Klasse Vektor
// Elementvariablen x, y und z
// Deklaration des Copy-Konstruktors
// Weitere Konstruktoren
// Definition des Copy-Konstruktors
// Zuweisung
// Konstruktor für (double,double,double) wird verwendet
// Copy-Konstruktor wird verwendet
CopyConstructor