Teil VIII Programmierung mit C++ (4)

Teil VIII
Programmierung mit C++ (4)
Objektorientierung
Überblick
1
Einführung Objektorientierung
2
Objekte und Klassen in C++
3
Vererbung in C++
4
Strukturen in C und C++
Eike Schallehn, FIN/ITI
Grundlagen der Informatik für Ingenieure
381/715
Einführung Objektorientierung
Definition (Objektorientierung)
Objektorientierung ist ein Ansatz aus der
Softwareentwicklung, der die Zusammenfassung von Daten
und den dazugehörigen Funktionen in Klassen von
Realweltobjekten unterstützt.
Grundlegender Gedanke: weiteres Mittel zu Strukturierung
des Programmtextes für komplexe Anwendungen
Bisher: Funktionen fassen zusammenhängende
Befehlsfolgen für Lösung eines Teilproblems zusammen
Jetzt: Strukturierung der Daten (Variablen etc.) und der
dazugehörigen Funktionen
Eike Schallehn, FIN/ITI
Grundlagen der Informatik für Ingenieure
382/715
Ziele der Objektorientierung
Wiederverwendbarkeit → verminderter
Programmieraufwand
Nutzung vordefinierter Klassen aus Bibliotheken
Definition eigener Klassen zur Verwendung in vielen
Programmteilen
Spezialisierung von Klassen: Erweiterung vordefinierter
Klassen um neue Attribute und Funktionen
Bessere Verständlichkeit und Wartbarkeit des Codes
Eike Schallehn, FIN/ITI
Grundlagen der Informatik für Ingenieure
383/715
OO Grundkonzepte: Klassen und Instanzen
Klassen fassen Objekte mit gleichen Eigenschaften
(Attributen) und gleichen auf sie anwendbaren
Funktionen (Methoden) zusammen
Gesamtheit von Attributen und Methoden entspricht dem
Typ → Klassen beinhalten somit eine
anwendungsspezifische und vom Programmierer
entwickelte Typdefinition
Objekte werden auch als Instanzen (Ausprägung, Einheit)
der Klasse gespeichert
Entstehen durch Erzeugung von Objekten des Klassentyps
→ Instantiierung
Tragen die Werte für die in der Klasse definierten Attribute
Grundlage für Aufruf der in der Klasse definierten
Methoden
Eike Schallehn, FIN/ITI
Grundlagen der Informatik für Ingenieure
384/715
OO Grundkonzepte: Instanzen und Klassen
Instanzen der Klasse Mitarbeiter
Schmidt
Claudia
70000
Finanzen
Klasse Mitarbeiter
Eigenschaften
Name
Vorname
Gehalt
Abteilung
Schulz
Peter
50000
Entwicklung
Funktionen
Einstellen
Gehalt Erhöhen
Abteilung Wechseln
Entlassen
Eike Schallehn, FIN/ITI
Meier
Gustav
80000
Marketing
Grundlagen der Informatik für Ingenieure
385/715
OO Grundkonzepte: Kapselung
Kapselung als Programmierkonzept unterscheidet die
nach außen sichtbaren Attribute und Methoden
(Schnittstelle der Klasse) von internen Eigenschaften und
Methoden, die vor dem Nutzer der Klasse verborgen
bleiben sollen (Implementierung der Klasse)
Beispiel: Dateizugriff über fstream-Klassen
Öffentlich zugänglich: Dateiname, Zugriffsmodus sowie
Methoden zum Öffnen, Schließen, Lesen, Schreiben etc.
Gekapselt: Methoden und Daten zum Zugriff auf
Dateipuffer etc.
Eike Schallehn, FIN/ITI
Grundlagen der Informatik für Ingenieure
386/715
OO Grundkonzepte: Vererbung
Vererbung oder auch (allgemeiner) Spezialisierung ist
eine Beziehung zwischen Klassen und Typen, welche
dadurch in einer Vererbungshierarchie stehen
Ist eine Klasse eine Unterklasse einer Oberklasse, dann
„Erbt“ sie die Attribute und Methoden der Oberklasse, d.h.
diese sind ohne weiteren Programmieraufwand auch hier
definiert
Kann jedes Objekt der Unterklasse auch als Objekt der
Oberklasse behandelt werden (→ Polymorphie)
Beispiel: Objekte der Unterklasse Studenten und der
Oberklasse Personen
Jeder Student ist eine Person
Jeder Student hat auch die Eigenschaften und Methoden
einer Person im Allgemeinen
Alles, was eine Person machen kann, kann auch ein
Student machen
Eike Schallehn, FIN/ITI
Grundlagen der Informatik für Ingenieure
387/715
OO Grundkonzepte: Wiederverwendbarkeit
Objektorientierung verringert bei geeignetem Einsatz den
Entwicklungsaufwand durch Wiederverwendung
Wiederverwendbarkeit durch
Verwendung von Klassen als nutzerdefinierte
Datentypen, die überall im Programm durch die
Instantiierung von Objektvariablen verwendet werden
können
Ableitung eigener Klassen durch Spezialisierung von
vorher implementierten Klassen oder Klassen einer
vordefinierten Klassenbibliothek → Erweiterung um im
neuen Anwendungskontext notwendige zusätliche Attribute
oder Methoden
Eike Schallehn, FIN/ITI
Grundlagen der Informatik für Ingenieure
388/715
Anwendung der Objektorientierung
Anwendung in vielen Bereichen der Informatik
Objektorientierter Entwurf von Software mit Hilfe formaler
Modelle oder grafischer Notationen (zum Beispiel UML)
Zahlreiche objektorientierte Programmiersprachen
Objektorientierte Datenbanken
Objektorientierte Nutzerschnittstellen
...
Im Folgenden: Objektorientierung in der
Programmiersprache C++
Eike Schallehn, FIN/ITI
Grundlagen der Informatik für Ingenieure
389/715
Objekte und Klassen in C++
Arbeiten mit Objektorientierung in C++ erfordert
Definition von Klassen
Implementierung von Konstruktoren zum Erzeugen von
Objekten der Klasse
Ggf. Implementierung von Destruktoren zum „Bereinigen“
der Daten von Objekten, die beim expliziten oder impliziten
Löschen der Objekte aufgerufen werden
Implementierung der Klassenmethoden
Ggf. Implementierung von klassenspezifischen Operatoren
Instantiierung der Klassen, d.h. Erzeugung von Objekten,
durch Aufruf von Konstruktoren
Als lokale Objektvariablen, z.B. auf dem Programm-Stack
Als Objektvariablen auf dem Heap über new
Arbeit mit Objekten durch Zugriff auf deren Attribute und
Methoden
Umsetzung der Vererbung zwischen Klassen
Eike Schallehn, FIN/ITI
Grundlagen der Informatik für Ingenieure
390/715
Objekte und Klassen in C++
Definition von Klassen durch Schlüsselwort class - im
einfachsten Fall:
class Klassenname { ... };
Bestandteil der Klasse können sein:
Attributdeklarationen: Klassenvariablen vergleichbar
Komponentenvariablen bei Strukturen
Konstruktoren und Destruktoren
Methodendeklarationen/-definitionen (Klassenfunktionen)
Operatordeklarationen/-definition
Zusätzlich: Kapselung durch Angabe ob Bestandteile
public: überall,
private: (Default, bei fehlender Angabe) nur in dieser
Klasse oder
protected: auch in abgeleiteten Klassen
sichtbar sind, d.h. im Code darauf zugegriffen werden kann
Eike Schallehn, FIN/ITI
Grundlagen der Informatik für Ingenieure
391/715
Kapselung in C++
class Klassenname {
private:
// Alle nur in dieser Klasse sichtbaren Attribute,
// Konstruktoren, Methoden, Operatoren kommen
// hier hin.
public:
// Alle überall sichtbaren Attribute,
// Konstruktoren, Methoden, Operatoren.
// Destruktoren müssen hier stehen.
protected:
// Alle in dieser und abgeleiteten Klassen sichtbaren
// Attribute, Konstruktoren, Methoden, Operatoren.
};
Eike Schallehn, FIN/ITI
Grundlagen der Informatik für Ingenieure
392/715
Beispiel: Vektor-Klasse
Im Folgenden durchgehend verwendetes Beispiel: Klasse
zur Arbeit mit mathematischen Vektoren beliebiger
Dimensionalität
Attribute:
Dimensionalität des Vektor
Array zur Speicherung der Komponenten
Methoden:
Norm (Betrag, Länge) des Vektors
Ausgabe des Vektors als virtuelle Funktion (kann in
abgeleiteten Klassen überschrieben werden → Vererbung)
Operatoren:
Addition zweier Vektoren mit +
Multiplikation mit einem skalaren Wert mit *
Außerdem zwei Konstruktoren und ein Destruktor
Eike Schallehn, FIN/ITI
Grundlagen der Informatik für Ingenieure
393/715
Beispiel: Klassendeklaration
class Vektor {
protected:
int
dimensionen;
float*
komponenten;
public :
Vektor(const Vektor& v);
Vektor(int d, float k[]);
∼Vektor();
virtual void ausgabe();
float norm();
Vektor operator +(Vektor v);
Vektor operator *(float skalar);
};
Eike Schallehn, FIN/ITI
Grundlagen der Informatik für Ingenieure
394/715
Anmerkung: Virtuelle Funktionen
Virtuelle Funktionen (korrekter eigentlich: Virtuelle
Methoden) erlauben ein späteres Überschreiben der
Implementierung in abgeleiteten Klassen (→ Vererbung)
Eike Schallehn, FIN/ITI
Grundlagen der Informatik für Ingenieure
395/715
Implementierung von Methoden in C++
Zwei Alternativen für Implementierung von Methoden,
Operatoren, Konstruktoren und Destruktoren
Direkt innerhalb der Klassendefinition
float norm() {
float sum=0;
for (int i=0; i<dimensionen; i++)
sum+=komponenten[i] * komponenten[i];
return sqrt(sum);
};
Außerhalb der Klassendefinition (empfohlen wegen
Übersichtlichkeit) durch Angabe des Klassennamens als
Scope
float Vektor::norm() {
float sum=0;
for (int i=0; i<dimensionen; i++)
sum+=komponenten[i] * komponenten[i];
return sqrt(sum);
}
Eike Schallehn, FIN/ITI
Grundlagen der Informatik für Ingenieure
396/715
Konstruktoren in C++
Konstruktoren sind spezielle Methoden, die beim
Erzeugen von Objekten aufgerufen werden
Name der Methode entspricht Name der Klasse
Haben in der Signatur keinen Rückgabewert
Parameter können zur Initialisierung der Attribute
verwendet werden
Verschiedene Konstruktoren mit unterschiedlichen
Parametern möglich
Zwei spezielle Arten von Konstruktoren werden
automatisch generiert, können aber vom Entwickler
überschrieben werden
Default-Konstruktor ohne Parameter, wenn nicht
überschrieben zufällige Werte bzw. Aufruf
Default-Konstruktoren der eingebetteten Objekte
Copy-Konstruktor erzeugt eine Kopie eines existierenden
Objektes diesen Typs
Eike Schallehn, FIN/ITI
Grundlagen der Informatik für Ingenieure
397/715
Beispiel: Konstruktoren
Vektor::Vektor(int d, float k[]) {
dimensionen = d;
komponenten = new float[d]();
for (int i=0; i<d; i++)
komponenten[i] = k[i];
}
Vektor::Vektor(const Vektor& v) {
dimensionen = v.dimensionen;
komponenten = new float[dimensionen]();
for (int i=0; i<dimensionen; i++)
komponenten[i] = v.komponenten[i];
}
Eike Schallehn, FIN/ITI
Grundlagen der Informatik für Ingenieure
398/715
Copy-Konstruktoren in C++
Falls nicht angegeben, existiert immer vordefinierter
Copy-Konstruktor, der einfach alle Daten (inklusive Zeiger)
eines Objektes direkt übernimmt
Copy-Konstruktor wird an zahlreichen Stellen automatisch
und für den Nutzer nicht sichtbar aufgerufen
Beim Aufruf von Funktionen mit Objekt als Pass By Value
Bei der Rückgabe eines Objektes als Ergebnis einer
Funktion
Bei der direkten Zuweisung einer Objektvariablen mit =
Überschreiben des Copy-Konstruktors oft sinnvoll
Wenn im Objekt Zeiger auf weitere Daten existieren, damit
diese Daten, und nicht nur der Zeiger kopiert werden
Signatur ist festgelegt
Klassenname(const Klassenname& o) { ... };
Eike Schallehn, FIN/ITI
Grundlagen der Informatik für Ingenieure
399/715
Instantiierung von Objekten
Erzeugung von Objekten auf dem Stack
Vektor v1(3,daten);
Vektor v2; // Aufruf des Default-Konstruktors
Vektor v3 = v1; // Aufruf des Copy-Konstruktors
→ werden beim Verlassen des aktuellen Scopes
automatisch gelöscht (inklusive Aufruf des Destruktors)
Erzeugung von Objekten auf dem Heap
Vektor* v4 = new Vektor(3,daten);
Vektor* v5 = new Vektor(); // Default-Konstruktor
Vektor* v6 = new Vektor(*v4); // Copy-Konstruktor
→ müssen, wenn nicht mehr benötigt, explizit durch
delete gelöscht werden, z.B.
delete v4;
(ruft ebenfalls automatisch Destruktor auf)
Eike Schallehn, FIN/ITI
Grundlagen der Informatik für Ingenieure
400/715
Destruktoren in C++
Spezielle Methode, die automatisch beim Löschen des
Objektes aufgerufen wird
Beim expliziten Löschen von Objekten auf dem Heap durch
delete
Für Objekte auf dem Stack veim Verlassen der aktuellen
Funktion
Deklaration immer als Methode der Form
∼Klassenname();
ohne Parameter
Automatisch generierter Default-Konstruktor löscht nur
Speicher des Objektes selber
Überschreiben sinnvoll, um weiteren, indirekt vom Objekt
genutzten und durch Zeiger referenzierten Speicher
freizugeben, bzw. um sonstige „Aufräumarbeiten zur
erledigen (z.B. Schließen oder Löschen von Dateien,
Schließen von Fenstern, etc.)
Eike Schallehn, FIN/ITI
Grundlagen der Informatik für Ingenieure
401/715
Beispiel: Destruktoren
Vektor::∼Vektor() {
delete[] komponenten;
}
Löscht mit Vektor assoziiertes Array auf dem Heap → bliebe
sonst als nicht mehr nutzbarer Speicherbereich (Memory Leak)
belegt
Eike Schallehn, FIN/ITI
Grundlagen der Informatik für Ingenieure
402/715
Überladen von Operatoren in C++
C++ erlaubt für Klassen die Definition neuer Operatoren
sowie das Überschreiben zahlreicher existierender
Operatoren, d.h. die Zuweisung einer neuen Bedeutung
dieser Operatoren durch eine anzugebende
Implementierung
Überschreiben zum Beispiel für arithmetische Operatoren
(+, -, *, /, ++, etc.), Zuweisungsoperatoren (=, += etc.),
Vergleichsoperatoren (==, >, <, etc.) und andere
Deklaration in der Klasse mit operator und
entsprechende Implementierung
Im Beispiel der Klasse Vektor
Vektoraddition + durch komponentenweise Addition
Skalarmultiplikation * mit einem float-Wert
Eike Schallehn, FIN/ITI
Grundlagen der Informatik für Ingenieure
403/715
Beispiel: Überladen von Operatoren
In der Klassendeklaration:
Vektor operator +(Vektor v);
Implementierung
Vektor Vektor::operator+ (Vektor v) {
Vektor result(this->dimensionen, this->komponenten);
for (int i=0; i<dimensionen; i++)
result.komponenten[i] += v.komponenten[i];
return result;
}
Anwendung, z.B.
Vektor v2 = v1 + v1;
Eike Schallehn, FIN/ITI
Grundlagen der Informatik für Ingenieure
404/715
Der Zeiger this
Vordefinierte Konstante in jeder C++-Klasse
Der this-Zeiger verweist für jede aufgerufene Methode
auf das Objekt (Adresse des Objektes), für das die
Methode aufgerufen wurde
Zum Beispiel notwendig ...
zur Vermeidung von Namenskonflikten, wenn Parameter
dieselben Namen wie Attribute der Klasse haben oder
das Objekt selber als Rückgabewert der Methode
zurückgeliefert werden soll
Eike Schallehn, FIN/ITI
Grundlagen der Informatik für Ingenieure
405/715
Beispiel: main-Funktion
...
int main() {
float daten[]={1,2,3};
Vektor v1(3,daten);
cout << ”Die Laenge des Vektors v1 ”;
v1.ausgabe();
cout << ” ist ” << v1.norm() << ” und v1 + v1 ist ” ;
Vektor v2 = v1 + v1;
v2.ausgabe();
cout << endl;
return 0;
}
Eike Schallehn, FIN/ITI
Grundlagen der Informatik für Ingenieure
406/715
Zerlegung des Quelltextes in C++
Konvention für komplexere Programme mit vielen Klassen:
Jede Klassendeklaration in eine eigene Header-Datei
(klassenname.h)
Implementierung von Methoden, Konstruktore etc. dieser
Klasse ebenfalls in eine eigene Quelldatei
(klassenname.cpp)
Hauptprogramm ebenfalls in separate Quelldatei (.cpp)
Vorteile:
Können vom Compiler separat und auch nur wenn
notwendig, d.h. wenn genau diese Klasse verändert wurde,
übersetzt werden
Linker verbindet am Ende einzelne Module mit
Hauptprogramm
Überall wo eine Klasse genutzt wird, muss nur deren
Header-Datei inkludiert werden
Kürzere und übersichtlichere Dateien
Eike Schallehn, FIN/ITI
Grundlagen der Informatik für Ingenieure
407/715
Beispiel: Zerlegung des Quelltextes in C++
// File vektor.h
#ifndef VEKTOR_H
#define VEKTOR_H 1
class Vektor {
...
};
#endif
Verwendung der Präprozessoranweisungen verhindert
mehrfaches indirektes Einbetten derselben Deklaration durch
den Präprozessor
Eike Schallehn, FIN/ITI
Grundlagen der Informatik für Ingenieure
408/715
Vererbung in C++
C++ erlaubt Klassenhierarchien durch Spezialisierung
Wichtigste Effekte:
Vererbung (Inheritance): alle Attribute und Methoden der
Oberklasse werden übernommen
Spezialisierung: in der Unterklasse müssen nur
zusätzliche, „speziellere“ Attribute und Methoden neu
definiert werden
Polymorphie: überall, wo ein Objekt der Oberklasse
verwendet werden kann, kann auch ein Objekt der
Unterklasse verwendet werden - uneingeschränkt nur bei
Public Inheritance (s.u.)
Überschreiben von Methoden (Overriding): in der
Unterklasse kann eine speziellere Implementierung für eine
Bereits in der Oberklasse implementierte Methode
angegeben werden
Eike Schallehn, FIN/ITI
Grundlagen der Informatik für Ingenieure
409/715
Vererbung in C++ /2
class Unterklasse : [public|private|proted] Oberklasse {...};
Typ der Vererbung (public,private,proted) bestimmt,
mit welcher Kapselung die public- und
protected-Attribute und -Methoden der Oberklasse
übernommen werden
→ meistens Public Inheritance sinnvoll
→ Default-Verhalten, d.h. wenn nicht angegeben, ist aber
private!
Auch Mehrfachvererbung durch kommaseparierte Liste
von Oberklassen mit separatem Vererbungstyp möglich
Eike Schallehn, FIN/ITI
Grundlagen der Informatik für Ingenieure
410/715
Vererbung am Beispiel
Einfaches Anwendungsszenario: für eine Firma sollen in
einer Anwendung verschiedene Bauteile verwendet
werden
BauTeil: ist eine allgemeine Klasse von zu verwendenden
Teilen, wobei jedes Bauteil eine Bezeichnung und eine
Masse als Attribute hat. Neben einem Konstruktor zur
Erzeugung von Bauteil-Objekten wird eine
toString()-Methode für die Ausgabe benötigt.
KaufTeil: ist eine spezielle Unterklasse Von Bauteilen, die
von Zulieferern zu einem bestimmten Preis eingekauft
werden.
FertigungsTeil: ist eine spezielle Unterklasse Von
Bauteilen, die innerhalb der Firma gefertigt werden und für
die die Durchlaufzeit von Interesse ist.
Eike Schallehn, FIN/ITI
Grundlagen der Informatik für Ingenieure
411/715
Klassendefinition: Basisklasse Bauteil
class BauTeil
{
private :
string bezeichnung;
float masse;
public :
BauTeil(string b, float m);
virtual string toString();
};
Eike Schallehn, FIN/ITI
Grundlagen der Informatik für Ingenieure
412/715
Klassendefinition: Unterklasse Kaufteil
class KaufTeil : public BauTeil
{
private :
string zulieferer;
float preis;
public :
KaufTeil(string b, float m, string z, float p);
virtual string toString();
};
Eike Schallehn, FIN/ITI
Grundlagen der Informatik für Ingenieure
413/715
Klassendefinition: Unterklasse Fertigungsteil
class FertigungsTeil : public BauTeil
{
private :
int durchlaufzeit;
public :
FertigungsTeil(string b, float m, int d);
virtual string toString();
};
Eike Schallehn, FIN/ITI
Grundlagen der Informatik für Ingenieure
414/715
Konstruktor der Oberklasse Bauteil
BauTeil::BauTeil(string b, float m)
{
bezeichnung = b;
masse = m;
}
Eike Schallehn, FIN/ITI
Grundlagen der Informatik für Ingenieure
415/715
Konstruktor der Unterklasse Kaufteil
KaufTeil::KaufTeil(string b, float m, string z, float p) :
BauTeil(b,m)
{
zulieferer = z;
preis = p;
}
Eike Schallehn, FIN/ITI
Grundlagen der Informatik für Ingenieure
416/715
Überschreiben der Methode toString()
Die Methodendefinition
string BauTeil::toString()
{
stringstream stst;
stst << ”Teil : ” << bezeichnung << ”, ” << masse;
return stst.str();
}
aus der Oberklasse wird überschrieben durch
string FertigungsTeil::toString()
{
stringstream stst;
stst << ”Fertigungs” << BauTeil::toString()
<< ”, ” << durchlaufzeit;
return stst.str();
}
Eike Schallehn, FIN/ITI
Grundlagen der Informatik für Ingenieure
417/715
Erklärungen zum Beispiel
Bei Konstruktoren können durch den Syntax
Klassenname::Klassenname(...) : Konstruktor(...) { ... }
explizit Konstruktoren der Oberklasse(n) oder anderer
eingebetteter Komponenten aufgerufen werden (bei mehreren
kommasepariert)
Entsprechend erzeugt der Konstruktor durch
KaufTeil::KaufTeil(string b, float m, string z, float p) :
BauTeil(b,m)
das Kaufteil erst als „normales“ Bauteil und setzt dann die Werte
beiden Kaufteil-Attribute
Die Methode toString() überschreibt die Methode aus der
Oberklasse BauTeil welche dort als virtual definiert wurde,
um die zusätzlichen eigenschaften auszugeben, verwendet aber
auch Implementierung aus der Oberklasse explizit durch die
Angabe der Herkunft der Methode bei dem Aufruf
Eike Schallehn, FIN/ITI
Grundlagen der Informatik für Ingenieure
418/715
Virtuelle Funktionen in C++
Definition einer Funktion als virtual erlaubt Angabe
einer anderen Implementierung in einer abgeleiteten
Klasse
Wird auch als Overriding (Überschreiben) bezeichnet
Durch Late Binding (spätes bzw. dynamisches Binden,
wird die „passende“ Implementierung zur Laufzeit gewählt
Statisches Binden: korrekte Implementierung einer
(nicht-virtuellen) Funktion wird vom Compiler in
Abhängigkeit vom Typ der Objekt- oder
Zeigervariable ausgewählt
Dynamisches Binden: korrekte Implementierung einer
virtuellen Funktion wird zur Laufzeit ausgewählt,
d.h. es wird getestet ob das Objekt unabhängig
vom Variablentyp selber von einem noch
spezielleren Typ ist (möglich wegen Polymorphie)
Eike Schallehn, FIN/ITI
Grundlagen der Informatik für Ingenieure
419/715
Beispiel: Hauptprogramm
Drei mal Aufruf der Methode toString() für Objekte
verschiedenen Typs:
int main()
{
BauTeil* b[3];
b[0] = new KaufTeil(”Getriebe”,122.5,
”Laios und Sohn”,99.99);
b[1] = new FertigungsTeil(”Motor”,407.00,4);
b[2] = new KaufTeil(”Vergaser”,72.00,
”Daidalos und Sohn”,49.99);
for (int i=0 ; i < 3 ; i++)
cout << b[i]->toString() << endl;
return 0;
}
KaufTeil : Getriebe, 122.5, Laios und Sohn, 99.99
FertigungsTeil : Motor, 407, 4
KaufTeil : Vergaser, 72, Daidalos und Sohn, 49.99
Eike Schallehn, FIN/ITI
Grundlagen der Informatik für Ingenieure
420/715
Strukturen in C und C++
Strukturen in C Vorstufe der Objektorientierung: fassen
vergleichbar mit Klassen von Objekten Daten zusammen
Strukturen dienen in C lediglich der Zusammenfassung
inhaltlich zusammengehöriger Variablen (keine Vererbung,
Kapselung, Methoden, etc.)
Erweiterung in C++: können dort ähnlich wie Klassen
verwendet werden und bieten zusätzliche Funktionalität
Eike Schallehn, FIN/ITI
Grundlagen der Informatik für Ingenieure
421/715
Strukturen in C: Deklaration und Initialisierung
Einfachste Form der Deklaration inklusive einer
Benennung des Strukturtyps (für spätere
Wiederverwendung) und der sofortigen Deklaration von
Variablen dieses Typs
struct typ_name {
datentyp variable1;
datentyp variable2;
...
} struct_variable1, ... ;
Initialisierung ähnlich Arrays über Werteliste
(verschiedenen Typs) möglich
struct typ_name struct_variable = {...};
zum Beispiel
struct studenten_typ s = {”Meier”,”Karl”,”123456”,25};
Eike Schallehn, FIN/ITI
Grundlagen der Informatik für Ingenieure
422/715
Strukturen und C++
Strukturen wie oben dargestellt auch in C++ verwendbar
Implizieren immer Typdefinition
Verwendbarkeit in C++ erweitert: haben vergleichbare
Möglichkeiten wie Klassen, d.h.
Vererbung (→)
Kapselung (→)
Methoden (→)
Unterschied zu Klassen: Default-Zugriff für Attribute und
Methoden sowie Vererbung ist public
Häufig jedoch „elegantere“ Lösung durch Verwendung
objektorientierter Konzepte wie Klassen möglich
Eike Schallehn, FIN/ITI
Grundlagen der Informatik für Ingenieure
423/715
Zusammenfassung: Objektorientierung in C++
Grundkonzepte der Objektorientierung
Klassen von Objekten mit gleichen Eigenschaften
Methoden als Beschreibung der Funktionalität, welche zu
diesen Objekten gehört
Vererbung als Mittel zur Wiederverwendung von Code
Erlaubt Entwicklung sehr gut strukturierter und damit leicht
zu entwickelnder und zu pflegender Programme
Konzepte sind in der Anwendung aber recht komplex →
erfordert „objektorientierte Denkweise“
Objektorientierung erfolgreiches Konzept, das sich in
vielen Programmiersprachen aber auch in anderen
Gebieten durchsetzt
Eike Schallehn, FIN/ITI
Grundlagen der Informatik für Ingenieure
424/715
Zusammenfassung C und C++
C und C++ ...
sind weit verbreitet eingesetzte Programmiersprachen in
allen denkbaren Anwendungsbereichen
stellen eine Hauptlinie bei der Entwicklung von
Programmiersprachen dar, d.h. viele andere
Programmiersprachen sind davon abgeleitet
sind sehr umfangreiche Programmiersprachen mit
zahlreichen umgesetzten, anspruchsvollen Konzepten
C und C++ sind keine „einfachen“ Programmiersprachen
ABER: „wer C++ programmieren kann, kann auch (fast)
alles andere programmieren“
Eike Schallehn, FIN/ITI
Grundlagen der Informatik für Ingenieure
425/715
Zusammenfassung C und C++ /2
In der Vorlesung: wichtigste Kernkonzepte vorgestellt
C und C++ umfassen noch wesentlich mehr Konzepte:
Bitmanipulaionsoperatoren - Union-Typkonstruktor - Typqualifikatoren:
const und volatile - Zeiger auf Funktionen - Präprozessor pragmas bedingte Kompilierung - Unicode in C/C++ - virtuelle Vererbung zahlreiche Standardbibliotheken - Typumwandlung durch Casting Reflexion und Laufzeittypinformationen - Entwicklungsumgebungen Debugging - Entwicklungstools - Programmstacks - Templates für
Klassen und Funktionen - Statische Methoden - virtuelle Destruktoren Namensräume - friend-Klassen - Entwicklung von Nutzerschnittstellen
(GUIs) - Arbeit mit Hardwareschnittstellen - Arbeit mit Netzwerken Multithreadding - Coding Conventions -
Eike Schallehn, FIN/ITI
...
Grundlagen der Informatik für Ingenieure
426/715