Merhaba sevgili yazılımperver dostlarım bugün sizler ile birlikte OOP’nin temel bileşenlerinden biri olan polimorfizme göz atacağız. Bu yazı ile birlikte aşağıdaki sorulara yanıt bulacağız. Kavramları olabilidiğince sade bir şekilde aktardıktan sonra bunları C++ da nasıl kullanıldığına bakıp, yine bu konu ile ilintili olduğunu düşündüğüm noktalara da değinip, konuyu kapatmayı planlıyorum açıkçası. Öncelikle sorularımıza bakalım:
- Polimorfizm (“Polymorphism”) nedir ve nesne yönelimli yazılım geliştirme yaklaşımdaki yeri nedir?
- Çeşitleri nelerdir? C++ da nasıl kullanılmaktadır?
- C++’da sanal tabloları (“vTables”) kullanımı nedir?
İçerik
Polimorfizm (“Polymorphism”) nedir ve nesne yönelimli yazılım geliştirmedeki yeri nedir?
Evet, ilk olarak polimorfizm nedir sorusunun cevabına bakalım isterseniz. Wikipedia’dan baktığımızda kısaca bir türün, başka bir tür gibi davranabilme ve bu tür gibi kullanabilme özelliği olarak ifade edilmiş. Kelimenin kendisine bakacak olursak “Polymorphism” kelimesi aslında “poly” ve “morphism” kelimelerinden bir araya gelmiştir. Bunlarda ilki çokluk ve ikincisi de form anlamına gelir. İlk olarak 1967 yıllarında Christopher Strachey denen kişi tarafından ortaya atılmış ve sonrasında ise Hindley ve Milner tarafından geliştirilmiştir.
Nesne yönelimli programlamada ise, bu özellik bir nesnenin, tek bir arayüze dayanmasına ve aynı metod ismine sahip olmasına rağmen farklı şekilde davranabilmesini ifade eder. C++ açısından bakacak olursak (ki buna ilerleyen başlıklarda daha detaylı bakacağız), bir sınıfın üye fonksiyonu çağırdığımızda, ilgili nesnenin tipine göre, farklı fonksiyonların çağrılabilmesi şeklinde gerçeklenmektedir. Peki bu nasıl olmakta? E bu kadar açıklama yeter hemen basit bir kod parçası ile duruma müdahale edelim 🙂 Bunu da hayvanlar alemi üzerinden yapalım.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 |
#include <iostream> #include <string> #include <vector> #include <memory> using namespace std; class Animal { private: const string mName; public: Animal(const string& mName) : mName(mName) {} string name() const { return mName; } virtual string speak() const { return "Ben kimim?"; }; }; class Cat: public Animal { public: Cat(const string& mName) : Animal(mName) {} virtual string speak() const override{ return "Miyav!"; } }; class Dog: public Animal { public: Dog(const string& mName) : Animal(mName) {} virtual string speak() const override{ return "Hav! Hav!"; } }; void checkAnimals(const auto& listOfAnimals) { for(const auto animal : listOfAnimals) { cout << animal->name() << " " << animal->speak() << " diye seslendi!" << endl; } } int main() { // Heyvanat bahcemizi olusturalim vector<shared_ptr<Animal>> animalList = { make_shared<Cat>("Mirnav"), make_shared<Dog>("Karabas"), make_shared<Cat>("Tosun") }; // Heyvanlara bir goz atalim checkAnimals(animalList); return 0; } |
Uygulamayı çalıştırdığımızda aşağıdaki çıktıyı alacağız:
|
1 2 3 |
Mirnav Miyav! diye seslendi! Karabas Hav! Hav! diye seslendi! Tosun Miyav! diye seslendi! |
Yukarıdaki örnekte göreceğiniz üzere aslında bütün sınıflar tek bir arayüz olan IAnimal arayüzünden türetilmekte. Fakat çalışma zamanında (ki burada main fonksiyonu içerisinde kallavi ilklendirme oluyor 🙂 ), oluşturulan nesne tipine göre daha sonra çalışma zamanındaki kullanım sırasında (ki buradaki aslında checkAnimals fonksiyonu) çağrılan fonksiyonların çıktısı ilgili nesneye göre farklılık gösteriyor. İyi de bunun bize ne faydası olacak diye düşündüğünüz anda hemen şu durumu hep birlikte ele alım. Diyelim ki, hayvanat bahçesinizi genişletmeye karar verdiniz ve yeni bir hayvan eklendi, neleri değiştirmeniz gerekecek? Aslında yukarıdaki basit örnek de bile, ilgili hayvan sınıfını ekleyip oluşturduktan sonra hiç bir şeyi değiştirmenize gerek kalmadığını göreceksiniz. İşte temel mantık bu. Elbette bu işin bir yönü, diğer yönlerine de hemen göz atacağız.
Çeşitleri nelerdir? C++ da nasıl kullanılmaktadır?
Şimdi artık biraz daha C++ doğru gelebiliriz. Bu yazımda Java ve benzeri dillere girmeyeceğim ağırlığı C++’a vereceğim ama kaynaklar kısmına bu dillere ilişkin de bir kaç sayfa koyacağım. Evet dostlar, C++ da polimorfizm kullanımına ilişkin bir örneği ilk başlıkta gördük. Bu aslında C++’ın çalışma zamanında bunu nasıl gerçekleştirdiği ile ilgiliydi buna benzer şekilde derleme zamanında da bu kabiliyet sunulmakta. Detaylarına geçmeden önce, C++’da bulunan polimorfizm mekanizmalarına göz atalım. Bunları aşağıdaki figürde görebilirsiniz:
Şimdi bu mekanizmalara daha yakından bakalım.
Çalışma Zamanında Polimorfizm
Çalışma zamanı polimorfizmi, kimi kaynaklarda dinamik polimorfizm olarak da geçer, temel olarak ilk örnekte de gösterildiği üzere fonksiyon üzerine bindirmesi (“function overriding“) ile gerçekleştirilmektedir. Bu da türetilmiş sınıfın, türetildiği sınıfta bulunan üye bir fonksiyona yeni bir tanım getirerek, bu fonksiyonun üzerine bindirmesi (“overriding“) ile gerçekleşir (evet türkçe karşılığına alışmak biraz vakit alabilir). Burada dinamik polimorfizmi gerçekleştirmek için “virtual” anahtar kelimesini kullanıyoruz, bu sayede derleyici, kullanılan işaretçinin tipinden ziyade, içerisinde gösterilen nesnenin tipine bakar ve bu sayede ilgili hayvanın metodu çağrılır. Velev ki virtual koymadık ne olur? Hemen yukarıdaki örneği virtual ve override anahtar kelimelerini kaldırarak çalıştıralım ve çıktıya bakalım:
|
1 2 3 |
Mirnav Ben kimim? diye seslendi! Karabas Ben kimim? diye seslendi! Tosun Ben kimim? diye seslendi! |
Görmek istediğimiz elbette bu değildi. C++’da bu işin kotarılmasında sanal fonksiyonlar rol oynamakta. Derleyici için bu anhatar kelime, işaretçinin içeriğine bakması için gerekli uyarıyı veriyor. Bu noktada aslında sanal fonksiyonların nasıl çalıştığından da haberdar olmanın önemli olduğunu düşünüyorum, o sebeple bu konuyu ayrı bir başlıkta daha detaylı olarak ele alacağım.
Sonuç olarak çalışma zamanında gerçekleştirilen bu polimorfizm için şunları akılda tutmakta fayda var:
- Bağlama (“Binding“) çalışma zamanında yapılır,
- Sanal fonksiyonlar ve işaretçiler kullanılarak gerçekleştirilir,
- Bu mekanizma ile dinamik (“dynamic“) ve geç (“late“) bağlama gerçeklenir,
- Bu polimorfizm mekanizmasında, çağrı derleyici tarafından çözülmez,
- Türetilen ve türetilmiş sınıflar arasındaki polimorfizm için metot ve parametreler aynı olmalıdır (fonksiyon imzaları),
- Statik polimorfizme göre, görece yavaştır,
- Çalışma zamanında çözümleme yapılmasından ötürü, daha fazla esneklik sunar.
Derleme Zamanında Polimorfizm
C++ da derleme zamanında polimorfizm iki şekilde yapılmakta bunlardan ilk fonksiyonlar, diğeri de operatörler kullanılarak gerçekleştirilmekte. Şimdi bunlara sırayla bakalım.
Fonksiyon çoklama temelde aynı isim ve dönüş değerine sahip fakat farklı sayıda, tipte parametre alma ve bunların farklı sıralanmaları ile gerçekleştirilir. Çok basit bir örnek vermek gerekirse:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 |
#include<iostream> using namespace std; class Adder { public: // İki tam sayı alan toplayıcı int addNumbers(int x, int y) { return (x+y); } // Üç tam sayı alan toplayıcı int addNumbers(int x, int y, int z) { return (x+y+z); } // Bir tam sayı ve bir de ondalıklı alan toplayıcı int addNumbers(int x, float y) { return (x+y); } // Farklı sırad, bir tam sayı ve bir de ondalıklı alan toplayıcı int addNumbers(float x, int y) { return (x+y); } }; int main() { Adder adderInst; cout << adderInst.addNumbers(10, 20) << endl // Ilk metod cagrildi << adderInst.addNumbers(10, 20, 30) << endl // ikinci metot cagrildi << adderInst.addNumbers(10, 20.0F) << endl // ucuncu metot cagrildi << adderInst.addNumbers(20.0F, 10) << endl; // dorduncu metot cagrildi return 0; } |
Çalıştırdığınızda elde edeceğiniz çıktı:
|
1 2 3 4 |
30 60 30 30 |
Fonksiyon çoklamasına benzer şekilde C++’da belirli operatörleri de yukarıdakine benzer şekilde, temel ya da karmaşık tipler için çoklayabilirsiniz. Örneğin, “+” operaötürünü string sınıfları için, metinleri birleştirme amacı ile çoklayabilirsiniz ya da kompleks sayılar için toplamada kullanabilirsiniz. Buna ilişkin de hemen bir örneğe göz atalım:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 |
#include<iostream> using namespace std; class Complex { private: int mReal, mImag; public: Complex(int r = 0, int i = 0) : mReal{r}, mImag{i} { } // Asagidaki metot iki Complex nesnesi ile + operatoru kullanildiginda // otomatik sekilde cagrilacaktir Complex operator + (Complex const &obj) { Complex res; res.mReal = mReal + obj.mReal; res.mImag = mImag + obj.mImag; return res; } void print() { cout << mReal << " + i" << mImag << endl; } }; int main() { Complex c1(10, 5), c2(2, 4); Complex c3 = c1 + c2; c3.print(); return 0; } |
Çalıştırdığınızda elde edeceğiniz çıktı:
|
1 |
12 + i9 |
Yukarıdaki örneklerden de anlaşılacağı üzere burada hangi fonksiyonların çağrılacağını aslında derleyici, derleme zamanında biliyor ve ona göre kodu üretiyor. Şimdi gelelim derleme zamanında gerçekleştirilen bu polimorfizm için aklımızda tutmamız gerekenlere:
- Hangi metodun çağrılacağı derleme zamanında, derleyici tarafından belirlenir,
- Fonksyion ve operatör çoklama kullanılarak gerçekleştirilir,
- Bu mekanizma ile statik (“static“) ve erken(“early“) bağlama gerçeklenir,
- Bu polimorfizm mekanizmasında, çağrı derleyici tarafından çözülür,
- Aynı sınıf içerisinde, aynı isme sahip, fakat farklı tipte veya sayıda parametrelerin kullanılması ile gerçekleştirilir,
- Dinamik polimorfizme göre, görece hızlıdır,
- Derleme zamanında çözümleme yapılmasından ötürü, daha az esneklik sunar.
C++’da sanal tabloları (“vTables”) kullanımı nedir?
Şimdi geldik biraz daha teknik bir konuya. Aslında yukarıda anlatılan çalışma zamanındaki polimorfizmin C++ da gerçeklenmesindeki en büyük rol sanal fonksiyonlarda. Eminim meraklı yazılımperver dostlarım, hayatlarında bir noktada aşağıdaki kodları çalıştırdıklarında ortaya çıkan farkı merak edip bu yapılara ulaşmışlardır. Aslına bakarsanız, benim de mülakatlarda arada sorduğum sorulardandır 🙂
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
#include <iostream> using namespace std; class ClassA { private: int a; int b; }; class ClassB { private: int a; int b; public: virtual void dummyFunction() { } }; int main() { // Bu fark neden olaki? :) cout << sizeof(ClassA) << " vs " << sizeof(ClassB) << endl; return 0; } |
Çalıştırdığınızda elde edeceğiniz çıktı:
|
1 |
8 vs 16 |
Sanal fonksiyonların da çalışmasının arkasında yatan mekanizma ise vtables olarak da bilinen sanal tablolardadır “virtual tables“. Haydi şimdi bunlara yakından bir göz atalım ne dersiniz. Peki nedir bu vTable‘lar? Wikipedia ne der bakalım:
A virtual method table (VMT),…, is a mechanism used in a programming language to support dynamic dispatch.
Kısaca, çalışma zamanında polmorfizm kapsamında, ilgili nesneye ilişkin doğru fonksiyonun seçilmesinde kullanılan tablodur. Peki normalde bu iş nasıl yapılmakta, hemen bakalım (aslında yukarıda biraz buna değinmiş olduk ama biraz daha basit bir örnek üzerinden gidelim):
|
1 2 3 4 5 6 7 8 9 10 |
#include <iostream> using namespace std; class Base { public: void func1(){ cout << "[Base::func1()] Kardes bu Base sinif!" << endl; } }; |
Derleyici yukarıda tanımlamış olduğumuz Base sınıfımızda bulunan func1()’ı oluşturacak ve bunun adresini hatırlayacak ve her Base sınıf nesnesinde aynı kod parçası çağılıyor olacak, yani belirsiz bir durum yok ve çalışma zamanı için herhangi bir sıkıntı. Şimdi ortamı biraz daha renklendirelim 🙂 mesela ortama bir kaç sanal fonksiyon ve dahi türetilmiş bir sınıf ekleyelim:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 |
#include <iostream> #include <memory> using namespace std; class Base { public: virtual void func1(){ cout << "[Base::func1] Kardes bu Base sinif!" << endl; } virtual void func2(){ cout << "[Base::func2] Kardes bu Base sinif!" << endl; } }; class Derived : public Base { public: void func1() override{ cout << "[Derived::func1] Kardes bu Derived sinifi!" << endl; } }; int main() { auto instance = make_shared<Derived>(); instance->func1(); return 0; } |
Bu durumda eğer Base sınıftaki virtual anahtar kelimeleri silersek aslında yine bir önceki örnekte olduğu gibi Base sınıfının fonksiyonu çağrılıyor olacaktı ama burada durum farklı. Burada, çalışma zamanında uygun fonksiyon seçilerek çağrılıyor olması gerekiyor. Şimdi adım adım bunların nasıl gerçekleştirildiğine bakalım:
- Ne zaman ki sınıfınızda bir sanal fonksiyon tanımladığınızda, derleyici sınıf içerisinde bir sanal tablo (bundan sonra vTable diyeceğim) oluşturur. Aynı zamanda türetilen sınıflar içerisinde de ayrıca bir vTable bulunmakta. Yukarıdaki boyuttaki fark da bundan kaynaklanıyor bu arada,
- Sınıfa ait bütün nesneler aynı vTable‘ı paylaşır,
- vtable içerisinde, sınıf içerisindeki her bir sanal fonksiyon için bir kalem tutulur ve burada ilgili fonksiyonun en spesifik hali tutulur (örnek Derived::func1()). Yukarıdaki örnek için aşağıdaki gibi vTable‘lar oluşturulur:
- Şimdi bu tabloları inceleyecek olursak.
- Base sınıfına ait vTable içerisinde iki adet girdi var bunlar bu sınıf içerisinde tanımlanmış olan func1() ve func2() fonksiyonları. Burada, iki fonksiyon da kendilerini işaret etmekte çünkü, Base sınıf gözünden, bu fonksiyonların en spesifik halleri bunlar
- Gelelim Derived sınıfına ait vTable’a. Burada func1(), Derived sınıfına ait ilgili fonksiyonu işaret etmekte. Çünkü bu sınıf Base sınıftaki ilgili fonksiyondan daha spesifik. Fakat, func2()’ye baktığımızda, bu fonksiyona ilişkin girdi, Derived değil de, Base sınıfına ait func2() fonksiyonunu işaret etmekte, çünkü Derived içerisindeki func2() ilgili fonksiyonun üzerine bindirme yapmıyor. Bu durumda en spesifik hali Base sınıfınki oluyor,
- Derleyici, bu tablolar için her bir sınıfa, bu tabloya olan bir işaretçi ekler ve tahmin edebileceğiniz üzere çalışma zamanında da bu tabloya göre doğru fonksiyon seçilerek çağrılır. Yani nihayetinde sınıflar aşağıdaki hali alırlar:
-
Polimorfizm açısından, vTable’a ilişkin yukarıdaki açıklamalar umarım yeterli olmuştur. Elbette C++ için bütün hikaye bu değil ama bundan sonraki mecra biraz daha teknik detaylara giriyor ki açıkçası burada oraya dalma niyetim yok ama kısaca bahsedeyim. Bir sonraki adım aslında “Multiple Inheritance”, yani çoklu miras. Bu durumda ise birden fazla sınıftan türetilen sınıf için birden fazla vTable ihtiyacı olabilir. Hatta miras da ortak atadan gelen sınıflardan türetilme durumlarında, daha da fazla vTable ihitiyacı olabilmektedir.
vTable’lara ilişkin daha detaylı bilgi ve bir kaç kod parçası için kaynaklar kısmına bir kaç kaynak ekliyorum. Meraklı yazılımperver dostlar bir göz atabilirsiniz.
Evet dostlar bir yazımın daha sonuna geldik. Umarım yazı, C++’da polimorfizm ve genel olarak polimorfizm konularına açıklık getirmiştir.
Bir sonraki yazımda görüşmek dileğiyle. Bol kodlu ve sağlıklı günler diliyorum 🙂