13.3 Relationships Among Objects in an Inheritance Hierarchy

Transkript

1 Chapter13 We now continue our study of OOP by explaining and demonstrating polymorphism with inheritance hierarchies. Polymorphism enables you to program in the general rather than program in the specific. In particular, polymorphism enables you to write programs that process objects of classes that are part of the same class hierarchy as if they were all objects of the hierarchy s base class. (OOP çalışmamıza şuradan devam edeceğiz: Inheritance hiyerarşisi ile polymorphism i açıklayacağız, göstereceğiz.) 13.3 Relationships Among Objects in an Inheritance Hierarchy Invoking Base-Class Functions from Derived-Class Objects The example demonstrates three ways to aim base and derived-class pointers at base and derived-class objects. The first two are straightforward we aim a base-class pointer at a base-class object and invoke base class functionality, and we aim a derived-class pointer at a derived-class object and invoke derived-class functionality. ( base ve derived-class object lere, base ve derived-class pointer lar ile ilgili 3 farklı yol gösterilmiştir bu örnekte. İlk ikisi straightforward dır, bunlardan birincisinde base-class object e base class pointer point eder, dolayısıyla base class functionality invoke edilir. Bunlardan ikincisinde ise derived class object e derived class pointer point eder, dolayısıyla derived class functionality invoke edilir. ) Then, we demonstrate the relationship between derived classes and base classes (i.e., the is-a relationship of inheritance) by aiming a base-class pointer at a derived-class object and showing that the base-class functionality is indeed available in the derived-class object. ( üçüncüsünde ise, derived class lar ve base class lar arasındaki ilişki gösterilir, derived class object e base class pointer point eder, dolayısıyla derived class object de base class functionality yi kullanmak mümkündür. ) Recall that each BasePlusCommissionEmployee object is a CommissionEmployee that also has a base salary. (Herbir BasePlusCommissionEmployee object i bir CommissionEmployee object idir. Chapter12 de bunların header file ları da verilmişti.)

2 1 - CommissionEmployee object is created. 2- a pointer to this class is created. 1 - BasePlusCommissionEm ployee object is created. 2 - a pointer to this class is created. Derived class pointer a, derived class object in adresi assign edilir. Bu pointer invoke edilince, derived class-daki print fonksiyonu çağırılır. (Lines ) Base class pointer a, base class object in adresi assign edilir. Bu pointer invoke edilince, base classdaki print fonksiyonu çağırılır.(lines 36-39)

3 Yukarıdaki programın output ı aşağıdaki gibidir: Aiming a Base-Class Pointer at a Derived-Class Object Line 49 then assigns the address of derived-class object basepluscommissionemployee to base-class pointer commissionemployeeptr, which line 53 uses to invoke member function print. This crossover is allowed because an object of a derived class is an object of its base class.

4 ( 49. satırda, base class pointer(commissionemployeeptr) a, derived class object in adresi assign ediliyor. 53. Satırda, member function print() çağırılıyor. Burada çağırılan print() base class ın member function ı olan print dir. Bu crossover a izin verilir, çünkü derived class ın bir object i aynı zamanda base class ın da bir object idir. ) Despite the fact that the base class CommissionEmployee pointer points to a derived class BasePlusCommissionEmployee object, the base class CommissionEmployee s print member function is invoked (rather than BasePlusCommissionEmployee s print function). ( base-class pointer ı, derived class object e point etmesine rağmen, base class ın print() member fonksiyonu çağırılır. ) The output of each print member-function invocation in this program reveals that the invoked functionality depends on the type of the pointer (or reference) used to invoke the function, not the type of the object for which the member function is called. ( Invoke edilen(çağırılan) fonksiyon, pointer ın(veya reference ın) type ına bağlıdır, pointer ın point ettiği object in type ına bağlı değildir. ) In Section , when we introduce virtual functions, we demonstrate that it s possible to invoke the object type s functionality, rather than invoke the handle type s functionality. We ll see that this is crucial to implementing polymorphic behavior the key topic of this chapter. ( Şimdiye kadar öğrendiklerimizle handle type ının functionality sini çağırabiliyoruz bahsettiğimiz gibi. Yani handle type neymiş? Pointer ın type ıymış. Section de virtual fonksiyonları öğrendiğimizde, object type ının functionality sini invoke etmeyi(çağırmayı) öğreneceğiz. Bunu öğrenmek polymorphism fikrini anlamamız için çok önemli bir adım olacak, bu chapter ın ana fikri, en önemli kısmı öğrenilmiş olunacak. ) Aiming Derived-Class Pointers at Base-Class Objects In Section , we assigned the address of a derived-class object to a base-class pointer and explained that the C++ compiler allows this assignment, because a derived-class object is a base-class object. We take the opposite approach in Fig. 13.2, as we aim a derived-class pointer at a base-class object.

5 ( Bir önceki section da ne yapmıştık? Base class pointer a, derived class object in adresini assign etmiştik, ve C++ compiler ın bu assignment a izin verdiğini açıklamıştık, çünkü derived class object in aynı zamanda bir base-class object olduğunu söylemiştik. Aşağıda, Figure 13.2 de, bu yaklaşımın tam tersini uyguladık, yani derived class pointer a, base class object in adresini verdik. ) Lines 8 9 of Fig create a CommissionEmployee object, and line 10 creates a BasePlusCommissionEmployee pointer. ( Figure13.2 de, Satırlarda CommissionEmployee object create edilir. 10 satırda BasePlusCommissionEmployee pointer ı create edilir. ) Line 14 attempts to assign the address of base-class object commissionemployee to derived-class pointer basepluscommissionemployeeptr, but the compiler generates an error. ( 14. Satırda, base class object in adresi, derived class pointer a assign edilir. Ama compiler error generate eder. Neyi neye assign edebilirsin şöyle açıklayayım da aklında kalsın. Pointer ın type ına bakarsın. Pointer ın type ına uygun bir şey assign etmelisin pointer a. Mesela base class pointer olsun. Bu pointer a bir adres i assign edeceğiz ya hani, işte bu adres doğru olmalı, bu adres base class object in adresi de olabilir, derived class object in adresi de. Sonuç da her ikisi de base class ın object idirler hiyerarşide. Ancak derived class pointer a, base class object in adresini veremeyiz. Mesela Mercedes* = CarObject diyemeyiz, çünkü derived class pointer a assign edeceğimiz adres, pointer type ına uygun olmalıdır, diğer bir deyişle is a relationship olmalıdır. CarObject is not Mercedes. Dolayısıyla bu assignment olmaz. ) The compiler prevents this assignment, because a CommissionEmployee is not a BasePlusCommissionEmployee. ( Compiler bu assignment ı engeller, bu assignment a izin vermez. Çünkü CommissionEmployee object i, BasePlusCommissionEmployee object i değildir, yani base class object i, derived class object i değildir. Bunun tersi doğru olduğu için, bir önceki section daki assignment a izin veriliyordu. ) Consider the consequences if the compiler were to allow this assignment. Through a BasePlusCommissionEmployee pointer, we can invoke every BasePlusCommissionEmployee

6 member function, including setbasesalary, for the object to which the pointer points (i.e., the base-class object commissionemployee). ( Compiler eğer bu assignment a izin verseydi, bunun olası sonuçları ne olurdu düşünelim. Derived class pointer ı aracılığıyla, derived class ın tüm member function ları (setbasesalary() fonksiyonu da dahil, ki bu fonksiyon pointer ın point ettiği object için çağırılır.) çağırılabilir. ) However, the CommissionEmployee object does not provide a setbasesalary member function, nor does it provide a basesalary data member to set. This could lead to problems, because member function setbasesalary would assume that there is a basesalary data member to set at its usual location in a BasePlusCommissionEmployee object. This memory does not belong to the CommissionEmployee object, so member function setbasesalary might overwrite other important data in memory, possibly data that belongs to a different object. ( Ancak, CommissionEmployee object, setbasesalary() member function ı provide etmez, basesalary isimli member data da provide etmez hatta. Bu member function ve member data sadece derived class da vardır yani. Bu da problemlere neden olabilir, çünkü setbasesalary member function ı, basesalary isimli bir data member ın varolduğunu assume eder, peki bu data member ın nerede olduğunu assume eder, olağan location ında, BasePlusCommissionEmployee object inde olduğunu assume eder. Böyle bir memory(basesalary), CommissionEmployee object nde yoktur, dolayısıyla setbasesalary isimli member function memory daki önemli dataların üzerine overwrite edebilir, muhtemelen farklı bir object in data sı üzerine overwrite eder.)

7 Derived-Class Member-Function Calls via Base-Class Pointers Off a base-class pointer, the compiler allows us to invoke only baseclass member functions. Thus, if a base-class pointer is aimed at a derivedclass object, and an attempt is made to access a derived-class-only member function, a compilation error will occur. ( base class pointer aracılığıyla, sadece base-class member function ların çağırılmasına izin verir compiler. Dolayısıyla, base class pointer, derived class object e point ederse ve derived-class-only member function a erişilmeye çalışılırsa, compilation error olur. Yani derived class da olup, base class da olmayan bir member function a erişilmeye çalışılırsa eğer, compilation error olur. ) Figure 13.3 shows the consequences of attempting to invoke a derived-class member function off a base-class pointer. Line 14 aims commissionemployeeptr at derived-class object basepluscommissionemployee. Recall from Section that this is allowed, because a BasePlusCommissionEmployee is a CommissionEmployee (in the sense that a

8 BasePlusCommissionEmployee object contains all the functionality of a CommissionEmployee object). Lines invoke base-class member functions getfirstname, getlastname, getsocialsecuritynumber, getgrosssales and getcommissionrate off the base-class pointer. All of these calls are legitimate, because BasePlusCommissionEmployee inherits these member functions from CommissionEmployee. ( Figure 13.3 şunu gösterir : base class pointer aracılığıyla, derived class member function ı invoke etme girişimlerinin sonuçlarını gösterir. 14. Satırda, base class pointer, derived class object e point ediyor. Hatırlayalım, compiler buna izin verir. 18. Ve 22. Satırlarda, base-class pointer aracılığıyla, base-class member function lar çağırılır. Bu call ların hepsi yasaldır, çünkü derived class, tüm bu member function ları base class dan miras alır. ) We know that commissionemployeeptr is aimed at a BasePlusCommissionEmployee object, so in lines we attempt to invoke BasePlusCommissionEmployee member functions getbasesalary and setbasesalary. The compiler generates errors on both of these calls, because they re not made to member functions of base-class CommissionEmployee. ( Base class pointer(commissionemployeeptr) a, derived class object in adresini assign etmiştik. 26. Ve 27. Satırlarda, base-class pointer aracılığıyla derived-class member function lardan ikisini yani getbasesalary ve setbasesalary fonksiyonlarını invoke etme girişiminde bulunuyoruz. Bu function call ların herbirisi için, compiler error generate eder, çünkü invoke edilen function lar(getbasesalary, setbasesalary) CommissionEmployee base class ının member fonksiyonları değildirler. ) The handle can be used to invoke only those functions that are members of that handle s associated class type. (In this case, off a CommissionEmployee *, we can invoke only CommissionEmployee member functions setfirstname, getfirstname, setlastname, getlastname, setsocialsecuritynumber, getsocialsecuritynumber, setgrosssales, getgrosssales, setcommissionrate, getcommissionrate, earnings and print. ( Handle neydi? Pointer dı. Handle sadece kendisinin type ı ile ilişkili class type larının member function larını invoke etmek için kullanılabilir. Bu örnekte, CommissionEmployee *(base class dır bu) sadece şu CommissionEmployee member function larını invoke edebiliriz: setfirstname, getfirstname, setlastname, getlastname,

9 setsocialsecuritynumber, getsocialsecuritynumber, setgrosssales, getgrosssales, setcommissionrate, getcommissionrate, earnings and print. ) The compiler will allow access to derived-class-only members from a base-class pointer that s aimed at a derived-class object if we explicitly cast the base-class pointer to a derived-class pointer this is known as downcasting.

10 ( Eğer şöyle yaparsak, compiler, derived class object e point eden bir base class pointer aracılığıyla derived-class-only member lara erişmemize izin verir : base class pointer ı, bir derived class pointer a explicitly cast edersek, bu işleme downcasting denir. ) As you know, it s possible to aim a base-class pointer at a derived-class object. However, as we demonstrated in Fig. 13.3, a base-class pointer can be used to invoke only the functions declared in the base class. Downcasting allows a derived-class-specific operation on a derived-class object pointed to by a base-class pointer. After a downcast, the program can invoke derived-class functions that are not in the base class. Downcasting is a potentially dangerous operation. Section 13.8 demonstrates how to safely use downcasting. ( Bildiğiniz gibi, base class pointer ın, derived class pointer a point etmesi mümkündür. Ancak, Figure 13.3 de de gösterildiği gibi, bir base-class pointer sadece baseclass da declare edilmiş olan fonksiyonları invoke etmek için kullanılır. Downcasting ise şuna izin verir : base-class pointer ın point ettiği bir derived-class object de, derived-class-specific operation gerçekleştirilmesine izin verir. Downcast yapıldıktan sonra, program, base-class da olmayan derived-class fonksiyonlarını invoke edebilir. Downcasting yapmak tehlikeli bir iştir. Section 13.8 de güvenli bir şekilde nasıl downcast yapılabileceğini öğreneceğiz. ) Software Engineering Observation 13.3 If the address of a derived-class object has been assigned to a pointer of one of its direct or indirect base classes, it s acceptable to cast that base-class pointer back to a pointer of the derived-class type. In fact, this must be done to send that derived-class object messages that do not appear in the base class. ( Bir derived class object in adresi, bu class ın direct veya indirect base class larından birine pointer a assign edilirse eğer, bu base class pointer ı derived-class type ına cast etmek uygundur. Aslında, base-class da olmayan derived-class'da olan fonksiyonlarını çağırmak için bu yapılmak zorundadır. ) Virtual Functions In Section , we aimed a base-class CommissionEmployee pointer at a derivedclass BasePlusCommissionEmployee object, then invoked member function print through that pointer. Recall that the type of the handle determined which class s functionality to invoke section'da base class pointer'ı derived class object'e point ettirmiştik. Sonra bu pointer aracılığıyla print member fonksiyonunu invoke etmiştik. Hatırlayalım, hangi class'ın fonksiyonunun invoke edileceğini, handle(pointer) type belirliyordu.

11 In that case, the CommissionEmployee pointer invoked the CommissionEmployee member function print on the BasePlusCommissionEmployee object, even though the pointer was aimed at a BasePlusCommissionEmployee object that has its own custom print function. ( Bu durumda, CommissionEmployee(base class) pointer, CommissionEmployee(base class) class'ının member function'ı olan print()'i, BasePlusCommissionEmployee(derived class) object'i üzerinde çağırır, pointer'ın point ettiği BasePlusCommissionEmployee object'inin kendi print fonksiyonu olmasına rağmen, bu print fonksiyonu çağırılmaz. ) Software Engineering Observation 13.4 With virtual functions, the type of the object, not the type of the handle used to invoke the member function, determines which version of a virtual function to invoke. ( virtual fonksiyonlar kullanırsak, hangi virtual function versiyonunun invoke edileceğini, handle'ın type değil, object'in type'ı belirler. ) First, we consider why virtual functions are useful. Suppose that shape classes such as Circle, Triangle, Rectangle and Square are all derived from base class Shape. Önce virtual fonksiyonların neden yararlı olduklarını tartışalım. Circle class'ından şu class'ların derive ettiğini(türediğini) düşünelim : Circle, Triangle, Rectangle and Square. Each of these classes might be endowed with the ability to draw itself via a member function draw. Although each class has its own draw function, the function for each shape is quite different. ( Bu class'ların herbiri kendilerini çizecek draw fonksiyonuna sahiptirler. ) In a program that draws a set of shapes, it would be useful to be able to treat all the shapes generically as objects of the base class Shape. ( Birçok shape çizen bir program düşünelim. Tüm shape'leri, base class Shape'in object'leri gibi düşünmek yararlıdır. ) Then, to draw any shape, we could simply use a base-class Shape pointer to invoke function draw and let the program determine dynamically (i.e., at runtime) which derivedclass draw function to use, based on the type of the object to which the base-class Shape pointer points at any given time.

12 ( Sonra, herhangi bir shape çizmek için, base-class(shape) pointer kullanabiliriz. Bu pointer'a hangi derived class type'ındaki object'in adresi assign edilirse, o derived class'ın draw fonksiyonu invoke edilir(çağırılır). Hangi derived class'ın draw fonksiyonunun çağırılacağına run-time'da karar verir programımız. Diğer bir deyişle, dynamically belirlenir hangi draw fonksiyonunun çağırılacağı. ) To enable this behavior, we declare draw in the base class as a virtual function, and we override draw in each of the derived classes to draw the appropriate shape. From an implementation perspective, overriding a function is no different than redefining one (which is the approach we ve been using until now). ( Bu behaviour'u enable etmek için, base-class'daki draw fonksiyonunu virtaul fonksiyon olarak declare ederiz. Ve herbir derived class'daki draw fonksiyonunu override ederiz. ) An overridden function in a derived class has the same signature and return type (i.e., prototype) as the function it overrides in its base class. ( Derived class'daki overridden function, base-class'daki override edilen function ile aynı signature ve return type'a sahip olmalıdır. ) If we do not declare the base-class function as virtual, we can redefine that function. By contrast, if we declare the base-class function as virtual, we can override that function to enable polymorphic behavior. We declare a virtual function by preceding the function s prototype with the keyword virtual in the base class. ( Base class function'ı virtual olarak declare etmezsek eğer, bu function'ı redefine edebiliriz. Ancak, base class function'ı virtual olarak declare edersek eğer, polymorphic behaviour'ı enable etmek için bu function'ı override edebiliriz. Virtual function nasıl declare edilir, base class'daki function'ın prototype'ının önüne virtual keyword'ünü getirerek. ) For example, virtual void draw() const; would appear in base class Shape. The preceding prototype declares that function draw is a virtual function that takes no arguments and returns nothing. This function is declared const

13 because a draw function typically would not make changes to the Shape object on which it s invoked virtual functions do not have to be const functions. (Örneğin base class Shape'deki virtual draw fonksiyonu böyle declare edilir. Bu fonksiyon, const olarak declare edilmiştir, çünkü draw fonksiyonu, içerisinden invoke edildiği object'i değiştirmez, modify etmez. Ancak virtual fonksiyonlar const function olmak zorunda değildir. ) Software Engineering Observation 13.5 Once a function is declared virtual, it remains virtual all the way down the inheritance hierarchy from that point, even if that function is not explicitly declared virtual when derived class overrides it. ( Bir function virtual olarak declare edilince, bu noktadan itibaren inheritance hiyerarşisinde aşağıya doğru virtual'dır. derived class, base class'daki virtual fonksiyonu override ederken explicity virtual declare edilmese bile. ) Good Programming Practice 13.1 Even though certain functions are implicitly virtual because of a declaration made higher in the class hierarchy, explicitly declare these functions virtual at every level of the class hierarchy to promote program clarity. ( Bazı fonksiyonlar implicitly virtual'durlar, çünkü class hiyerarşisinde üstlerde(base class'larda) virtual declaration explicitly yapılmıştır. Ancak, program'ın daha clear olması için, bu fonksiyonlar tüm aşamalarda explicit bir şekilde virtual keyword ile declare edilmelidirler. Yani base class'da virtual draw fonksiyonu var diyelim. Bu class'ın derived class'larında draw methodu yazarsak, bu methodun signature'ının başına virtual keywordünü koymasak bile bu fonksiyon virtual'dır. Ancak bu fonksiyonların başına virtual keyword'ünü koymak iyi bir alışkanlık olacaktır, daha clear,temiz,net bir program olacaktır, kodumuzu okuyanlar kolaylıkla takip edebilecektir. ) Error-Prevention Tip 13.1 When you browse a class hierarchy to locate a class to reuse, it s possible that a function in that class will exhibit virtual function behavior even though it isn t explicitly declared virtual. This happens when the class inherits a virtual function from its base class, and it can lead to subtle logic errors. Such errors can be avoided by explicitly declaring all virtual functions virtual throughout the inheritance hierarchy.

14 ( Mesela, derived class'da draw methodunu tanımlarken şuna dikkat et. Bu class'ın base class'larında draw methodu virtual olarak declare edilmiş olabilir, dolayısıyla bizim class'ımızdaki draw methodu da implicit bir şekilde virtual'dır. Dolayısıyla base class'daki draw donksiyonunun virtual olduğunu bilmezsek, problem olabilir. Bu yüzden class'ımızın miras aldığı fonksiyonları bilmeli ve buna göre hareket etmeliyiz. Bu gibi error'ları önlemek için class hiyerarşisindeki tüm virtual fonksiyonları explicit bir şekilde virtual keyword'ü ile declare etmeliyiz. ) Software Engineering Observation 13.6 When a derived class chooses not to override a virtual function from its base class, the derived class simply inherits its base class s virtual function implementation. ( Derived class, base class'daki bir virtual fonksiyon'u override etmek zorunda değildir. Override etmeyebilir, bu durumda base class'ın virtual function implementation'ı derived class'a miras yoluyla aktarılır. ) If a program invokes a virtual function through a base-class pointer to a derivedclass object (e.g., shapeptr->draw()) or a base-class reference to a derived-class object (e.g., shaperef.draw()), the program will choose the correct derived-class draw function dynamically (i.e., at execution time) based on the object type not the pointer or reference type. Choosing the appropriate function to call at execution time (rather than at compile time) is known as dynamic binding or late binding. ( derived class object'e point eden bir base-class pointer aracılığıyla, virtual function invoke edilirse, veya derived class object'e refer eden bir base-class reference aracılığıyla virtual function invoke edilirse, program pointer veya reference type'ına göre değil, object'in type'ına göre doğru derived class'ın draw fonksiyonunu dynamically seçer. Execute edilecek fonksiyonun, execution time'da belirlenmesi işlemine dynamic binding veya late binding denir. ) When a virtual function is called by referencing a specific object by name and using the dot member-selection operator (e.g., squareobject.draw()), the function invocation is resolved at compile time (this is called static binding) and the virtual function that s called is the one defined for (or inherited by) the class of that particular object this is not polymorphic behavior.?????????*

15 ( Specific bir object'in ismi ve dot operator kullanılarak, bir virtual function reference edilerek çağırıldığında(mesela squareobject.draw(), hangi fonksiyonun invoke edileceğine compile time'da karar verilir. Buna da static binding denir. Invoke edilen virtual function, specific object'imizin veya bu objecrt'imizin fonksiyonudur, veya bu object'imizin derived class'larının bir fonksiyonudur. ) Thus, dynamic binding with virtual functions occurs only off pointer (and, as we ll soon see, reference) handles. ( Virtual fonksiyonlar kullanırken gerçekleşen dynamic binding sadece pointer handle'lar ile mümkündür. Reference handle'lar ile de mümkündür, bunu da yakında göreceğiz. ) Now let s see how virtual functions can enable polymorphic behavior in our employee hierarchy. Figures are the headers for classes CommissionEmployee and BasePlusCommissionEmployee, respectively. The only new features in these files is that we specify each class s earnings and print member functions as virtual (lines of Fig and lines of Fig. 13.5). Because functions earnings and print are virtual in class CommissionEmployee, class BasePlusCommissionEmployee s earnings and print functions override class CommissionEmployee s. ( Employee class hiyerarşimizde, polymorphic behaviour'ı nasıl kullandığımızı öğrenelim şimdi de. Earnings ve print member function'ları virtual olarak declare edilmiştir. Bu file'lardaki tek değişen şey şu olmuştur: herbir class'ın earnings ve print member function'ları virtual olarak declare edilmiştir. Base class(commissionemployee)'daki earnings ve print member function'ları virtual olarak declare edilmiştir, dolayısıyla derived class(basepluscommissionemployee)'daki earnings ve print member function'ları, base class'ın correspoinding member function'larını override eder. ) Now, if we aim a base-class CommissionEmployee pointer at a derived-class BasePlusCommissionEmployee object, and the program uses that pointer to call either function earnings or print, the BasePlusCommissionEmployee object s corresponding function will be invoked. There were no changes to the member-function implementations of classes CommissionEmployee and BasePlusCommissionEmployee, so we reuse the versions of Figs and

16 ( base-class pointer, derived class object'e point ediyor, program bu pointer aracılığıyla earning veya print member function'larını invoke etmeye çalışınca, derived class'ın earning ve print member function'ları invoke ediliyor. 12. chapter'daki Figure ve 12.15'deki class'ların member implementation'ları değişiklik yapılmadan aşağıda gösterilmiştir: )

17 We modified Fig to create the program of Fig Lines demonstrate again that a CommissionEmployee pointer aimed at a CommissionEmployee object can be used to invoke CommissionEmployee functionality, and a BasePlusCommissionEmployee pointer aimed at a BasePlusCommissionEmployee object can be used to invoke BasePlusCommissionEmployee functionality. Line 54 aims the base-class pointer commissionemployeeptr at derived-class object basepluscommissionemployee. Note that when line 61 invokes member function print off the base-class pointer, the derived-class BasePlusCommissionEmployee s print member function is invoked, so line 61 outputs different text than line 53 does in Fig (when member function print was not declared virtual). We see that declaring a member function virtual causes the program to dynamically determine which function to invoke based on the type of object to which the handle points, rather than on the type of the handle. ( 54. Satırda, base class pointer, derived class object e point(aim) ediyor. 61. Satırda, base-class pointer aracılığıyla, print member functin invoke edilince, derived class ın print() member function ı invoke edilir, dolayısıyla bu programdaki 61. Satır ve Figure 13.1 deki 53. Satır farklı output lar verir. Bu program ve Figure13.1 deki program arasındaki fark şudur: bu programda print member function virtual olarak declare edilmiştir. Yani şunu görmüş oluruz programı çalıştırınca: Bir member function ı virtual olarak declare edersek, program handle ın type ına göre değil, handle ın point ettiği object in type ına göre hangi function ı çağıracağına dynamically karar verir. )

18 Note again that when commissionemployeeptr points to a CommissionEmployee object (line 40), class CommissionEmployee s print function is invoked, and when CommissionEmployeePtr points to a BasePlusCommissionEmployee object, class BasePlusCommissionEmployee s print function is invoked. ( CommissionEmployeePtr(base class), CommissionEmployee(base class) object e point ederse, CommissionEmployee nin print function ı invoke edilir. CommissionEmployeePtr(base class), BasePlusCommissionEmployee(base class) object e point ederse, BasePlusCommissionEmployee nin print function ı invoke edilir. ) Thus, the same message print, in this case sent (off a base-class pointer) to a variety of objects related by inheritance to that base class, takes on many forms this is polymorphic behavior. ( Dolayısıyla, farklı derived class lara point eden base-class pointer aracılığıyla invoke edilen print fonksiyonu farklı biçimler(formlar) alabilir. Bu da polymorphic behaviour olarak bilinir. )

19 Static binding in nasıl gerçekleştiğini inceleyelim.

20 13.4 Type Fields and switch Statements One way to determine the type of an object is to use a switch statement to check the value of a field in the object. This allows us to distinguish among object types, then invoke an appropriate action for a particular object. For example, in a hierarchy of shapes in which each shape object has a shapetype attribute, a switch statement could check the object s shapetype to determine which print function to call. ( Bir object in type ını saptamak için switch statement kullanılarak object deki bir field ın değeri check edilir. Bu sayede object type larını birbirinden ayırt edebiliriz, ve belli bir object için uygun olan bir action ı gerçekleştirebiliriz. Örneğin, herbir object in shapetype isimli bir attribute e sahip olduğu bir shape hiyerarşisinde, switch statement kullanılabilir,

21 hangi print function ın çağırılacağına object in shapetype attribute check edilerek karar verilebilir. ) Using switch logic exposes programs to a variety of potential problems. For example, you might forget to include a type test when one is warranted, or might forget to test all possible cases in a switch statement. When modifying a switch-based system by adding new types, you might forget to insert the new cases in all relevant switch statements. Every addition or deletion of a class requires the modification of every switch statement in the system; tracking these statements down can be time consuming and error prone. ( switch kullanmak şu olası problemlere yol açabilir: Örneğin, bazı type ları check edip, bazı type ları check etmeyi unutursak problem olur. Örneğin, yeni bir type implement ettikten sonra switch-based system i modify ederken, yeni case i tüm ilgili switch statement larına eklemeyi unutursak problem olur. Bir class ın eklenmesi veya silinmesi, sistemdeki tüm switch statement larını modify etmeyi gerektirir, bu statement ları takip etmek zaman alıcıdır ve hata yapma olasılığı yüksektir. ) Software Engineering Observation 13.7 Polymorphic programming can eliminate the need for switch logic. By using the polymorphism mechanism to perform the equivalent logic, you can avoid the kinds of errors typically associated with switch logic. ( Polymorphic programming switch logic e olan ihtiyacı ortadan kaldırır. Polymorphism mekanizması kullanarak, aynı mantığı uygulayabiliriz, ayrıca switchlogic deki muhtemel error ları da önlemiş oluruz. ) Software Engineering Observation 13.8 An interesting consequence of using polymorphism is that programs take on a simplified appearance. They contain less branching logic and simpler sequential code. This simplification facilitates testing, debugging and program maintenance. ( Polymorphism kullanmanın ilginç bir sonucu ise şudur : programlar daha sadeleştirilmiş, daha az komplex görünür. ) 13.5 Abstract Classes and Pure virtual Functions When we think of a class as a type, we assume that programs will create objects of that type. However, there are cases in which it s useful to define classes from which you never intend to instantiate any objects. Such classes are called abstract classes. Because these classes normally are used as base classes in inheritance hierarchies, we refer to them as abstract base classes. These classes cannot be used to instantiate objects, because, as we ll soon see, abstract classes are incomplete derived classes must define the missing pieces before objects of these classes can be instantiated. We build programs with abstract classes in Section 13.6.

22 ( Bir class ı bir type gibi düşünürsek, programların bu type dan bir object create edeceklerini assume ederiz. Ancak, kendisinden object create etmeyeceğimiz bazı class lar define etmek de isteyebiliriz bazen. Bu class lara abstract classes denir. Bu class lar inheritance hiyerarşisinde genelde base class olarak kullanıldıkları için, bu class lara abstract base classes da denir. Bu class lardan object instantiate edilemez(object create edilemez), çünkü abstract class lar incomplete dirler(tamamlanmamıştırlar),derived class lar bu eksik kısımları tamamlamalıdırlar ki bu class lardan object instantiate edilebilsin. ) Classes that can be used to instantiate objects are called concrete classes. Such classes define or inherit implementations for every member function they declare. We could have an abstract base class TwoDimensionalShape and derive such concrete classes as Square, Circle and Triangle. ( Kendisinden object create edilebilen class lara concrete class denir. Bu class lardaki declare edilen tüm fonksiyonlar define edilmiştirler, veya implementation ları miras almıştırlar. Örneğin, TwoDimensionalShape isimli bir abstract base class ımız olsun. Squrare, Circle ve Triangle isimli concrete class larımız olsun. ) Abstract base classes are too generic to define real objects; we need to be more specific before we can think of instantiating objects. -optional reading- For example, if someone tells you to draw the two-dimensional shape, what shape would you draw? Concrete classes provide the specifics that make it reasonable to instantiate objects. An inheritance hierarchy does not need to contain any abstract classes, but many object-oriented systems have class hierarchies headed by abstract base classes. In some cases, abstract classes constitute the top few levels of the hierarchy. A good example of this is the shape hierarchy in Fig. 12.3, which begins with abstract base class Shape. On the next level of the hierarchy we have two more abstract base classes TwoDimensionalShape and ThreeDimensionalShape. The next level of the hierarchy defines concrete classes for two-dimensional shapes (namely, Circle, Square and Triangle) and for three-dimensional shapes (namely, Sphere, Cube and Tetrahedron). -- Pure Virtual Functions A class is made abstract by declaring one or more of its virtual functions to be pure. A pure virtual function is specified by placing = 0 in its declaration, as in virtual void draw() const = 0; // pure virtual function The = 0 is a pure specifier. Pure virtual functions do not provide implementations. Every concrete derived class must override all base-class pure virtual functions with concrete implementations of those functions.

23 ( Bir class ın içerdiği virtual function ların biri pure yapılırsa, bu class abstract olur. Virtual bir function declare edilirken, =0 ile specify edersek, bu function, pure virtual function olur. Pure virtual function lar implement edilmemiştirler. Abstract base class dan concrete derived class create etmek istiyorsak, base-class daki pure virtual function ları derived class da override etmek zorundayız. ) The difference between a virtual function and a pure virtual function is that a virtual function has an implementation and gives the derived class the option of overriding the function; by contrast, a pure virtual function does not provide an implementation and requires the derived class to override the function for that derived class to be concrete; otherwise the derived class remains abstract. ( virtual function ve pure virtual function arasındaki fark nedir? Virtual function implement edilmiştir, dolayısıyla derived class bu function ı override etme ve etmeme seçeneğine sahiptir. Ancak pure virtual function, implementation a sahip değildir, object create edilebilen bir class(concrete class) ortaya çıkarmak için, base class daki pure virtual function override edilmek zorundadır(yani base class da implement edilmemiş, derived class da implement edilmek zorunda), aksi takdirde derived class da abstract class olarak kalır. ) Pure virtual functions are used when it does not make sense for the base class to have an implementation of a function, but you want all concrete derived classes to implement the function. Returning to our earlier example of space objects, it does not make sense for the base class SpaceObject to have an implementation for function draw (as there is no way to draw a generic space object without having more information about what type of space object is being drawn). An example of a function that would be defined as virtual (and not pure virtual) would be one that returns a name for the object. We can name a generic SpaceObject (for instance, as "space object"), so a default implementation for this function can be provided, and the function does not need to be pure virtual. The function is still declared virtual, however, because it s expected that derived classes will override this function to provide more specific names for the derived-class objects. ( Peki bir function ı neden pure virtual yapmak isteyelim? Veya neden virtual yapmak isteyelim? Base class daki bir fonksiyonu implement etmek mantıksız olacaktır mesela, pure virtual function kullanırız dolayısıyla, derived class larda da bu function ı implement etmek isteriz. Örneğin SpaceObject class ındaki draw fonksiyonunu implement etmek mantıksız olacaktır, çünkü şekli belli değil, ancak bu class ın derived class larında draw function ı implement etmek gerekecektir. Dolayısıyla SpaceObject class ındaki draw() fonksiyonu pure virtual olmalıdır, concrete derived class lar bunu overide etmelidirler. Mesela SpaceObject in ismini return eden fonksiyonu düşünelim. Her SpaceObject in bir ismi olacaktır mutlaka, base class da olsa, derived class da olsa. Dolayısıyla, pure virtual function değil, virtual function olacaktır bu. Ancak bu fonksiyon da gene virtual olarak declare edilmiştir, çünkü derived class object ler daha specific isimlere sahip oldukları için, derived class ların bu function ı overide etmeleri umulur. )

24 Software Engineering Observation 13.9 An abstract class defines a common public interface for the various classes in a class hierarchy. An abstract class contains one or more pure virtual functions that concrete derived classes must override. ( Bir abstract class, bir veya daha fazla pure virtual function içerir, concrete derived class'lar bu function'ları override etmek zorundadırlar. ) Common Programming Error 13.1 Failure to override a pure virtual function in a derived class makes that class abstract. Attempting to instantiate an object of an abstract class causes a compilation error. (derived class'da eğer pure virtual function'ı override etmezsek, bu class abstract olarak kalır. Abstract class'dan obje t instantiate etmeye çalışmak compilation error'a neden olur.) Software Engineering Observation An abstract class has at least one pure virtual function. An abstract class also can have data members and concrete functions (including constructors and destructors), which are subject to the normal rules of inheritance by derived classes. Although we cannot instantiate objects of an abstract base class, we can use the abstract base class to declare pointers and references that can refer to objects of any concrete classes derived from the abstract class. Programs typically use such pointers and references to manipulate derived-class objects polymorphically. ( Abstract base class type'ındaki bir pointer veya reference, bu class'dan derive etmiş bir concrete derived class'ın object'ine point edebilir. Derived class object'leri polymorphically manipulate etmek için, bu gibi pointer'lar ve reference'lar kullanılabilir. ) Device Drivers and Polymorphism An object-oriented operating system might use an abstract base class to provide an interface appropriate for all device drivers. Then, through inheritance from that abstract base class, derived classes are formed that all operate similarly. The capabilities (i.e., the public functions) offered by the device drivers are provided as pure virtual functions in the abstract base class. The implementations of these pure virtual functions are provided in the derived classes that correspond to the specific types of device drivers. This architecture also allows new devices to be added to a system easily, even after the operating system has been defined. The user can just plug in the device and install its new device driver. The operating system talks to this new device through its device driver, which has the same public member functions as all other device drivers - those defined in the device driver abstract base class. Object Oriented bir OS, tüm device driver'lar için uygun bir interface sağlamak amacıyla, abstract base class kullanır. Sonra inheritance aracılığıyla, bu abstract base class'dan derive eden class'lar da benzer şekilde çalışır. Device driver'lar tarafından sağlanan capability'ler, abstract base class'da pure virtual function'dırlar. Bu pure virtual function'ların implementation'ları derived class'larda sağlanır. Bu mimari sisteme yeni device'ların da

25 kolaylıkla eklenmesini sağlar. Kullanıcı sadece device'ı bağlar, ve yeni device driver'ı kolaylıkla install eder. Operating system bu yeni device ile, yüklenmiş olan device driver aracılığıyla konuşur. Bu device driver da diğer device driverlar ile aynı public member function'lara sahiptir, abstract base class'daki public member function'lar ile aynıdır. Iterators and Polymorphism It s common in object-oriented programming to define an iterator class that can traverse all the objects in a container (such as an array). For example, a program can print a list of objects in a vector by creating an iterator object, then using the iterator to obtain the next element of the list each time the iterator is called. ( Bir container(mesela array)'daki tüm object'leri traverse edebilecek bir iterator class define etmek oop'da sıklıkla yapılır. Örneğin, bir program, bir vector'deki object'lerin listesini print etmek isteyebilir. Bunun için bir iterator object create edip, bu iterator object'in her çağırılışında listedeki bir sonraki eleman obtain edilir(elde edilir). ) Iterators often are used in polymorphic programming to traverse an array or a linked list of pointers to objects from various levels of a hierarchy. The pointers in such a list are all base-class pointers. (Chapter 22, Standard Template Library (STL), presents a thorough treatment of iterators.) ( Polymorphic programlama'da iterator'lar şunlar için kullanılabilir : hiyerarşide farklı level'lerdeki object'lere pointer'ları içeren linked list veya array'leri traverse etmek için. Böyle bir listenin elemanları olan pointer'lar, base-class pointer'larıdır. ) A list of pointers to objects of the base class TwoDimensionalShape could contain pointers to objects of the classes Square, Circle, Triangle and so on. Using polymorphism to send a draw message, off a TwoDimensionalShape * pointer, to each object in the list would draw them correctly on the screen. ( Base class TwoDimensionalShape'in objectlerine pointer'ları içeren bir list, derived class'ların object'lerine pointer da içerebilir. Nasıl yani? ) 13.6 Case Study: Payroll System Using Polymorphism A company pays its employees weekly. The employees are of three types: Salaried employees : are paid a fixed weekly salary regardless of the number of hours worked, Commission employees : are paid a percentage of their sales, and Base-salary-plus-commission-employees : receive a base salary plus a percentage of their sales. For the current pay period, the company has decided to reward base-salary-pluscommission-employees by adding 10 percent to their base salaries. The company wants to implement a C++ program that performs its payroll calculations polymorphically. ( Bir şirket, çalışanlarının maaşlarını haftalık olarak ödüyor. 3 çeşit çalışan var :

26 Salaried employees : Bu çalışanlara sabit bir maaş ödenir. Çalıştıkları saat miktarına bakılmaksızın, maaşları sabittir. Commission employees : Bu çalışanlara, yaptıkları satışın belirli bir yüzdesi ödenir. Base-salary-plus-commission-employees: Sabit bir maaş + Satışın belirli bir yüzdesi. Şirket, Base-salary-plus-commission-employees type'ındaki çalışanları, sabit maaş kısmına yüzde 10 zam yaparak ödüllendirmeye karar veriyor. Şirket maaş hesaplamalarını polymorphically yapan bir C++ programı implement etmek istiyor. ) Aşağıdaki gibi bir class hieararchy inşaa ederiz. The abstract class name Employee is italicized, as per the convention of the UML. Abstract base class Employee declares the interface to the hierarchy that is, the set of member functions that a program can invoke on all Employee objects. Each employee, regardless of the way his or her earnings are calculated, has a first name, a last name and a social security number, so private data members firstname, lastname and socialsecuritynumber appear in abstract base class Employee. ( Tüm Employee object'lerinde invoke edilebilecek member function'lar, abstract base class Employee içinde declare edilir. BU class hiyerarşinin interface'ini declare eder. Çalışan type'ına bakılmaksızın, tüm çalışanlar şu data member'lara sahiptir : first name, a last name, a social security number. Dolayısıyla bu private data member'lar abstract base class Employee'de declare edilirler. ) Software Engineering Observation optional reading- A derived class can inherit interface and/or implementation from a base class. Hierarchies designed for implementation inheritance tend to have their functionality high in the hierarchy - each new derived class inherits one or more member functions that were

27 defined in a base class, and the derived class uses the base-class definitions. Hierarchies designed for interface inheritance tend to have their functionality lower in the hierarchy - a base class specifies one or more functions that should be defined for each class in the hierarchy (i.e., they have the same prototype), but the individual derived classes provide their own implementations of the function(s). -- The following sections implement the Employee class hierarchy. The first five each implement one of the abstract or concrete classes. The last section implements a test program that builds objects of all these classes and processes the objects polymorphically Creating Abstract Base Class Employee Class Employee provides functions earnings and print, in addition to various get and set functions that manipulate Employee s data members. An earnings function certainly applies generically to all employees, but each earnings calculation depends on the employee s class. So we declare earnings as pure virtual in base class Employee because a default implementation does not make sense for that function - there is not enough information to determine what amount earnings should return. Each derived class overrides earnings with an appropriate implementation. To calculate an employee s earnings, the program assigns the address of an employee s object to a base class Employee pointer, then invokes the earnings function on that object. ( Employee isimli abstract base class ımızı implement edelim. Earnings isimli function tüm employee lerde invoke edilebilir olmalıdır, ancak herbir farklı employee class için, farklı bir earning hesaplaması yapılmalıdır. Bu function, base class Employee de pure virtual olarak declare edilmelidir. Çünkü bu function için default implementation olması anlamsızdır. ) We maintain a vector of Employee pointers, each of which points to an Employee object. Of course, there cannot be Employee objects, because Employee is an abstract class because of inheritance, however, all objects of all derived classes of Employee may nevertheless be thought of as Employee objects. The program iterates through the vector and calls function earnings for each Employee object. C++ processes these function calls polymorphically. Including earnings as a pure virtual function in Employee forces every direct derived class of Employee that wishes to be a concrete class to override earnings. ( Employee pointer larından oluşan bir sağlıyoruz. Bu pointer lardan herbiri bir Employee object e point ediyor. Tabi Employee object e point ediyor derken şunu kastediyoruz aslında: Employee object var olamaz, Employee class ından object create edilemez. Çünkü Employee abstract bir class dır. Ama Employee class ının derived class larının object leri Employee object ler gibi düşünülebilir. Yani Employee pointer ları, Employee object lerine point ediyor derken, kastettiğimiz Employee object bu şekildedir. ) Function print in class Employee displays the first name, last name and social security number of the employee. As we ll see, each derived class of Employee overrides function print to output the employee s type (e.g., "salaried employee:") followed by the rest of