9. Hafta

//////////////////////////////////////////////////1. Ders//////////////////////////////////////////////////////

---------------
dynamic binding / late binding: hangi fonksiyonun çağrıldığı derleme zamanında değil çalışma zamanına bir kodun koşturulması ile anlaşılıyro ise

static binding / early binding : hangi fonksiyonun çağrıldığı  derleme zamanında belli oluyorsa 
--------------



Bir taban sınıfın fonksiyonları 3'e ayrılır :

1) türemiş sınıflara hem bir bir interface (arayüz) hem de bir implementasyon veren fonksiyonlar

Airplane
  taekoff

2) türemiş sınıflara hem bir bir interface (arayüz) hem de bir default implementasyon veren fonksiyonlar

fly

3) türemiş sınıflara hem bir bir interface (arayüz) veren implementasyon vermeyen fonksiyonlar

land

-------------

override (function overrideing): taban sınfın interface'ini alıp onu istememeye denir

-------------

Bir sınıfın en az 2. katergorisinde bir fonksiyonu varsa böyle sınıflara polymorphic (çok biçimli)
Bir sınıfın en az 3. katergorisinde en az bir fonksiyonu varsa böyle sınıflara abstract class

-------------
1)

class Airplane {
public:
void takeoff(); //1. kategori
};

class Airbus : public Airplane{ //override yapmak zorunda değiliz

};

-------

2)
  
class Airplane {
public:
void takeoff();
virtual void fly(); //virtual fonksiyon (sanal fonksiyon)

};

class Airbus : public Airplane{ 

};

-------

3)

class Airplane {
public:
void takeoff(); //override edilelemz
virtual void fly(); // override edilebilir ama etmek zorunda değilim
virtual void land() = 0; //pure virtual function (saf sanal fonksiyon), override edilmeli
};

class Airbus : public Airplane{ 
};


------

class Airplane {
public:
void takeoff();
virtual void fly();
//virtual void land() = 0; 
//airplane abstract (soyut) değil yani concrete(somut)
//polymorphic'dir
};

class Airbus : public Airplane{ //override yapmak zorunda değiliz

};

-----

bir sınıfın abstract olmasının çok önemli bir sonucu da var, o sınıf türünden nesne oluşturamayız
sadece pointer ve referans semantiği ile kullanabiliriz

----

class Airplane {
public:
void takeoff();
virtual void fly();
virtual void land() = 0; 
};

class Airbus : public Airplane{};

int main()
{
Airplane a; //hata
//Airbus ab; //hata
}

---------------

//virtual kullanıldığında aynı imzaya sahip farklı geri dönüş türü
olan fonksiyon bildirilmesi dilin kurallarına aykır

class Base {
public:
virtual int func(int); //türemiş sınıf ister override eder ister etmez
};

class Der : public Base {
public:
double func(int);
};

----------

//ne overriding ne de overloading olur ve lagal
class Base {
public:
virtual int func(int);
};

class Der : public Base {
public:
double func(double); 
};

----------
//bu şekilde taban sınıfı override eder
//eskiden override etmenin yolu buydu

class Base {
public:
virtual int func(int);
};

class Der : public Base {
public:
int func(int); 
};

---------

override ve final contexual keyword (bağlamasal anahtar sözcük) : 
belli bir alanda kullanıldğı zaman keyword başka bir yerde kullanıldığı zaman isim anlamına gelir

-------

class Base {
public:
virtual int func(int);
};

class Der : public Base {
public:
int func(int); //burada override
int func(double)override; //hata
int func(int)override; // burada da override
};


-------

class Base
{
public:
	virtual int func(int)const;
};

class Der : public Base
{
public:
	int func(int); //override değil const yazmamız lazım
};

--------

geri dönüş değeri aynı imza aynı override
imza aynı geri dönüş değeri farklı sentax
geri dönüş farklı imza farklı override da değil overloadingde değil

----------------

eğer bir fonksiyon çağrısı taban sınıf türünden bir nesne ile değil
taban sınıf türünden bir pointer değişken ya da 
taban sınıf türünden bir referans değişken ile 
yapılıyor ise
"virtual dispatc" (sanal gönderim devreye giriyor)

airplane_ptr->fly();
airplane_ref.fly();

ao.fly();
Airplane ao = myairbus; // olmaz

---------------
car ile ilgili örnek 

!! BU KISIM VİSİUL STDİODA

---------------

virtual dispatc mekanizmasının devreye girdiği seneryolar

1) Non virtual interface (NVI)

class Base {
public:
virtual void foo()
{
std::cout << "Base::foo()\n";
}
void bar()
{
foo();
}
};

class Der : public Base {
public:
void foo()
{
std::cout << "Der::foo()\n";
}
};

void gf1(Base* p)
{
p->foo();
}

void gf2(Base& p)
{
r.foo();
}

int main()
{
Der myder;
myder.bar(); //sanal olmaya bir fonksiyona çağrı yapıyoruz
}

---------------------

bazı tehlikeli hatalar...

1) sanal olmayan bir yapıyı override yaptığını sanması

class Base {
public:
void foo()
{
std::cout << "Base::foo()\n";
}
};

class Der : public Base {
public:
void foo()
{
}
};

----------

2) override edeyim derken parametrik yapının yanlış yazılması

class Base {
public:
virtual void foo(double)
{
std::cout << "Base::foo()\n";
}
};

class Der : public Base {
public:
void foo(float)
{
std::cout << "Base::foo()\n";
}
};

----------

class Base {
public:
virtual void foo(double)const
{
std::cout << "Base::foo()\n";
}
};

class Der : public Base {
public:
void foo(double) //Yukarıdakinin override'ı değildir const olması gerekir
{
std::cout << "Base::foo()\n";
}
};

-------------

4) eğer taban sınıfın sanal fonksiyonunu override ederken 
override contexual keywordünü kullanırsak bunun overirde olduğunu ve derleyiicye kontrol 
yükümlülüğü veririz

class Base {
public:
void foo(long)
{
std::cout << "Base::foo()\n";
}
};

class Der : public Base {
public:
void foo(long)override; //derleyici böyle bir override olmadığını kontrol eder
//!! override yazmak isek derleyici override olmadığı zmana hata verir
!! override ediyorsak override yaz
};

----------------------------

Bir taban sınıfın sanal fonksiyonunu override 
eden türemiş sınıfın fonksiyonu virtual specifier ile nitelenmemiş olsa da
yine de sanal (virtual) fonksiyondur

class Base {
public:
virtual void foo(int);
};

class Der : public Base {
public:
void foo(int); //bu fonksiyon virtual
};

class NDer : public Der {
public:
void foo(int);
};

---------

!! BU KISIM car_1.h'da


----------

//private, public olma zorunluluğu yoktr sentax hatası yoktur

class Base {
//private
virtual void vfunc()
{
std::cout << "Base::vfunc()\n";
}
};

class Der : public Base {
public:
virtual void vfunc()override
{
std::cout << "Base::vfunc()\n";
}
};

----------
//hata olmaz

class Base {
public:
virtual void vfunc()
{
std::cout << "Base::vfunc()\n";
}
};

class Der : public Base {
private:
virtual void vfunc()override
{
std::cout << "Base::vfunc()\n";
}
};

----------
//hata olmaz

class Base {
public:
virtual void vfunc()
{
std::cout << "Base::vfunc()\n";
}
};

class Der : public Base {
private:
virtual void vfunc()override
{
std::cout << "Base::vfunc()\n";
}
};


void gf(Base* p)
{
p->vfunc();
}

int main()
{
Der myder;
myder.vfunc(); //hata çıkar, erişim hatası
gf(&myder);
}

------------------

C++ dilini yeni öğrenenler tipik olarak

statik tür kavramı (static type)
dinamik tür kavramını (dynamic type)
birbirine karıştırma eğiliminde

-----------------

mülaktta sorulan tipik soular

class Base {
public:
void foo();
void bar();

};

class Der : public Base {
public:
void baz();
};

void gf(Base& r)
{
r.baz(); //hata, taban snıfta arar, isim arama her zaman static türe göre yapılır
}

int main()
{

}

-------------

class Base {
public:
void foo();
virtual void bar();
private:
virtual void baz();
};

class Der : public Base {
public:
};

void gf(Base& r)
{
r.baz(); //hata
}

------------

tipik mülakat sorusu

class Base {
public:
virtual void foo(int x = 7)
{
std::cout << "Base::foo(int x) x =" << x << "\n";
}
};

class Der : public Base {
public:
virtual void foo(int x = 999)override
{
std::cout << "Der::foo(int x) x =" << x << "\n"; //iyi bir kullanım değil
}
};

void gf(Base& r) 
{
r.foo();
//r.foo(7);//buna dönüştürcek
}

int main()
{
Der myder;
gf(myder); //7

myder.foo(); //999, der sınıfının foo'nunun varsayılan argümanıyla çağrılır

}

---------------

yanlış anlaşılmalar...

virtual bir fonksiyon overload edilebilir

class Myclass {
public:
virtual void foo(int);
virtual void foo(double);
};

class Der : public Base {
public:
void foo(int) override;
void foo(double) override;
};

-------------

!! virtual anahtar sözcüğünün specifirını global fonksiyonlar için kullanamayız

virtual void gf(Base *);

-------------

class Base {
public:
virtual static void foo(); //sınıfın static üye fonksiyonu virtual olamaz
};

-------------

class Base {
public:
virtual Base(int); //ctor virtual olamaz

};

C++ dilinde sınıfların ctor'ları virtual anahtar sözcüğü ile bildirilemez
ancak virtual ctor özellikle OOP paradigmasında bir ihtiyaç olabilir
C++ dilinde bu yapıya virtual ctor idioum, clone idiom denir	
		      -------------------  ------------								

------------

!!BU YAPI car_2.h'da
//main.cpp
#include "car.h"
void car_game(Car* o)
{
//buraya (çalışma zamanında)  hangi türden araba gelirse
//oyunun senaryosu gereği çalışma zamanında aynı türden bir araba oluşturulcak

Car* p = p->clone(); 
}

---------------

class Base {
public:
void foo()
{
vfunc();
}

virtual void vfunc()
{
std::cout << "Base::vfunc()\n";
}
};

class Der : public Base {
public:
virtual void vfunc()override
{
std::cout << "Der::vfunc()\n"; //virtual devreye girer burası ekranda yazar
}
};

int main()
{
Der myder;
myder.foo();
}

-------------
mülakatlarda sık sorulur
!!ÖZEL DURUM
//taban sınıf ctor içinde yapılan sanal fonksiyon çağrıları için
virtual dispatch uygulanmaz

class Base {

public:

void foo()
{
vfunc();
Base::vfunc();//devreye girmez
}

/*~Base()
{
vfunc(); //yine devreye girmez
}*/

virtual void vfunc()
{
std::cout << "Base::vfunc()\n";
}
};

class Der : public Base {
public:
virtual void vfunc()override
{
std::cout << "Der::vfunc()\n"; 
}
};

int main()
{
Der myder;
}

---------

sanal fonksiyon mekanizmasının devreye girmediği yerler...

1) çağrı taban sınıf nesnesi ile yapılıyor ise
2) çağrı taban sınıf ctor içinde yapılıyorsa
3) çağrı taban sınıf dtor içinde yapılıyorsa
4) çağrı taban sınıf çzünürlük operatörü ile yapılıyorsa

-------

class Base {
public:
virtual void func();
};

class Der : public Base {
public:
virtual void func()override
{
Base::func();
}

};

///////////////////////////////////////////////////2. Ders///////////////////////////////////////////////////

class Base {
public:
~Base()
{
std::cout << "Base dtor\n";
}
};

class Der : public Base {
public:
~Der()
{
std::cout << "Der dtor\n";
}
};

int main()
{
Base *p = new Der;
delete p;
}

//derleyici dtor'un virtual olmaması durumunda p'nin static türüne bakıcak
ve bunun base* olduğunu gördüğü için base sınıfının dtor'unu çağırıcak


//taban sınıf pointerı türemiş sınıf türünden dinamik ömürlü bir nesneyi gösteriyor ise
taban sınıfın dtoru virtual değil ise tababn sınıfn pointerını bu şekilde delete etmek
sadece taban sınıfın dtor çağrılmasını sağlıycak dolayısıyla tanımısız davranış olucak

--------------
//olması gerektiği gibi çalışır

class Base {
public:
//virtual dtor
virtual ~Base()
{
std::cout << "Base dtor\n";
}
};

class Der : public Base {
public:
~Der()
{
std::cout << "Der dtor\n";
}
};

int main()
{
Base *p = new Der;
delete p;
}

-----------
mülakatlarda çıkar

!! polimorfik sınıfların dtor'ları ya public virtual ya da
protected non-virtual olmalı

//türemiş sınıf taban sınıfın protected bölümüne erişebilir


class Base {
public:

protected:
~Base()
{
std::cout << "Base dtor\n";
}
};

class Der : public Base {
public:
~Der()
{
std::cout << "Der dtor\n";
}
};

int main()
{
//Der myder; hata olmaz

Base* p = new Der; 
delete p; //hata

}


---------------

//bu kısım car_3.h'da

--------------

!! virtual dispatch heryerde kullanamk mantıklı olmayabilir bunun yerine aşağıdakiler kullanılabilinir

type erasure
std::variant
CRTP (curiously recurring template pattern)

-------------
virtual arka planda nasıl çalışır
-----------------------------------

//polimorfic olunca 4 byte artar, pointe sizeof'undan dolayı

class Base {
virtual ~Base
int x{};
int y{};
virtual void f1(){};
//virtual void f1(){}; normalde fonksiyonlar yer kaplamaz ancak virtualla kaplar
};

class Der : public Base {

};

int main()
{
std::cout << "sizeof(Base) = " << sizeof(Base) << "\n";

}

----

sanal fonksiyon tablosu
virtual function table
it is a data structure

her sınıf için bir sanal fonksiyon tablosu vardır
index ile fonksiyon adreslerine erişebileceğimiz bir veri yapısı demektir

virtual function table for class Audi
------------------------------------
0
-----------------------------------
1			&Audi::start
2			&Audi::run
3			&Audi::stop

virtual function table for class Mercedes
------------------------------------
0
-----------------------------------
1			&Mercedes::start
2			&Mercedes::run
3			&Mercedes::stop


void car_game(Car* p)
{
p->run();
p->vptr[2]() //bu şekilde derleyici yazar
}

her türemiş sınıf nesnesi oluşturulduğunda vptr init edilecek

sanal fonksiyon tablosu her sınıf için oluşturulcak

-----

görünmeyen maliyet kalemler:

otomotik ömürlü nesneden güzeli yok!
dinamik ömürlüde ağır işlemler gerçekleşiyor

mülakatların klasik sorusudur
run time polimorfizim ne şekilde 
virtual dispatch ne şekilde implemente edilir ve hangi maaliyetlerin söz konusu olduğu


her sanal fonlsiyon çağrısı için virtual dispatch uygulanmayabilir
compiler optimization dan dolayı
devirtualization

--------------------------------------------------

sınıf içinde yapılan using bildirimlerine devam...

using bildiriminin kullanıldığı yerlerden biri de taban sınıftaki bir ismi türemiş sınıfta görünür kılmak

class Base {
public:
void func(int);
void func(long);
};

class Der : public Base {
public:
using Base::func;
void func(int x) //using sayesinde bu yapıya gerek kalmaz
{
Base::func(x);
}
void func(double);
};

int main()
{
Der myder;
myder.func(12);
}


-----------
protected'ı clientlar çağıramaz, ancak türemiş sınıf çağırabilir

class Base {
public:
protected:
void func(int);
};

class Der : public Base {
public:
using Base::func; //bu şkiled protected içindeki kullanılır
};

int main()
{
Der myder;
myder.func(12);
}

-----------

class Base {
public:
protected:
private:
void func(int);
};

class Der : public Base {
public:
using Base:func; //gecersiz
};

int main()
{
Der myder;
}

-----------

class Base {
public:
void func(int x)
{
std::cout <<"Base::func\n";
}
private:
};

class Der : public Base {
public:
void func(int x)
{
std::cout <<"Der::func\n";
}

};

int main()
{
Der myder;
myder.func(12); //türemiş sınıf çağrılır
myder.Base::func(12); //base çağrılır
}

----------------
!!kalıtım neden yaparız:
taban sınıf interface ile aynı interface sahip bir sınıf oluşturmak istiyoruz
ancak bazı eklemelerde yapmak istiyoruz bunu yapmanın tipik yolu kalıtımdır
--------------

modern cpp öncesi taban sınıfın ctor için using kullanılmıyordu
artık kullanılıyır buna inherited ctor denir.
			--------------
------

class Base {
public:
//protected olsaydı geçerli olmıycaktı
Base(int);
Base(int,int);

void f1();
void f2();
void f3();
private:
};

class Der : Base {
public:
Der(int x, int y) : Base(x, y) {}; //eskiden bu şekilde yapılırdı
using Base:Base; //modern cpp(cpp11) ile bu geldi, //inheritance ctor
void bar();
void foo();

};

int main()
{
Base mybase(12);
Base mybase(1, 2);
Der myder(13); //inheritance ctor
Der myder(1,3);


}

--------------------------------------------

coveriance / variant return type :
---------------------------------

taban sınıfın sanal fonksiyonunu override edebilmemiz için taban sınıfın sanal fonksiyonu ile
aynı imzaya sahip aynı geri dönüş değeri türüne sahip olmalıdır

covariance : diyelim ki taban sınıfın sanal fonksiyonunun geri dönüş türü

class B {}
class D : public B {}

class Base {
public:
virtual B* foo();
virtual B& bar();
virtual B baz(); //bu şekilde olmaz
}

class Der : public Base {
public:
D *foo()override;
D& bar()override;
D baz()override; //hata
};

int main()
{
D* dp = myder.foo();
auto dp2 = myder.foo();
}
//YUKARIDAKİ DURUMUA COVARİANCE DENİR BU İSTİSNADIR
//pointer ve referans türü ile olmalıdır

---------------------------------
önümüzde ki konular...

multiple inheritance
private inheritance
protected inheritance
RTTI runtime type information

----------------------
//aşağıdaki kısmın bize faydaları nedir, araştır

NVI (non-virtual interface)

class Base {
public:
void foo(int x)
{
vfoo(x);
}
private:
virtual void foo(int);
};

class Der : public Base {
public:
void vfoo(int) override;
};

------------------------------------

final contexture keyword:
-------------------------

void final(int final, int override
{

}
int main()
{
int final = 12;
int override = 23;

final += override;

::final(final, override);
}

----------

final 2 ayrı yerde kullanılır
1) final class
2) final override

kalıtımın daha fazla yapılmamaıs için yapılan bir yönetdir
eskiden yorum satırı olarak yapılmaması gerektiği söylenirdi

class Base {
//bu sınıftan kalitim yapmayın
};

class Der final : public Base { //der sınıfından kalıtım yapılması hata olur

};

class NecDer : public Der {

};

---------

artık türemiş sınıflar tarafından override edilmesin

class Base {
virtual void func();
};

class Der : public Base {
public:
void func()override final; // yerleri değişik olabilir
};

class Mer : public Der {
public:
void func()override; //hata
};


-------------------------------

int main()
{
using namespace std;

std::vector<Car*> carvec;

for (int i = 0; i < 1000; ++i) {
carvec.push_back(create_random_car());
}
//range-based for loop
for (auto p : carvec) {
cout << *p << "\n";
p->start();
(void)getchar();
}
}

//////////////////////////////////////////3. Ders////////////////////////////////////////////

üretimde 
%80 public 
% 15 private
%5 protected kullanılır


private kalıtımı:
----------------

!! türemiş sınıfın implementasyonu taban sınıfın public bölümündeki öğelere erişemez

class Base {
private:
void foo();
};

class Der : private Base {
void func()
{
foo();
}
};

----------------
!! foo bar fonksiyonları der sınıfının private interface'ine eklenir,

class Base {
public:
void foo();
void bar();
};

class Der : private Base {

};

int main()
{
Der myder;
myder.foo();
}
---------------

!! protected olsa da private'a eklenir

class Base {
public:
void foo();
void bar();

protected:
void pro_func();
};

class Der : private Base {

};

class NecDer : public Der {
void baz()
{
pro_func();
}
};


------------
!! türemiş sınıf nesnesi taban sınıf türünden kabul edilmiyor

class Base {
public:
};

class Der : private Base {

};

int main()
{
Der myder;
Base* p = &myder; //hata olur
Base&p = myder; //hata olur

}

---------------

class Base {
public:
};

class Der : private Base {
public:
void gf();
friend void gf();

void foo()
{
Der myder;
Base* p = &myder; //legal olur
}
};

void gf()
{
Der myder;
Base* p = &myder; //friendleri içinde legal olur
}


------------------

türemiş sınıf nesnesinin içinde taban sınıf nesnesi var
private, public veya protected olması burada önemli değil  her zmana vardır

-------------------

class Base {
public:
virtual void vfunc();
};

class Der : private Base {
public:
void vfunc()override; //legal
};

-------------------

private inheritance containement için (composition)
bir alternatif oluşturur

class X1 {
public:

};

class Y1 { //Y1 içinde X1 vardır
private:
X1 mx; //member object
};

----------

class X2 {

};

class Y2 : private X2 { //Y2 içinde X2 vardır, base class object

};


--------------------
yukarıdaki 2 yapı arasındaki farkları inceliyoruz...

class X1 {
protected:
void foo();
public:
};

class Y1 { 
public:
void bar()
{
mx.foo(); //erişim hatası
}

private:
X1 mx;
};

-----

class X2 {
public:
void foo();
};

class Y2 : private X2 { 
public:
using X2::foo();
void foo() //bu şekilde de yapılır
{ 
X2::foo();
}
};

---

class X2 {
protected:
void foo();
};

class Y2 : private X2 { 
public:
void bar()
{
foo(); //legal
}
};

----

class X2 {
protected:
virtual void foo();
};

class Y2 : private X2 { 
public:
void foo()override;
};

-------------------

containment mı yoksa private inheritance mı?
genel olarak containment seçilir, containment yapamadığımız durumlarda private kullanılır bu durumlar...

1) elemanımın sınıfının sanal fonksiyonunu (doğrudan) override edemem
ancak private taban sınıfımın sanal fonksiyonlarını override edebilirim

2) elemanımın protected bölümüne erişemem ancak private taban sınıfının
protected bölümüne erişebilirim

3)bir sınıf nesnesi elemanının türünden değildir
ancak türemiş sınfın üye fonksiyonları içnde ve türemiş sınfın friendleri için
is a relationship var

4) eğer sınıfımızın bir elemanı empty class türünden ise 
bu sınıfın 1 byte olan storage ihtiyacı
alignment gereği sınıf nesnesinin içinde padding bytes oluşturabilir

ancak empty class'tan private kalıtımı yaparsak 
derleyiciler EBO denilen opt. yapabilir


--------

class X {

};

class Y {
X mx;
};

int main()
{
Y y;
X *p = &y; //bunu diyemem
}

--------

class X {

};

class Y : private X{ private
void foo()
{
Y y;
X *p = &y; //böyle diyebilirim
}
};

int main()
{

}

--------------------

class X {

};

class Y {
X x1; 
X x2; //mümkün değil, 
};

//aynı taban sınıfdan 2 kere kalıtım yapamam

class Base {

};

class Der : Base, Base {

};

--------------------

class Empty {
void foo();
void bar();
};

class Nec {

Empty member;
int mx;
};

int main()
{
std::cout << "sizeof(Empty) = " << sizeof(Empty) << "\n";
std::cout << "sizeof(Empty) = " << sizeof(Nec) << "\n"; //hizalamadan dolayı 8 olur 4n katlarından dolay
}

--------------

EBO
----

class Empty {
void foo();
void bar();
};

class Nec : private Empty{
int mx;
};

int main()
{
std::cout << "sizeof(Empty) = " << sizeof(Empty) << "\n";
std::cout << "sizeof(Empty) = " << sizeof(Nec) << "\n"; //hizalamadan dolayı 8 olur 4n katlarından dolay
}

--------------------------------------------

Herb sutter tarafından tanıtılan bir kullanım 
bu örüntüye restricted polymporphism deniyor, 

//çok kullanılan bir yapı değil ancak mülakatlarda private ile alakalı soru sorulursa araya sıkıştır diyor necati hoca

class Base {
public:
virtual void vfunc();

};

void foo(Base& baseref)
{
baseref.vfunc();
}

//f1, f2, f3 fonksiyonlarımız olucak bunların bazılarına haklar vericek

class Der : public Base {
friend void f1(); //f2, f3 yazarsak onlar kullanılır
};

void f1()
{
Der myder;
foo(myder);
}

void f2()
{
Der myder;
foo(myder);
}

void f3()
{
Der myder;
foo(myder);
}


------------------------------------------------------

protected kalıtımı:
-------------------

private'dan farkı yoktur,
multi level inheritancelarda kullanılır

class Base {
public:
void foo();
};

class Der : private Base {

};

class Nec : public Der {
void necbar()
{
foo(); //Hata, protected kalıtımı olsa idi legal olucaktı
}
};


-----------------------------------------------------------------
//mülakatlarda bolca sorulur

Multiple inheritance:
---------------------

Bir sınıfı oluştururken birden fazla taban sınıf oluşturabiliyoruz

bir sınıfın birden fazla taban sınıftan tek bir türetme ile oluşturulması


multi -level için geçerli olan çoğu şey bunun için de geçerlidir

sentaxı:
--------

class Base1 {

};

class Base2 {

};

class Der : public Base1, Base2 { //Base1, public - Base2 private olur

};

--------

class Base1 {
public:
void foo();	
};

class Base2 {
public:
void bar();
};

class Der : public Base1, public Base2 { 

};

int main()
{
Der myder;

myder.foo();
myder.bar();
Base1* p1 = &myder; //ref içinde geçerli
Base2* p2 = &myder;

}

------------

class Base1 {
public:
int mx;
};

class Base2 {
public:
int my;
};

class Der : public Base1, public Base2 { 

};

int main()
{
std::cout << "sizeof(Der) = " << sizeof(Der) << "\n";

}

-----------

class Base1 {
public:
Base1(int)
{
std::cout << "Base1 ctor\n";
}
};

class Base2 {
public:
Base2(int)
{
std::cout << "Base2 ctor\n";
}
};

class Der : public Base1, public Base2 { 
public:
Der() : Base2(2), Base1(1) {} //yukarıdaki sıra geçerlidir
};

int main()
{
Der myder; //sırlamayı inheritanceda'ki sıra belirler (Base1, Base2)
}

------------

class Base1 {
public:
Base1(int)
{
std::cout << "Base1 ctor\n";
}
};

class Base2 {
public:
Base2(int)
{
std::cout << "Base2 ctor\n";
}
};

class Der : public Base1, public Base2 { 
public:
Der() : Base2(2), Base1(1) {} //yukarıdaki sıra geçerlidir
};

void foo(Base1&);
void bar(Base2&);

int main()
{
Der myder;
foo(myder);
bar(myder);


}

-----------

class Base1 {
public:
Base1(int)
{
std::cout << "Base1 ctor\n";
}
};

class Base2 {
public:
Base2(int)
{
std::cout << "Base2 ctor\n";
}
};

class Der : public Base1, public Base2 { 
public:
Der() : Base2(2), Base1(1) {} //yukarıdaki sıra geçerlidir
};

void foo(Base1&);
void foo(Base2&);

int main()
{
Der myder;
foo(myder); //ambigidous

}

-------------

class Base1 {
public:
};

class Base2 {
public:
};

class Der : public Base1, public Base2 { 
public:
};

void foo(Base1&)
{
std::cout <<" Base1&\n";
}

void foo(Base2&)
{
std::cout <<" Base2&\n";

}

int main()
{
Der myder;

foo(static_cast<Base1&>(myder));
foo(static_cast<Base2&>(myder));

}

---------------

class Base1 {
public:
void foo(double);
};

class Base2 {
public:
void foo(int);
};

class Der : public Base1, public Base2 { 
public:

void bar()
{
foo(12.3); //her 2 sınıfta da aranır,
foo(10); //her 2 sınıfta da aranır

}
};

----------------

class Base1 {
public:
int foo(double dval)
{
std::cout << "Base1::foo(double) dval = " << dval << '\n';
}
};

class Base2 {
public:
int foo(double dval)
{
std::cout << "Base2::foo(double) dval = " << dval << '\n';
}
};

class Der : public Base1, public Base2{
public:
void bar()
{
Base1::foo(1.2);
Base2::foo(67);
}
};

int main()
{
Der myder;
myder.bar();
myder.foo(12); //hata
myder.Base1::foo(12); //legal
myder.Base2::foo(1.2); //legal
}

-----------

class Person {

};

class Employee {

};

class Teacher : public Person, public Employee {

};

-----------

class A {
virtual void bar();
};

class B {
virtual void foo();
};

class C : public A, public B {
void bar()override;
void foo()override;
};

-----------

class InputStream {
public:
void read(int&);
};

class OutputStream {
void write(int);
};

class InOutStream : public InputStream, public OutputStream {

};

int main()
{
InOutStream stream;

int x{};
stream.read(x);
stream.write(12);

}

----------------

//mülakatlarda bunun üstüne giderler

DDD / dreadful diomand of derivation / deatful diomand of derivation

class Stream {

};

class InputStream : public Stream {
public:
void read(int&);
};

class OutputStream : public Stream {
public:
void write(int);
};

class InOutStream : public InputStream, public OutputStream {

};

int main()
{
InOutStream stream; //2 tane stream var 

int x{};
stream.read(x);
stream.write(12);

}

---------------------

1 tane stream olmasını virtual inheritance (sanal kalıtım) ile sağlarız

class Base {
int x{ 0 };
};

class DerX : public Base {

};

class DerY : public Base {

};

class MDer : public DerX, public DerY {}; //2 tane ayrı base nesnesi olucak

int main()
{
std::cout << "sizeof(Base) = " << sizeof(Base) << "\n";
std::cout << "sizeof(Base) = " << sizeof(DerX) << "\n";
std::cout << "sizeof(Base) = " << sizeof(DerY) << "\n";

}

----------
// bu yapı compile time da ve run time da problemle oluşturur
class Base {
public:
void func()
{
std::cout << "this = " << this << "\n";
}
};

class DerX : public Base {

};

class DerY : public Base {

};

class MDer : public DerX, public DerY {

}

int main()
{
MDer md;
md.DerX::func();
md.DerY::func();
}

------------

class Base {
public:
void foo();
};

class DerX : public Base {

};

class DerY : public Base {

};

class MDer : public DerX, public DerY {

};

int main()
{
Mder md;

Base* p = &md; //hata
md.foo(); //hata olur çünkü çağrılması için base pointerı gerekiyor ama md nesnesinin içinde 2 tane base nesnesi var
md::DerX.foo();
md::DerY.foo();

}


---------

class Base {
public:
void foo();
};

class DerX : public Base {

};

class DerY : public Base {

};

class MDer : public DerX, public DerY {

void func()
{
foo(); //hata
DerX::foo(); //legal
DerY::foo();
}
};

void func(Base&);

int main()
{

}

---------------

#include <iostream>

class EDevice
{
public:
    void turn_on()
    {
        m_flag = true;
    }

    void turn_off()
    {
        m_flag = true;
    }

    bool is_open() const
    {
        return m_flag;
    }

private:
    bool m_flag{};
};

class Printer : public EDevice
{
public:
    void print()
    {
        if (is_open())
        {
            std::cout << "printer is printing...\n";
        }
        else
        {
            std::cout << "printer connot print device is off...\n";
        }
    }
};

class Scanner : public EDevice
{
public:
    void scan()
    {
        if (is_open())
        {
            std::cout << "scanner is scanning...n";
        }
        else
        {
            std::cout << "printer connot print device is off...n";
        }
    }
};

class Combo : public Scanner, public Printer
{
};

int main()
{
    Combo mydevice;
    mydevice.turn_on(); // hata çünkü combo içinde 2 tane edevice var

    mydevice.Printer::turn_on();

    mydevice.print();
    mydevice.scan();
}

//doğru çalışmıyor, virtual kullanmamız lazım

--------------------
!! eğer 2 tane taban sınıfın ortak bir taban sınıfı var ise 
eğer bunları daha sonra çoklu kalıtımda kullanıcak isek her 2 sınıfda virtual inheritance ile elde etmemiz lazım

class EDevice
{
public:
    void turn_on()
    {
        m_flag = true;
    }

    void turn_off()
    {
        m_flag = false;
    }

    bool is_open() const
    {
        return m_flag;
    }

private:
    bool m_flag{};
};

class Printer : virtual public EDevice
{
public:
    void print()
    {
        if (is_open())
        {
            std::cout << "printer is printing...\n";
        }
        else
        {
            std::cout << "printer connot print device is off...\n";
        }
    }
};

class Scanner : virtual public EDevice
{
public:
    void scan()
    {
        if (is_open())
        {
            std::cout << "scanner is scanning...\n";
        }
        else
        {
            std::cout << "printer connot print device is off...\n";
        }
    }
};

class Combo : public Scanner, public Printer
{
};

int main()
{
    Combo mydevice;

    mydevice.turn_on();
    mydevice.print();
    mydevice.scan();

    mydevice.turn_off();
    mydevice.print();
    mydevice.scan();
}


--------------------

mülakatlarda elmas formasyonunu sorarlar, açıklamanızı isterler
virtual inheritance sorarlar, isim aramaya ilişkin sorarlar

----------------------

class A {
public:
A(int);
};

struct B : A {

};

struct C : B {
public:
C() : A(12) {} //NORMALDE BU HATA, ancak virtaul inheritance'da bunu yapmamız gerekicek
};

---------------

class Base {
public:
Base(int x)
{
std::cout << "Base(const char *p) p = "<< p << '\n';
}
};

class Der1 : virtual public Base { //der 1 sınıfı base sınıfından kalıtım yoluyla elde edildi
public:
Der1(int) : Base("Der1\n") {};
};

class Der2 : virtual public Base { //der 2 sınfı base sınıfında  kalıtım yoluyla elde edildi
public:
Der2(int) : Base("Der2\n") {};
};

class MulDer : public Der1, public Der2 { //MulDer sınıfı Der1 ve Der2 sınıfından kalıtım yolula elde edildi
public:
Mulder() : Der1(1), Der2(2) {}; //hata
Mulder() : Base("Mulder"), Der1(1), Der2(2) {}; //legal

};

class Nec : public Mulder {
public:
Nec() : Base("Nec");
};

int main()
{
//Mulder md;
//Der1 d2(1);
Nec e;
}

----------------------------------------------------------

RTTI (run time time information):
---------------------------------

run time da türün belirlenmesine yönelik
cpp ın araç seti var. Bu araç setind 2 tna operator var
bunlar dinamik ömürlü nesnenin türünün öğrenilmesini sğlar

dynamic_cast
typeid 
    type-info

-----------
taban sınıftan türemiş sınıfa dönüşümlere --> down casting
türemiş sınıfatan taban sınıfta dönüşümlere --> up casting
----------