8. Object-oriented Programming. June 15, 2010

Size: px

Start display at page:

Download "8. Object-oriented Programming. June 15, 2010"

Gwendolyn Shaw
6 years ago
Views:

1 June 15, 2010 Introduction to C/C++, Tobias Weinzierl page 1 of 41

2 Outline Recapitulation Copy Constructor & Operators Object-oriented Programming Dynamic and Static Polymorphism The Keyword Static The Singleton Pattern Generic Programming Introduction to C/C++, Tobias Weinzierl page 2 of 41

3 8.1. Brain Teaser class S t r i n g { p r i v a t e : / / ain t a 0 terminated s t r i n g char data ; / / length of s t r i n g i n t l e n g t h ; S t r i n g ( ) ; void copyfromotherstring ( const String& s t r i n g ) ; S t r i n g : : S t r i n g ( ) : data ( 0 ), l e n g t h ( 0 ) {} void String : : copyfromotherstring ( const String& s t r i n g ) { data = s t r i n g. data ; l e n g t h = s t r i n g. l e n g t h ; s } Introduction to C/C++, Tobias Weinzierl page 3 of 41

4 8.2. Copy Constructor and Operators C++ generates a couple of default operations for any class/struct to allow you to use these datatypes as you use a built-in datatype. i n t a ( 1 0 ) ; Date mydate ( anotherdate ) ; Sometimes, we have to rewrite these default operations. For the copy constructor, it is very simple. Introduction to C/C++, Tobias Weinzierl page 4 of 41

5 Copy Constructor for a String Class class S t r i n g { p r i v a t e : / / ain t a 0 terminated s t r i n g char data ; / / length of s t r i n g i n t l e n g t h ; S t r i n g ( ) ; S t r i n g ( const S t r i n g& s t r i n g ) ; S t r i n g : : S t r i n g ( ) : data ( 0 ), l e n g t h ( 0 ) {} S t r i n g : : S t r i n g ( const S t r i n g& s t r i n g ) : data ( 0 ), l e n g t h ( s t r i n g. l e n g t h ) { data = new ; f o r ( ) { } } Introduction to C/C++, Tobias Weinzierl page 5 of 41

6 Excursus: C++ Strings Good news: You now know how to write a copy constructor for your personal string class. Bad news: Such a class does already exist. # i n c l u d e <s t r i n g > std : : s t r i n g mystring0 ; std : : s t r i n g mystring1 ( h e l l o world ) ; std : : s t r i n g mystring2 ( mystring1 ) ; std : : s t r i n g mystring3 = h e l l o MPG ; std : : s t r i n g mystring4 = mystring3 ; mystring. length ( ) ; mystring4 += mystring1 ; Introduction to C/C++, Tobias Weinzierl page 6 of 41

7 Default Operations The following operations are generated automatically as public operations if we don t provide our own implementation: Default constructor. Destructor. Copy constructor. However, there s still another pitfall: MyString a ; / / do something with a ; MyString b ( a ) ; / / works MyString c ; c = a ; / / does not work Introduction to C/C++, Tobias Weinzierl page 7 of 41

8 Operators In C++, operators such as +,-,+=,=, are just methods, too. The = operators (assignment operator) is generates automatically, if we don t overwrite it. It then is a bit-wise copy of the object. We can redefine the operators. We now know, what std : : cout << s t u p i d << std : : endl means. Introduction to C/C++, Tobias Weinzierl page 8 of 41

9 Operators Redefined Part I class Vector { / / copy c o n s t r u c t o r Vector ( const Vector& vector ) ; Vector& operator =( const Vector& vector ) ; / / unary operators Vector& operator +=( const Vector& vector ) ; Vector& operator =( const double& value ) ; void tostream ( std : : ostream& out ) const ; / / binary operators Vector& operator +( const Vector& lhs, const Vector& rhs ) ; std : : ostream& operator <<(std : : ostream& out, const Vector& vector ) ; Vector& operator +( const Vector& lhs, const Vector& rhs ) { Vector r e s u l t ( l h s ) ; r e s u l t += rhs ; r e t u r n r e s u l t ; } Introduction to C/C++, Tobias Weinzierl page 9 of 41

10 Operators Redefined Part II class Vector { / / copy c o n s t r u c t o r Vector ( const Vector& vector ) ; Vector& operator =( const Vector& vector ) ; / / unary operators Vector& operator +=( const Vector& vector ) ; Vector& operator =( const double& value ) ; void tostream ( std : : ostream& out ) const ; / / binary operators Vector& operator +( const Vector& lhs, const Vector& rhs ) ; std : : ostream& operator <<(std : : ostream& out, const Vector& vector ) ; std : : ostream& operator <<(std : : ostream& out, const Vector& vector ) { vector. tostream ( out ) ; r e t u r n out ; } Introduction to C/C++, Tobias Weinzierl page 10 of 41

11 8.3. Inheritance Sometimes, someone hands you over an object, but this object lacks some functionality. Now, it is up to you to add this functionality. However, what happens if there is different variants of this functionality? Image you write a researcher management application. Let Employee be a multi-purpose class for bookkeeping. Task: Add a function setsalary() and gettaxespaid. However: There are also people getting a stipend. These guys do not pay taxes. Writing two classes is not a variant, as all employees have to have a getweight() operation. Challenge: If we duplicate the code, then multiple operations have to be rewritten: bool isbmiabovethreshold ( ) { } Introduction to C/C++, Tobias Weinzierl page 11 of 41

12 Challenge Rewritten A Stipend is an extension of Employee. A PostDoc is an extension of Employee, too. Stipdend and PostDoc are two different things. Whatever we do with an Employee, we can do with a Stipend and PostDoc, too. Introduction to C/C++, Tobias Weinzierl page 12 of 41

13 is a Relations getentry() AbstractDB RealDatabase HardcodedTestDB Student has all operations and attributes, Employee has. Every operation expecting an instance of Employee could also be passed an instance of Student. Again, we could image this to be an extension of a cut-n-paste mechanism. Introduction to C/C++, Tobias Weinzierl page 13 of 41

14 is a Relations in Source Code (Part I) class Employee { p r i v a t e : double weight ; ; bool isbmiabovethreshold ( ) ; class Stipend : p u b l i c Employee { p r i v a t e : double getstipdend ( ) const ; Stipend mystipend ; mystipend. isbmiabovethreshold ( ) ; / / t h a t s f i n e Introduction to C/C++, Tobias Weinzierl page 14 of 41

15 is a Relations in Source Code (Part II) class Employee { class Stipend : p u b l i c Employee { void foo ( const Employee& employee ) { } Stipend mystipend ; foo ( mystipend ) ; Introduction to C/C++, Tobias Weinzierl page 15 of 41

16 Object-oriented Programming is-a relations are mapped to inheritance. Object-based programming becomes object-oriented programming due to this inheritance concept. Whenever an object of type A is expected somewhere, we can also pass an object with a subtype of B. This concept is called polymorphism. There s a new visibility mode protected: These attributes and operations behave like private, i.e. they are not visible from outside, but they are visible within subclasses. Introduction to C/C++, Tobias Weinzierl page 16 of 41

17 8.4. virtual Operations class A { void foo ( ) ; class B : p u b l i c A { void foo ( ) ; class C: p u b l i c B { void foo ( ) ; A object1 ; B object2 ; C object3 ; A object4 = new A ( ) ; A object5 = new B ( ) ; B object6 = new C ( ) ; object1. foo ( ) ; object2. foo ( ) ; object3. foo ( ) ; object4 >foo ( ) ; object5 >foo ( ) ; object6 >foo ( ) ; Introduction to C/C++, Tobias Weinzierl page 17 of 41

18 Static Polymorphism class A { void foo ( ) ; class B : p u b l i c A { void foo ( ) ; A object4 = new A ( ) ; object4 >foo ( ) ; C++ implements a static polymorphism by default. It is called static, as the (known) object type determines which operation is to be invoked. There is a variant called dynamic polymorphism, too. Java, C# support only dynamic polymorphism. Introduction to C/C++, Tobias Weinzierl page 18 of 41

19 Dynamic Polymorphism class A { void foo ( ) ; v i r t u a l void bar ( ) ; class B : p u b l i c A { void foo ( ) ; v i r t u a l void bar ( ) ; A object1 = new A ( ) ; B object2 = new B ( ) ; A object3 = new B ( ) ; object1 >foo ( ) ; object2 >foo ( ) ; object3 >foo ( ) ; object1 >bar ( ) ; object2 >bar ( ) ; object3 >bar ( ) ; Introduction to C/C++, Tobias Weinzierl page 19 of 41

20 Dynamic Destructors If you use inheritance, always make your destructor virtual. Introduction to C/C++, Tobias Weinzierl page 20 of 41

21 Finally: Super Constructor class A { A( i n t v a r i a b l e ) ; class B : p u b l i c A { B ( ) ; B : : B ( ) : A( 23 ) { } This is the reason, C++ introduced initialisation lists, and treats both attributes and super types the same way. Please take care of the order: First, you have to call the supertype s constructor, then you have to initialise your attributes in the right order. Introduction to C/C++, Tobias Weinzierl page 21 of 41

22 Excursus: Multiple Inheritance class A { class B { class C: p u b l i c A, B { Multiple inheritance is supported by C++. However, today it is considered to be a bad smell. There s also a concept called virtual inheritance which is also considered to be a bad smell nowadays. Introduction to C/C++, Tobias Weinzierl page 22 of 41

23 Excursus: Private Inheritance class A { class B { class C: p r i v a t e A,B { Private inheritance is supported by C++. Here, the is-a relationship does not hold anymore, i.e. it is a pure implementation inheritance, not a behavioural. However, today it is considered to be a bad smell. I nevertheless find is useful. Introduction to C/C++, Tobias Weinzierl page 23 of 41

24 Abstract Operations class A { class B : p u b l i c A { class C: p u b l i c A { Let B and C be classes that belong together logically. An example: B writes measurements into a database, C plots data to Matlab. However, B and C have to implementation in common. They share solely the signature. Consequently, all operations (in A) have to be virtual. However, it does not make sense to provide any default implementation of an operation in A. Introduction to C/C++, Tobias Weinzierl page 24 of 41

25 Abstract Operations class A { v i r t u a l void foo ( ) = 0; class B : p u b l i c A { v i r t u a l void foo ( ) ; class C: p u b l i c A { v i r t u a l void foo ( ) ; vitual operations can be made abstract. A class with at least one abstract method is an abstract class. We cannot instantiate abstract types. This way, we enforce subclasses to implement them. Classes with solely abstract operations are called interface. Introduction to C/C++, Tobias Weinzierl page 25 of 41

26 8.5. static Variable Lifecycle void foo ( ) { i n t myint ; } void bar ( ) { s t a t i c i n t myint ; } Variables belong to a scope. Whenever we encounter a variable definition, we reserve memory. At the end of the scope, the variable is destroyed (invoke destructor, free memory). Introduction to C/C++, Tobias Weinzierl page 26 of 41

27 Static Variables void foo ( ) { i n t myint ; } void bar ( ) { s t a t i c i n t myint ; } Variables belong to a scope. Whenever we encounter a static variable definition for the first time, we reserve memory. A static variable is freed when the application terminates (invoke destructor, free memory). Introduction to C/C++, Tobias Weinzierl page 27 of 41

28 An Example for Static Variables void bar ( ) { s t a t i c i n t myint = 20; } myint ++; bar ( ) ; / / f i r s t c a l l of bar ( ) ever bar ( ) ; bar ( ) ; Static variables are bind to the application, not to the scope. However, they are still accessible only within the scope. Usuall, (good?) procedural programmers do not use static. Introduction to C/C++, Tobias Weinzierl page 28 of 41

29 Object Variables class A { i n t f i e l d ; void foo ( ) ; void A : : foo ( ) { f i e l d ++; } A instance1, instance2 ; instance1. foo ( ) ; instance2. foo ( ) ; Both instances work on different instantiations of field. Introduction to C/C++, Tobias Weinzierl page 29 of 41

30 Class Variables (Static) class A { s t a t i c i n t f i e l d ; void foo ( ) ; void A : : foo ( ) { f i e l d ++; } A instance1, instance2 ; instance1. foo ( ) ; instance2. foo ( ) ; A : : f i e l d ++; Here, static binds the attribute to the class. It is a class attribute. Depending on the visibility, one can either access the static attribute within any operation of A, or even outside of the class (not recommended as it violates the encapsulation idea). If the field is public, the class acts (from a syntax point of view) similar to a namespace. Introduction to C/C++, Tobias Weinzierl page 30 of 41

31 Example: Instance Counter class A { p r i v a t e : s t a t i c i n t instances ; A ( ) ; void A : : A ( ) { instances ++; } This code keeps track how many instances of A are created. Introduction to C/C++, Tobias Weinzierl page 31 of 41

32 Static Operations class A { void foo ( ) ; s t a t i c void bar ( ) ; void A : : foo ( ) { } void A : : bar ( ) { } We can also declare methods as static. Static methods (class methods) belong to the class, not to an object. Static methods may work on class attributes only. Introduction to C/C++, Tobias Weinzierl page 32 of 41

33 A Factory Method class A { p r i v a t e : i n t a t t r i b u t e ; s t a t i c A createanafromterminal ( ) ; s t a t i c A createanafromterminal ( ) { A r e s u l t ; std : : c i n >> r e s u l t. a t t r i b u t e ; r e t u r n A ; } A mya; mya = A : : createanafromterminal ( ) ; Static methods may manipulate any attribute of the class as they are part of the class. Static methods are called similar to methods wrapped by a namespace. Static methods typically represent operations on sets while methods represent operations on an element of a set. Introduction to C/C++, Tobias Weinzierl page 33 of 41

34 8.6. Design Patterns Design Patterns: Stem from reocurring solutions for certain technical challenges. More complex than idioms. Something different than an algorithm: It describes the technical realisation. Famous book by the gang of four. Standard book by the gang of four. Introduction to C/C++, Tobias Weinzierl page 34 of 41

35 A Singleton / Implements a connection to a database ( big f i l e ) w ith l o t s of m a t e r i a l constants. / class MaterialConstants { We want to ensure that MaterialConstants is created only once throughout the application lifecycle. Here are some hints: MaterialConstants should not have a public (default) constructor. As anyone could need the database, a static getdatabase() operation might be helpful that returns an instance of MaterialConstants. This static operation might hold an instance of MaterialConstants. However, it should not create it each time it is invoked. Introduction to C/C++, Tobias Weinzierl page 35 of 41

36 Singleton Implementation - Part I class MaterialConstants { p r i v a t e : / noone should be able i n s t a n t i a t e the database on h i s own / MaterialConstants ( ) ; / noone should be able to copy a database / MaterialConstants ( const MaterialConstants & ) ; / / noone should be able i n t getentry ( ) const ; void addentry ( ) ; MaterialConstants mydatabase ; / / forbidden / / however, we need something l i k e mydatabase. getentry ( ) ; We could make all the operations static. However, then we don t have control of the open process. Even worse, this won t fit to our fancy new object-oriented paradigm. Introduction to C/C++, Tobias Weinzierl page 36 of 41

37 Singleton Implementation - Part II class MaterialConstants { p r i v a t e : / noone should be able i n s t a n t i a t e the database on h i s own / MaterialConstants ( ) ; / noone should be able to copy a database / MaterialConstants ( const MaterialConstants & ) ; / / noone should be able / Provide access to one s i n g l e database ( s i n g l e t o n ) / s t a t i c MaterialConstants& getdatabase ( ) ; MaterialConstants : : getdatabase ( ). getentry ( ) ; / / f i n e MaterialConstants myconstants = MaterialConstants : : getdatabase ( ) ; / / forbidden Introduction to C/C++, Tobias Weinzierl page 37 of 41

38 Singleton Implementation - Part III class MaterialConstants { p r i v a t e : / Provide access to one s i n g l e database ( s i n g l e t o n ) / s t a t i c MaterialConstants& getdatabase ( ) ; MaterialConstants& MaterialConstants : : getdatabase ( ) { MaterialConstants r e s u l t ; r e t u r n r e s u l t ; } This simple realisation of the static operation works. However, it creates a segmentation fault. Introduction to C/C++, Tobias Weinzierl page 38 of 41

39 Singleton Implementation - Part III class MaterialConstants { p r i v a t e : / Provide access to one s i n g l e database ( s i n g l e t o n ) / s t a t i c MaterialConstants& getdatabase ( ) ; MaterialConstants& MaterialConstants : : getdatabase ( ) { MaterialConstants r e s u l t ; r e t u r n r e s u l t ; } This simple realisation of the static operation works. However, it creates a segmentation fault. If we removed the reference symbol, it would create one instance and one copy per call. That is not what we want. Introduction to C/C++, Tobias Weinzierl page 38 of 41

40 Singleton Implementation - Part IV class MaterialConstants { p r i v a t e : / Provide access to one s i n g l e database ( s i n g l e t o n ) / s t a t i c MaterialConstants& getdatabase ( ) ; MaterialConstants& MaterialConstants : : getdatabase ( ) { s t a t i c MaterialConstants r e s u l t ; r e t u r n r e s u l t ; } Introduction to C/C++, Tobias Weinzierl page 39 of 41

41 A Factory Pattern Study our simple MaterialConstants type. This shall be part of a project where we are promised to get access to the real database by the end of the project. Meanwhile, we have to work with a small number of artificial material constants. Could be switch from one database to another without changing anything in the code using the material database? Introduction to C/C++, Tobias Weinzierl page 40 of 41

42 A Factory Pattern getentry() AbstractDB RealDatabase HardcodedTestDB We define an abstract Database type. It is an interface (see UML diagram). This type is delivered by our singleton, i.e. codes work only with the interface. We implement the interface with a stupid class where we hardcode some material constants (basically a big case statement). Within the static operation, we then decide whether we deliver a real database or our artificial one. Introduction to C/C++, Tobias Weinzierl page 41 of 41

10. Object-oriented Programming. 7. Juli 2011

10. Object-oriented Programming. 7. Juli 2011 7. Juli 2011 Einführung in die Programmierung Introduction to C/C++, Tobias Weinzierl page 1 of 47 Outline Object Case Study Brain Teaser Copy Constructor & Operators Object-oriented Programming, i.e.