C++ - Strukturen - ADT - Klassen - Objekte · PDF fileFB Informatik Prof. Dr. R.Nitsch C++ - Strukturen - ADT - Klassen - Objekte Reiner Nitsch 8471 [email protected]

FB InformatikProf. Dr. R.Nitsch

C++ -

Strukturen -

ADT -

Klassen -

Objekte

Reiner Nitsch 8471

[email protected]

mailto:[email protected]


15.04.2009 2

Datei time.h

Strukturen (auch Records genannt)

•

sind benutzerdefinierte Datentypen•

sind Datentypen, die aus mehreren Variablen mit gleichem Typ (=homogener Typ)

oder

unterschiedlichem Typ (=inhomogener Typ)

zusammengesetzt sind,•

unterstützen

den Programmierer bei der Verwaltung zusammengehöriger Daten,

Beispiel:

// Modul "Tageszeit"// Datentyp Time für das Speichern der Tageszeit,// und Funktionen ihrer Verarbeitung

// Deklaration des neuen Typs Time als Datenstruktur

struct Time {int hour; // 0-23int minute; // 0-59int second; // 0-59

};

void print24hFormat( Time ); // Fkt-Prototypvoid print12hFormat( Time ); // Fkt-Prototyp

Name des neuen Typs

Bauplan desneuen Typs

Membervariablen

(Typ bel. ausser

Zeit)

Deklarationsteil


15.04.2009 3

Strukturen

// Datei time.cpp#include <iostream>#include <iomanip>

using namespace std;

void print24hFormat ( ostream os, Time t ){ // Zeit im 0-24h Format ausgebencout << setfill('0')

<< setw(2) << t.hour << ':'<< setw(2) << t.minute << ':'<< setw(2) << t.second;

}

void print12hFormat ( Time t ){ // Zeit im 0-12h Format ausgebencout << setw(2) << (( t.hour==0 || t.hour==12 ) ? 12 : t.hour%12 ) << ':'

<< setw(2) << t.minute << ':'<< setw(2) << t.second << ( t.hour < 12 ? " AM" : " PM" );

}// END Datei time.cpp// weitere Funktionen im Praktikum

#include "time.h"

Implementationsteil


15.04.2009 4

Strukturen

// Datei: time_appl.cpp

int main() {// Deklaration einer Struktur-// Variablen des neuen Typsstruct Time begin; //ohne Initialisierung!// Membervariable initialiserenbegin.hour = 18;begin.minute = 5;begin. second = 0;

cout << "Abendessen ist um ";print24hFormat( begin );cout << " im 0-24h Format,\nbzw. ";print12hFormat( begin );cout << " im 0-12h Format.\n";

Memberzugriffsoperatoroder Punkt-Operator

Erzeugt Strukturvariable gemäß

Bauplan

#include "time.h"#include <iostream>

using namespace std;

Anwendungsteil


15.04.2009 5

Strukturen

// Anwender setzt Membervariable auf ungültige Wertestruct Time crazyTime;crazyTime.hour = 29;crazyTime.minute = 73;crazyTime.second = 105;cout << "\nVerrueckte Zeit: ";print24hFormat( crazyTime );cout << endl; // Deklaration und Initialisierungstruct Time end = { 20, 14, 10 };return 0;

} // end main

Nachteil bei struct: Kein Schutzmechanismus

Anfangswerte für {Stunde, Minute, Sekunde}

// Datei Time.cpp// Versuch einen Schutzmechanismus durchzusetzenvoid setTime( Time t, int h, int m, int s ) {if(h>=0 && h<24 &&

m>=0 && m<60 &&s>=0 && s<60 ) {

hour = h; minute = m;second = s;

}

Reicht nicht, weil direkter Zugriff immer nich möglich!


15.04.2009 6

Strukturen und ihre Nachteile

Nachteile von Struktur-Datentypen in C (C++)•

Strukturen können ohne Initialisierung benutzt werden

(Keine Datenkapselung)

•

Strukturen können falsch initialisiert sein. Ausschließlich der Programierer

ist verantwortlich.

•

Änderungen

im Memberbereich

einer Datenstruktur (z.B. andere Bezeichner, Datentypen oder Codierung) sind aufwändig, weil alle

Anwendungsprogramme,

die

diesen benutzerdefinierten Typ benutzen, geändert werden müssen.

•

Abhilfe:

Objektorientierte Programmstrukturierung mit abstrakten Datentypen

Abendessen ist um 18:05:00 im 0-24h Format,bzw. 6:05:00 PM im 0-12h Format.

Sonderbare Zeit: 29:73:105Press any key to continue

Ausgabe


15.04.2009 7

Grundkonzept der Informatik -

Abstraktion

•

Abstraktion ist das Weglassen von unwesentlichen Details, so dass die Essenz

der Sache übrig bleibt

–

Beispiel: Karte der U-Bahn in London,–

1928 (links) und 1933 (rechts)

Bildquelle: J. Kramer. Is Abstraction the Key to Computing ? Communications of the ACM, Vol. 50, No. 4, April 2007


15.04.2009 8

Funktionale Abstraktion

•

Historisch erste Form der Abstraktion•

Merkmale

–

Programmstrukturierungsmittel: Daten

zur Zustandsspeicherung und

getrennt davon

die auf sie angewendeten Funktionen.

•

Nachteile: –

Daten müssen den Funktionen übergeben werden, teilweise auch als globale Variablen damit ein gemeinsamer Zugriff durch Funktionen auf verschiedenen Ebenen möglich wird.

–

Das hat negative Auswirkungen auf die Sicherheit.•

auch unzulässige Funktionen können auf die Daten angewendet werden.

–

Daten und Funktionen können beliebig im Programm verteilt sein (schlecht für Fehlersuche, Wiederverwendung, Änderungen)

FunktionDaten Daten


15.04.2009 9

Datenabstraktion

Deshalb neues Programm-Strukturierungskonzept: Datenabstraktion–

Daten stehen im Mittelpunkt;

–

Sie haben eigene Funktionen zur Verfügung, die Methoden

genannt werden.–

Nur diese Methoden haben Zugriff auf die Daten (Datenkapselung, Zugriffsschutz).

–

Daten und zugehörige Funktionen werden an einer Stelle im Programm zusammen gefasst. Daraus resultiert eine bessere Änderbarkeit, Wiederverwendbarkeit und einfachere Fehlereingrenzung.

–

Datentypen mit diesen Eigenschaften nennt man Abstrakte Datentypen

(ADT)

–

Anforderung: Die Programmiersprache muss diesen Datentyp unterstützen.

Abstrakter Datentyp = Datentypen + Funktionen

Abstrakter Datentyp

hms

Botschaft

gekapselte DatenuhrStellen(h,m,s)

Objekt


15.04.2009 10

Realisation der Qualitätsanforderungen Software durch OOP

•

Die grundlegenden Prinzipien von OOP sind Abstraktion, Kapselung, Modularisierung

und Hierarchie.

•

Objekte und Objekttypen (Klassen), die gekapselten Daten (Zustände) und eigene Operationen (Methoden) besitzen bilden das Programmgerüst.

•

Objekte stehen miteinander in Verbindung und senden sich gegenseitig Aufträge (Botschaften) zu.

•

Jedes Objekt erledigt damit nur den Teil der Aufgaben, für den es verantwortlich ist.

•

Das Zusammenwirken aller beteiligten Objekte löst die Gesamtaufgabe.

Ziele

ProblemangeméssenheitZuverlässigkeit

WiederverwendbarkeitErweiterbarkeit

Pflegbarkeit

Prinzipien

AbstraktionModularitätHierarchie

Techniken

KapselungKlassenbildung

ObjekteVererbung

Polymorphie


15.04.2009 11

Grundkonzepte der Objektorientierung -

Klassen und ObjekteBa

upla

n

Reale WeltPersonenkraftwagen(PKW)

EigenschaftenHerstellerTypLeistungGewichtTankinhaltGeschwindigkeit

Klasse PKWAuto1

Hersteller = VWTyp = LupoBaujahr = 2004Leistung = 40Tankinhalt = 45Geschwindigkeit = 0

Auto2

Hersteller = BMWTyp = Z3Baujahr = 2003Leistung = 150Tankinhalt = 55Geschwindigkeit = 0

Objekte vom Typ PKW

Instanziierung:Objekte nach diesem Bauplan herstellen

Verhaltenfahrenbremsentanken…Herstellen Verschrotten

Abstrakter Datentyp


15.04.2009 12

Klassen und Objekte - Ein Vergleich

Objekt•

kleinste Einheit der Systemgestaltung

•

Einzelheiten sind–

sein Zustand

•

Attribute

oder Membervariable•

- sein Verhaltensrepertoire

•

Operationen

oder Memberfunktionen

Klasse•

Bauanleitung für Objekte (nach innen)

•

Nutzungsanleitung für Objekte (nach aussen)•

Besitzt Mechanismus zur Erzeugung / Zerstörung von Objekten –

Konstruktor

/ Destruktor

Wer heute nicht objektorientiert denken kann, kann als Programmierer einpacken.


15.04.2009 13

Unified

Modelling

Language

(UML)

•

ermöglicht programmiersprachenunabhängige–

Spezifikation

–

Visualisierung–

Konstruktion

–

Dokumentationobjektorientierter Softwaresysteme

UML-Klassendiagramm

a) niedrigster DetaillierungsgradPKW bmw

UML kennt keine strenge visuelle Unterscheidung zwischen Objekten und Klassen. Objektnamen sind unterstrichen, Klassennamen nicht.

Klasse Objekt

b) mittlerer Detaillierungsgrad

PKW

- hersteller: string- typ: string- baujahr: int

+ <Konstruktor>+ <Destruktor>+ fahren():void+ tanken(wieviel:float):void

Name

Attribute

Methoden

'+' bzw. '-' bedeutet public bzw. private Deklaration. Dies hat Auswirkung auf die Zugriffsrechte (kommt gleich)


15.04.2009 14

Struktur und Syntax einfacher OO-Programme in C++

1 Systemprogrammierung, Teil 1:

Klassendeklaration (Schnittstellenbeschreibung; enthält Prototypen)

// Datei: NeueKlasse.hclass NeueKlasse {

private:<Typ> attribut1;<Typ> attribut2;

...<Typ> attributN;

public:NeueKlasse();~NeueKlasse();

<Typ> methode1();<Typ> methode2();

...<Typ> methodeM();

};

Privater Schnittstellenteil (default: private)Zugriffsschutz von aussenkeine Speicherplatzreservierung, nur Bauplan

// öffentlicher (public) Schnittstellenteil beginnt hier// Konstruktor: Kein Ergebnistyp; wird vom System auch // automatisch erzeugt.

// Destruktor: Kein Ergebnistyp, // wird automatisch aufgerufen

// File: Counter.h// Class-Declarationclass Counter{private:

int value;public:Counter();~ Counter();void set(int);void higher();void lower();void show();

};

Counter

- value: int

+ Konstruktor+ Destruktor+ set(int): void+ higher():void+ lower(): void+ show(): void


15.04.2009 15


2 Anwendungsprogrammierung: Arbeiten

mit problemangepassten

Datentypen und Objekten// Datei: main.cpp

#include "NeueKlasse.h"void main(void)

{NeueKlasse einObjekt;

NeueKlasse einAnderesObjekt;einObjekt.methode1();einObjekt.methode2();

einAnderesObjekt.methode1();}

// methode1 arbeitet mit den Membervariablen von einObjekt// methode1 arbeitet mit den Membervar von einAnderesObjekt

// Hier werden die Destruktoren automatisch aufgerufen

// Konstruktoraufruf; Achtung: ohne "( )"// hier wird Objekt "anObjekt" definiert

// Memberfunktionen gibt es nur einmal// pro Klasse im Speicher

// Datei: main,cpp#include "Counter.h"int main(void) {

Counter myCounter;myCounter.set(5);myCounter.higher();myCounter.show(); myCounter.lower();myCounter.show(); Counter yourCounter();yourCounter.set(10);yourCounter.show();int i = yourCounter.value; return 0;

}


15.04.2009 16


3 Systemprogrammierung, Teil 2:

Klassendefinition

(Implementierung der Methoden)

// Datei: NewClass.cpp

#include " NeueKlasse.h"NeueKlasse::NeueKlasse(){

[<Anweisung>]}

NeueKlasse::~NeueKlasse() {

[<Anweisung>]}

<Typ> NeueKlasse::methode1(){

<Anweisung><Anweisung>

...<Anweisung>

}

...

// File: Counter.cpp// Class-Implementation#include "Counter.h"#include <iostream>using namespace std;

Counter::Counter() { // Konstruktorvalue = 0;cout << "Ein Zaehler wird erzeugt!\n";

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

cout << "Ein Zaehler wird zerstoert!\n";}void Counter::set(int aValue) {

if(aValue>=0 && aValue<=10)value = aValue;

}void Counter::higher() {

if(value<10) ++value;}void Counter::lower() {

if(value>0) -- value;}void Counter::show() {

cout << value << endl; }

NamensbereichBezeichner (Name)der Methode

Namensbereichauswahloperator


15.04.2009 17

Ein einfaches Beispiel - Datentyp Counter

Counter

- value: int

+ Konstruktor+ Destruktor+ set(int): void+ higher():void+ lower(): void+ show(): void

// Datei: main,cpp#include "Counter.h"int main(void) {

Counter myCounter;myCounter.set(5);myCounter.higher();myCounter.show(); myCounter.lower();myCounter.show();

Counter yourCounter();yourCounter.set(10);yourCounter.show();int i = yourCounter.value; return 0;

}

// File: Counter.h// Class-Declarationclass Counter{private:

int value;public:Counter();~ Counter();void set(int);void higher();void lower();void show();

};

// File: Counter.cpp// Class-Implementation#include "Counter.h"#include <iostream>using namespace std;

Counter::Counter() { // Konstruktorvalue = 0;cout << "Ein Zaehler wird erzeugt!\n";

}

Counter::~Counter() { // Destruktorcout << "Ein Zaehler wird zerstoert!\n";

}

void Counter::set(int aValue) {if(aValue>=0 && aValue<=10)

value = aValue;}void Counter::higher() {

if(value<10) ++value;}void Counter::lower() {

if(value>0) -- value;} void Counter::show() {

cout << value << endl; }

//Fehler: Zugriffschutz


15.04.2009 18

Objekte im Speicher

•

Jedes Objekt besitzt seine eigenen Membervariablen

•

Speicherplatz für Membervariable

wird erst bei der Objektdefinition reserviert.

•

Memberfunktionen

gibt es nur einmal pro Klasse im Speicher

•

Memberfunktionen

arbeiten stets mit den Datenelementen des Objekts, für das sie aufgerufen werden.

AdresseC000Membervariable 1

Membervariable 2…

myCounter

Membervariable 1Membervariable 2

…

C100yourCounter


15.04.2009 19

double sqrt( double x ) { // Berechnet Quadratwurzel// PRE: x>=0 // POST: Maximaler Fehler kleiner 10-6

assert( x>=0 );

// hier folgt der Algorithmus …

assert( betrag(y*y-x) < 1e-6 );return y; }

Programmieren mit Vertrag

•

Vorbedingungen: Der Zustand, in dem das System sein muss, damit die Methode ihre Leistung erbringen kann.

•

Nachbedingungen: Beschreiben den Zustand, in dem das System sein muss, wenn die Leistung korrekt erbracht wurde.

•

Beispiel: Counter::lower()

•

C++ Konzept der Zusicherungen "assert"

#include <cassert>void Counter::lower() {// PRE: value>0// POST: value um eins vermindert

assert (value > 0);--value;

}

//Aufrufer für korrekten Aufruf verantwortlich! // Kontrollierter Programmabbruch, wenn Bedingung == false

// Überprüfung der Nachbedingung hier überflüssig: Korrekte Abwicklung // einzelner Sprachkonstrukte kann vorausgesetzt werden.

•

werden typischerweise nur in der Entwicklungsphase eines Programmes überprüft und helfen logische Fehler

frühzeitig erkennen (ungeeignet bei Benutzereingaben)

PRE&POST (mathematisch oder verbal) gehören zur Funktionsbeschreibung


15.04.2009 20

Membervariable

oder lokale Variable

class Account{

double credit;

};

void Account::payIn(){

cin >> thePayIn;

credit += thePayIn;}

int thePayIn; // Falsch: nur von lokaler temporärer Bedeutung in payIn()

int thePayIn; // Richtig: lokale Variable – nur von temporärer Bedeutung

Membervariable

sollen nicht nur von lokaler temporärer Bedeutung sein

Membervariable

sollen nicht nur von lokaler temporärer Bedeutung sein

// Faustregel: Bedingungen, die an äußere Einflüsse (Benutzereingaben, Dateiinhalte, ...) gebunden sind, muß die Programmlogik behandeln;

Vorbedingung// Was fehlt hier?thePayIn = thePayIn >=0 ? thePayIn:-thePayIn;

// Warum ist assert ungeeignet?

// Weder Compiler noch Programmlogik können sicherstellen, daß der Benutzer einen passenden Wert eintippt;


15.04.2009 21

Übung 2 –

Konto -

MusterausgabeBildschirmausgabe zur Übung 2 (Konto)

•

Testsequenz fuer Konto 1 ...•

--------------------------------------------------•

Konto 1 erzeugen ...•

Gib 4-stellige PIN: 1234•

--------------------------------------------------•

Konto 1 Einzahlung ...•

Wieviel wollen Sie einzahlen: 111•

--------------------------------------------------•

Konto 1 Kontoauszug holen ...•


Der aktuelle Stand des Kontos ist: 111.00•

--------------------------------------------------•

Konto 1 Auszahlung ...•


Wieviel soll es denn sein: 11•

--------------------------------------------------•



Der aktuelle Stand des Kontos ist: 100.00•

--------------------------------------------------•

Konto 1 PIN aendern ...•

PIN aendern: Gib 4-stellige PIN: 1234•

Gib neue PIN: 4321•

Wiederhole neue PIN: 4321•

OK! Pin geaendert.•

--------------------------------------------------•



Der aktuelle Stand des Kontos ist: 100.00

Account- balance:double {>0} - pin:int {>1111,<9999}

+ Konstruktor + Destruktor + payIn():void + payOut():void + showCredit():void + changePin():void - checkPin():bool

Programmierrichtlinien lesen und beachten!Alle Bezeichner in Englisch.Nur Dialog in Deutsch.

Keine Parameter!

UML-Zusicherung


15.04.2009 22

So, das war´s

erst mal!


15.04.2009 36

Klassen und Objekte - Ein Vergleich

Wer heute nicht objektorientiert denken kann, kann als Programmierer einpacken.

In realer Welt

Art/Sortegekennzeichnet durch

-

gemeinsame Eigenschaften und Verhaltensrepertoire/Fähigkeiten

Ding / Lebewesengekennzeichnet durchidentifizierbare und unterscheidbare EinzelheitenFähigkeiten/

Verhalten/ Verwendungsmöglichkeiten

In Informatiksystemen

Ding / Lebewesen•

gekennzeichnet durch•

identifizierbare und unterscheidbare Einzelheiten

•

Fähigkeiten/ Verhalten/

Verwendungsmöglichkeiten

Objektkleinste Einheit der SystemgestaltungEinzelheiten sind- sein Zustand

-> Attribute

oder Membervariable- sein Verhaltensrepertoire

-> Operationen

oder Memberfunktionen

KlasseBauanleitung für Objekte (nach innen)Nutzungsanleitung für Objekte (nach aussen)Besitzt Mechanismus zur Erzeugung / Zerstörung von Objekten

-> Konstruktor / Destruktor


15.04.2009 37

Objektstruktur

von aussen

unzugängliche

Datenstruktur(Membervariablen; z.B. Hersteller, Typ, Baujahr, …)

von aussen zugängliche

Memberfunktionen (Methoden; z.B. fahren, bremsen, tanken, …)

Klar definierte Schnittstelle zur Abgrenzung nach aussen

Objekt 1

Objekt 2

Kommunikation durch Aufrufvon Memberfunktionen

Documents

C++ - Strukturen - ADT - Klassen - Objekte · PDF fileFB Informatik Prof. Dr. R.Nitsch C++ - Strukturen - ADT - Klassen - Objekte Reiner Nitsch 8471 [email protected]