Object-oriented Programming in C++

Transcription

1 Object-oriented Programming in C++ Object Orientation in C++ Wolfgang Eckhardt, Tobias Neckel July 1, 2014 Object Orientation in C++, July 1,

2 1 The Concept of Object Orientation Object Orientation in C++, July 1,

3 1.1 Definition of Objects What Is an Object? a car a cat a chair... a molecule a star a galaxy... anything that represents a real thing anything that represents an abstract thing anything which has some properties Object Orientation in C++, July 1,

4 How to Program Object-orientedly Change your way of thinking Change your point of view It is not just a technical question! Good designs requires considerable experience! Object Orientation in C++, July 1,

5 Classes A class is similiar to the definition of a type Specifies properties of the objects to be created 1.2 Classes vs. Objects Data to be stored once for all objects (class/static variable) Data to be stored in each object (member variables) Operations to be done with objects (member functions/methods) Represents a class of things/objects Instances / Objects An instance/object is a concrete thing of the type of a class A class specifies properties, an object has specific values for the specified properties state of an object For each class, there can be an arbitrary number of objects Each object belongs to exactly one class (exception: polymorphism, day 3) Object Orientation in C++, July 1,

6 Object: Definition Definition Oracle, The Java Tutorials State: the set of values of member variables/fields (built-in datatypes and other objects) at a specific point in time Behaviour: Member functions/methods operate on the internal state of the object, primary mechanism for object-to-object communication Object Orientation in C++, July 1,

7 Object: Example Oracle, The Java Tutorials Example: Bike State: Speed, Revolutions per Minute, Gear,.. Behaviour: Change gears, change cadence, brake,.. Object Orientation in C++, July 1,

8 Pros 1.3 Why Object Orientation? Modularity: Implementation of different objects usually written independently. Information hiding: Internal implementation remains hidden from the outside world (can be changed easily even for heavy used objects) Code reuse: Object (re-)use: you only have to understand the member-functions visible to you (interfaces in software projects and/or libraries) Inheritance (details below) Cons Performance: Wrong usage of OO-language constructs might come with a significant overhead. Code complexity: Be careful: unclever OO design problems in maintenance, extensibility, etc.) Object Orientation in C++, July 1,

9 2 Objects in C ++ Bikes as Objects Task: Model a bike in C ++ Goal: Learn the C ++ syntax on the way Design Gear Shift Bike State: current gear, #gears Behaviour: increase gear, decrease gear, get current gear State: current speed, revolutions per minute, gear shift Behaviour: change gear, brake, change cadence Object Orientation in C++, July 1,

10 2.1 Overview: Bikes as Objects Design Gear Shift Overview Bike State: current gear, #gears Behaviour: increase gear, decrease gear, get current gear State: current speed, revolutions per minute, gear shift Behaviour: change gear, brake, change cadence Next Skeleton (header file) of the bike class with member variables, member functions and access control. Object Orientation in C++, July 1,

11 Bike.h - The class Keyword 17 # ifndef BIKE_H_ 18 # define BIKE_H_ # include <cmath > 21 # include <iostream > # include " GearShift.h" class Bike { 72 }; # endif // BIKE_H_ Keyword code: class defines a class in C ++ frame for OO concepts (member variables, member functions, inheritance,... ) Object Orientation in C++, July 1,

12 Bike.h - State: Member Variables 25 class Bike { 26 // private : 27 //! current speed 28 float m_speed ; //! current rpm 31 float m_revolutions ; //! gear shift 34 GearShift m_gearshift ; 72 }; State code: Member variables define the state of an object. Member variable can be built-in or custom objects. Object Orientation in C++, July 1,

13 Relationships between Objects: Part-Of Part-Of releationship Object A is with object B in an part-of releationship, if A is part of B (A is one of the parts the machinery of B is assembled of). Example: Object gear shift can be modeled in a part-of relation to the object bike. Object Orientation in C++, July 1,

14 Object Member Variables model Part-Of Object Member Variables OO-programming: allows objects to be build of other objects not only built-in data-types allows for a modular implementation and code reuse Object Orientation in C++, July 1,

15 Bike.h - Behaviour: Member Functions 25 class Bike { 36 public : 37 /** 38 * Constructor 39 * 40 i_numberofgears # gears 41 **/ 42 Bike ( int i_numberofgears ); /** 45 * Destructor 46 **/ 47 ~ Bike (); /** 50 * Changes the gear to the closest possible gear. 51 * 52 i_gear gear to change to. 53 **/ 54 void changegear ( int i_gear ); 72 }; code: Object Orientation in C++, July 1,

16 Bike.h - Behaviour: Member Functions (2) 25 class Bike { 36 public : 56 /** 57 * Brakes the bike. 58 **/ 59 void brake (); /** 62 * Accelerates the bike. 63 * 64 i_rpm revolutions per minute. 65 **/ 66 void changecadence ( float i_rpm ); 72 }; Behaviour code: Member functions: mutator methods: change internal state of an object (often setxxx()) Object Orientation in C++, July 1,

17 Bike.h - Behaviour: Member Functions (3) 25 class Bike { 36 public : /** 69 * Prints status of our bike. 70 **/ 71 void printinformation () const ; 72 }; Behaviour code: Member functions: accessor methods give access (read-only) to the state of an object (often getxxx()) Object Orientation in C++, July 1,

18 Bike.h - Access Control 25 class Bike { 26 // private : 27 //! current speed 28 float m_speed ; 36 public : 37 /** 38 * Constructor 39 * 40 i_numberofgears # gears 41 **/ 42 Bike ( int i_numberofgears ); Accessibility Restrictive access control: helps to write clean code & uses compiler to enforce interfaces. private: Members public: Anyone Object Orientation in C++, July 1,

19 Information Hiding Users/developers have restricted access to objects/classes avoid side effects! (you don t want a user to change the gravity constant of the earth, etc.) reduce code complexity in usage (you only need to care about what you can see) reduce code complexity in development (accessor methods, e.g.: rename a member variable) Object Orientation in C++, July 1,

20 2.2 Overview: Bikes as Objects Design Gear Shift Overview Bike State: current gear, #gears Behaviour: increase gear, decrease gear, get current gear State: current speed, revolutions per minute, gear shift Behaviour: change gear, brake, change cadence Previous Skeleton (header file) of the Bike class with member variables, member functions and access control. Next Implementation (source file) of the Bike class & runner. Object Orientation in C++, July 1,

21 Bike.cpp - Constructor 17 # include " Bike.h" Bike :: Bike ( int i_numberofgears ): 20 m_speed (0), 21 m_revolutions (0), 22 m_gearshift ( i_numberofgears ) { 23 std :: cout << " bike with " << i_numberofgears 24 << " gears constructed " << std :: endl ; 25 }; Properties code: Called whenever an object is created More than one constructor (with different syntax) possible; no return type If none is specified, the compiler generates one (default constructor) Object Orientation in C++, July 1,

22 Bike.cpp - Member Initialisation List 19 Bike :: Bike ( int i_numberofgears ): 20 m_speed (0), 21 m_revolutions (0), 22 m_gearshift ( i_numberofgears ) { Properties code: Per default the default constructor is called for all members Some member types have to be initialised in the member initialisation list: references non-static const member class members w\o default constructors base class members (Performance gains possible: construction vs. assignment) Object Orientation in C++, July 1,

23 Bike.cpp - Destructor 27 Bike ::~ Bike () { 28 std :: cout << " bike destroyed :(" << std :: endl ; 29 } Properties code: Called whenever an object is destroyed Clean up of the object (could free dyn. allocated memory, e.g.) No arguments or return type If no destructor is specified, the compiler generates a default one Object Orientation in C++, July 1,

24 Bike.cpp - Member Functions 31 void Bike :: changegear ( int i_gear ) { 32 if( i_gear < m_gearshift. getcurrentgear () ) { 33 // decrease gears until best possible gear is reached 34 while ( m_gearshift. decreasegear () ) { 35 if( i_gear == m_gearshift. getcurrentgear () ) break ; 36 } 37 } 38 else if( i_gear > m_gearshift. getcurrentgear () ) { 39 // increase gearse until best possible gear is reached 40 while ( m_gearshift. increasegear () ) { 41 if( i_gear == m_gearshift. getcurrentgear () ) break ; 42 } 43 } 44 } void Bike :: brake () { 47 m_speed = std :: max ( 0.f, m_speed - 5. f ); 48 m_revolutions = m_speed * 25. f; 49 } void Bike :: changecadence ( float i_rpm ) { 52 m_revolutions = std :: max ( 0.f, i_rpm ); 53 m_speed = m_revolutions * m_gearshift. getcurrentgear () / 25. f; 54 } Object Orientation in C++, July 1,

25 Bike.cpp - Member Functions (2) 56 void Bike :: printinformation () const { 57 std :: cout << " speed : " << m_speed << std :: endl 58 << " rpms : " << m_revolutions << std :: endl 59 << " gear : " << m_gearshift. getcurrentgear () 60 << std :: endl ; 61 } Properties accessor member functions: const forbids modification of member variables (details later and in the tutorials) Object Orientation in C++, July 1,

26 2.3 Runner: Instantiating Objects 17 # include " Bike.h" int main () { 20 // construct two bikes 21 Bike l_mybike ( 20 ); 22 Bike * l_myfriendsbike = new Bike ( 15 ); 39 delete l_myfriendsbike ; 40 } code: 2 Variants: Direct instantiation via constructor call Dynamic memory allocation in C ++: via new-keyword (more typesafe and calls constructors) Hint: Always delete what you new, and free what you malloc. Don t mix new with free or malloc with delete! Object Orientation in C++, July 1,

27 17 # include " Bike.h" int main () { 20 // construct two bikes 21 Bike l_mybike ( 20 ); 22 Bike * l_myfriendsbike = new Bike ( 15 ); // print their initial status 25 l_mybike. printinformation (); 26 l_myfriendsbike -> printinformation (); // go on a bike tour with a friend 29 l_mybike. changegear ( 16 ); 30 l_mybike. changecadence ( 16.5 ); 31 l_myfriendsbike -> changegear ( 9 ); 32 l_myfriendsbike -> changecadence ( 29.8 ); // print information 35 l_mybike. printinformation (); 36 l_myfriendsbike -> printinformation (); // free dynamic memory 39 delete l_myfriendsbike ; 40 } Runner: Using bikes Object Orientation in C++, July 1,

28 2.4 Special Members up to now: member variables member functions How about variables that exist only once per class (not per object)? How about functions that do not modify objects? Object Orientation in C++, July 1,

29 19 class SimpleClass { 20 // private : 21 static int s_simplecounter ; 22 Static Members 23 public : 24 SimpleClass () { 25 s_simplecounter ++; 26 std :: cout << " ctr in constr =" << s_simplecounter << std :: endl ; 27 }; ~ SimpleClass () { 30 s_simplecounter - -; 31 std :: cout << " ctr in destr=" << s_simplecounter << std :: endl ; 32 }; 33 }; int SimpleClass :: s_simplecounter = 0; int main () { 38 SimpleClass l_simple1 ; 39 { 40 SimpleClass l_simple2 ; 41 } 42 SimpleClass l_simple3 ; 43 } Object Orientation in C++, July 1,

30 Static Members (2) 19 class SimpleClass { 20 // private : 21 static int s_simplecounter ; public : 24 SimpleClass () { 25 s_simplecounter ++; 26 std :: cout << " ctr in constr =" << s_simplecounter << std :: endl ; 27 }; ~ SimpleClass () { 30 s_simplecounter - -; 31 std :: cout << " ctr in destr=" << s_simplecounter << std :: endl ; 32 }; 33 }; int SimpleClass :: s_simplecounter = 0; code: Description A class can have static member variables, which are single locations in memory shared by all instances of the class. Object Orientation in C++, July 1,

31 19 class SimpleClass { 20 // private : 21 static int s_simplecounter ; 22 Static Member Functions 23 public : 24 static void increasecounter (){ s_simplecounter ++; }; 25 static void printcounter (){ std :: cout << s_simplecounter << std :: endl ; }; 26 }; int SimpleClass :: s_simplecounter = 1; int main () { 31 SimpleClass :: printcounter (); 32 SimpleClass :: increasecounter (); 33 SimpleClass :: printcounter (); 34 } code: Description Static member functions: accessible independently of a single instance of a class non-static members or this-pointer can t be accessed Object Orientation in C++, July 1,

32 Const Members 17 class SimpleClass { 18 // private : 19 const int m_a ; public : 22 SimpleClass ( int i_a ): m_a ( i_a ) { 23 // forbidden assignment 24 // m_a = 10; 25 }; 26 }; int main () { 29 SimpleClass l_simple ( 15 ); 30 } code: Description A class can have const member variables: can t be changed after initialization have to be set in the member initialisation list. Object Orientation in C++, July 1,

33 Const Member Functions 17 class SimpleClass { 18 // private : 19 int m_a ; public : 22 void simplefunctions () const { 23 // forbidden assignment 24 // m_a = 5; 25 } 26 }; int main () { 29 SimpleClass l_simple ; 30 l_simple. simplefunctions (); 31 } code: Description A class can have const member functions, which are not allowed to change the member variables/state of an object. Hint: The position of the const qualifier is crucial ( tutorials). Object Orientation in C++, July 1,

34 3 Inheritance Object Orientation in C++, July 1,

35 Inheritance in Real Life object Object Orientation in C++, July 1,

36 Inheritance in Real Life sunbed table chair furniture oak cypress beech daisy tulip rose Audi car VW BMW machine object comp. plant animal tree mammal reptile flower horse donkey cat Golf Polo Phaeton laptop desktop vectorc. cluster croc. snake mule Object Orientation in C++, July 1,

37 Relationships between Objects: Is-A Oracle, The Java Tutorials Is-A releationship Object A is with object B in an is-a releationship, if A behaves like B, but adds additional features (B is a blueprint for A); Example: Objects mountain bike and road bike are modeled to be in a is-a relation to the object bicycle Object Orientation in C++, July 1,

38 Is-A models Inheritance Oracle, The Java Tutorials Inheritance OO-programming allows to inherit states and behaviour from other objects; allows for abstraction/specialization in the implementation Object Orientation in C++, July 1,

39 Understanding Is-A : Rectangles Sketch Rectangles Rectangle: increasesize() Square is-a Rectangle Rectangle.increaseSize(), Square.increaseSize()? Object Orientation in C++, July 1,

40 Inheritance in OO Code Classes can inherit from a base class they are derived classes / subclasses of the base clase All classes can be specialised All classes together form a taxonomy/hierarchy of classes Methodes of the base class can be kept and used, or can be defined newly (overwriting, details see day 3) Object Orientation in C++, July 1,

41 3.2 Inheritance: Interface and Implementation Sketch Shape Shape( int i_color = 0 ); virtual ~Shape(); int getcolor() const; virtual double getsurfacearea() const; Star Rectangle Star(..); virtual ~Star(); virtual double getsurfacearea() const; Circle Rectangle( double i_width, double i_height, int i_color = 0 ); virtual ~Rectangle(); virtual double getsurfacearea() const; Circle( double i_radius ); virtual ~Circle(); virtual double getsurfacearea() const; Object Orientation in C++, July 1,

42 Star(..); virtual ~Star(); virtual double getsurfacearea() const; Shape( int i_color = 0 ); virtual ~Shape(); int getcolor() const; virtual double getsurfacearea() const; Circle( double i_radius ); virtual ~Circle(); virtual double getsurfacearea() const; Rectangle( double i_width, double i_height, int i_color = 0 ); virtual ~Rectangle(); virtual double getsurfacearea() const; Sketch Inheritance: Interface and Implementation (2) Shape Star Rectangle Circle Description Inheritance splits into: Function interfaces and function implementations Allows for three different type implementations: Implementation provided by base class Default-implementation provided base class (can be overwritten) Interface provided by base class (needs to be implemented) Object Orientation in C++, July 1,

43 3.3 Inheritance in C ++: Basic Syntax 19 class Shape { 20 // private : 21 public : 22 Shape () { 23 std :: cout << " constructed a new shape " << std :: endl ; 24 } virtual ~ Shape () {}; 27 }; class Star : public Shape {}; 30 class Circle : public Shape {}; 31 class Rectangle : public Shape {}; Concept code: Shape is the base class for the derived classes Star, Circle and Rectangle Object Orientation in C++, July 1,

44 Shape.cpp - A Bit More Complex 23 class Shape { 24 // private : 25 int m_color ; public : 28 Shape ( int i_color =0 ): 29 m_color ( i_color ) {}; 30 virtual ~ Shape () {}; int getcolor () const { return m_color ; }; 39 }; code: code: Object Orientation in C++, July 1,

45 Inheritance - Implementing a Child Class 41 class Circle : public Shape { 42 // private : 43 double m_radius ; public : 46 Circle ( double i_radius ): 47 Shape (), m_radius ( i_radius ) { 48 std :: cout << " constructed a circle, radius : " 49 << m_radius << std :: endl ; 50 }; 51 virtual ~ Circle () {}; 57 }; code: code: Accessibility Circle inherits from Shape note class definition Note: call of base class constructor in initialisation list Object Orientation in C++, July 1,

46 41 class Circle : public Shape { 42 // private : 43 double m_radius ; public : 46 Circle ( double i_radius ): 47 Shape (), m_radius ( i_radius ) { 48 std :: cout << " constructed a circle, radius : " 49 << m_radius << std :: endl ; 50 }; 51 virtual ~ Circle () {}; 57 }; Inheritance - Access Control code: code: Accessibility Restrictive access control helps to write clean code and uses the compiler to enforce your interfaces. private: Members protected: Members of the class & of derived classes public: Anyone Object Orientation in C++, July 1,

47 4 Backup some stuff that may be interesting but is not covered in the lecture Object Orientation in C++, July 1,

48 4.1 Switching Off the Lifecycle Management 1 double * p ; 2 3 p = new double ; / / now, p p o i n t s to an e x i s t i n g new v a r i a b l e 4 5 * p = 20; 6 7 d e l e t e p ; / / now v a r i a b l e i s freed, but p s t i l l p o i n t s 8 / / to t h i s v a r i a b l e * p = 30; The value 20 in the memory is an anonymous variable as it doesn t have a name we can reach it only through a pointer. Object Orientation in C++, July 1,

49 Two Memory Leaks 1 double * p ; 2 3 f o r ( i n t i =0; i <20; i ++) { 4 p = new double ; 5 } 6 7 d e l e t e p ; 1 f o r ( i n t i =0; i <20; i ++) { 2 double * p = new double ; 3 } The upper operation creates 20 doubles on the heap, but it destroys only one double in the end. Consequently, the remaining 19 doubles are lost for the future program execution. Let s sketch the memory layout! The second one destroys the pointer but not the space where the pointer is pointing to. This is why many applications crash after Wolfgangseveral Eckhardt, Tobias hours Neckel: of Object-oriented execution. Programming in C++ Object Orientation in C++, July 1,

50 Understanding is-a : Birds Birds Bird: fly() Penguin is-a bird Bird.fly(), Penguin.fly()? What happenend? Problem of our intuotion/language, birds fly means in general birds have the ability to fly Correct model, if our project contains no non-flying bird and will not contain non-flying birds in future Birds (2) Bird FlyingBird is-a Bird: fly() NonFlyingBird is-a Bird Penguin is-as a NonFlyingBird FlyingBird.fly() NonFlyingBird.fly(), Peguin.fly() Object Orientation in C++, July 1,

51 4.2 Modellierung mit UML Flussdiagramme Nur geeignet für kleine Algorithmen Keine Darstellung von Klassenhierarchien Keine Darstellung von Datenabhängigkeiten... UML: Unified Modeling Language visuelle Modellierungssprache Sprache unterstützt unterschiedliche Diagrammtypen Software wird über diese Diagramme/Modelle spezifiziert Kann als Basis für die Dokumentation dienen Automatische Code-Generierung möglich Auch für sonstige betriebliche Abläufe geeignet Object Orientation in C++, July 1,

52 Strukturdiagramme Klassendiagramm Objektdiagramm Kompositionsstrukturdiagramm Komponentendiagramm Verteilungsdiagramm Paketdiagramm Profildiagramm Verhaltensdiagramme Aktivitätsdiagramm Anwendungsfalldiagramm (Use-Cases) Interaktionsübersichtsdiagramm Kommunikationsdiagramm Sequenzdiagramm Zeitverlaufsdiagramm Zustandsdiagramm Object Orientation in C++, July 1,

53 Klassendiagramm Einzelne Klasse Klasse dargestellt durch Rechteck Horizontale Unterteilung in drei Bereiche Oberster Bereich: Klassenname Mittlerer Bereich: Attribute/Variablen Unterer Bereich: Methoden Klassenname + public_vars private_vars + public_methods private_methods Object Orientation in C++, July 1,

54 Syntax der Klassenbeschreibung Name von Klasse/Variablen/Methoden frei wählbar +: public Variable/Methode (optional) -: private Variable/Methode (optional) Für Variablen kann der Typ angegeben werden (nach :) Für Methoden kann der Rückgabewert angegeben werden (nach :) Object Orientation in C++, July 1,

55 Vererbung Darstellung durch Pfeil mit geschlossener Spitze ist ein - Beziehung Pfeil von spezialisierter Klasse zur Vaterklasse Fahrzeug Auto Motorrad Object Orientation in C++, July 1,

56 Assoziation Semantischer Zusammenhang zwischen Klassen Beschreibung der Assoziation neben dem Pfeil Vorlesung liest hört Dozent Student Object Orientation in C++, July 1,

57 Aggregation und Komposition Aggregation (leere Raute): hat ein Komposition (volle Raute): enthält ein Angabe der Anzahl möglich Fahrzeug 1 5 Besitzer Türen Object Orientation in C++, July 1,