8. Hafta

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

namespaces (isim alanları) : isim çakışmalarını önlemek için yapılır, global isim alanları içinde ayrı scopelar oluşturulur
---------------------------

//here is as namespace

void x();

int main()
{
::x //bu isim global isim alanında aranır
}

-----------

bir namespace nasıl oluşturulur :
---------------------------------
!! bir namespace içinde olmalayız
!! bir fonksiyon içinde olmaz
!! bir sınıf tanımı içinde olmaz

namespace nec {

} //burada ';' yok

--------

namespace nec {
int x = 10; //global değişken
}

-------

file scope ==> namespace scope

namespace ali {
int x = 5;
double x = 5.6; //hata
}

--------

//bu şekilde sentax hatası olmaz
namespace bugra{
void f(int); //function overloading
void f(double);
}

--------

namespace emre {
double x = 5;

class A {
};

int foo(int)
{

}
}

namespace furkan {
double x = 5.5;

class A {
};

int foo(int)
{

}
}
}

---------

//ismi namespace içinde aratmak

namespace tamer {
int x;
}

int main()
{
tamer::x;
}

---------
//legal
namespace a{
int x;
}

namespace b{
int x;
}

int main()
{
a::x = b::x;
}

---------
#include <iostream>
#include <chrono>

int main()
{
std::chrono::duration //bu şekilde namespace içinde namespace aranabilir
}

---------

int main()
{
std::sort
std::ranges::sort
}

----------
//aşağıdaki sort isimleri farklı varlıklara ilişkili
namespace Std {
//sort
namespace Ranges {
//sort
}
}

---------
//bunu yapmanın nedeni farklı başlık dosyalarına aynı namespace içinde ancak farklı başlık dosyaları içinde 
olmasını sağlar

namespace onur {
int a = 5;
int b = 67;
}

namespace onur {
int c = 343;
}


-----
//yukarıdaki ile aynı anlamda

namespace onur {
int a = 5;
int b = 67;

int c = 343;
}

----------

namespace eda {
int a, b, c;
}

namespace eda {
double a; //hata
}

----------

//unnamed namespace

namespace { //legal
int a, b, c;
}

--------

namespace ali {
void foo(int); //function overloading

}

namespace ali {
void foo(int, int);
}

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

!! bir isim alanı içindeki bir ismin nitelenmeden kullanılmasını sağlayan 3 araç vardır

-using declaration
-using (namespace) directive
-ADL (argument dependent lookup) (argümana bağlı isim arama)


----------

using declaration :
-----------------

using std::cout;

1) using bildiriminin bir kapsamı vardır ve o kapsam içinde 
etkin olur

using std::cout;

void foo()
{
using std::cin;
}

2) bildirime konan isim bildirimin yapıldıgu isim alanına enjecte edilir ve sanki o kapsamda tanımlanmış gibi etki gösterir

namespace emre {
int x = 5;
}

int main()
{
int x = 55;
using emre::x; //buraya enjecte edilir, hata olur
}

-----

namespace emre {
int x = 5;
}

int main()
{
using emre::x; 
x //emre namespace'inde tanımlanan x olduğunu anlıycak
}

------

namespace emre {
int x = 5;
}

int x = 10;
using emre::x; //hata olur

int main()
{

}

------

namespace emre {
int x = 5;
}

void foo()
{
using emre::x; //x adece burada etkin
x = 5;
}

void bar()
{
x = 2; //hata 
}

------

namespace emre {
int x = 5;
}

using emre::x; //global alanda yapıldığı için x hata yok

void foo()
{
x = 5;
}

void bar()
{
x = 2;
}

--------

namespace emre {
int x = 5;
}

void foo()
{
x = 5; //hata 
}

using emre::x; 

void bar()
{
x = 2; //hata yok
}

---------

namespace ali {
int x = 10;
}

int x = 56;

int main()
{
using ali::x; //ali'nin x'i
x = 99;
std::cout << ali::x << "\";
}

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

using (namespace) directive
---------------------------

using namespace std:ranges;
using namespace ::boost

-------

namespace ali {
int a, b, c;

class Neco {

};

void foo();
}

using namespace ali; //ali namespace içindekiler global alanda görünür olucaklar

int main()
{

}


-------
using (namespace) direktifi bir bildirimdir

Tüm bildirimlerde olduğu gibi bu bildirimin de bir kapsamı vardır
ve bu bildirim bildirimin kapsamnında etkindir

-------

namespace Ali {
int x, y, x;
}

int main()
{
using namespace ali;

x = 5; //hepsi legal
y = 5;
z = 456;
}

--------

namespace ali {
int x, y, z;

}

using namespace ali;

void foo()
{
x = 5;
y = x;
z = y;
}

void bar()
{
x = 5;
y = x;
z = y;
}

---------

namespace ali {
int x = 99, y, z;
}

int main()
{
using namespace ali;
int x = 10;
std::cout << x << "\n";
}

----------

namespace ali {
int x = 99;
}

namespace veli {
int x = 99;
}

int main()
{
using namespace ali;
using namespace veli;
x = 4; //ambigiosu hatası
}

-----------


namespace ali {
int foo(int);
}

namespace veli {
int foo(int, int);
}

int main()
{
using namespace ali;
using namespace veli;

foo(3);
foo(3, 6); //overloading
}

----------

int g = 10;

namespace ali {
using ::g;
}

namespace veli{
using ali::g;
}

int main()
{
++g;
++ali::g;
++veli::g;
std::cout << "g = " << g << '\n';
}

---------------
namespace Nec {
void foo();
void bar(int);
}

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

ADL :
-----
Bir fonksiyona nitelenmemiş bir isimle çağrı yapıldığında 
eğer fonksiyona gönderilen argümanlardan biri
bir namespace içinde tanımlanan türe ilişkin ise
söz konusu fonksiyon ismi o namespace içinde de aranır!!!

---------

namespace nec {

class Erg {

};
void foo();
void bar(int);
void baz(Erg);
}

int main()
{
nec::Erg e;
baz(e);
bar(12); //hata
}

---------

int main()
{
std::cout << "merhaba dunya"; //adl nedeni ile arandı
}

---------

namespace nec {
class Erg {

};
void foo(Erg); //adl ile bulunur
}

void foo(nec::Erg) {} //Adl ile bulunmaz

int main()
{
nec::Erg e;
foo(e); //ambiguous hata
}

-----------

namespace nec {
class Erg {

};
void foo(std::vector<Erg>);
}

int main()
{
std::vector<nec::Erg> x;
foo(x);  //leagl
}

-----------

namespace nec {
enum Pos {off, on, hold};

void foo(Pos);
}

int main()
{
foo(nec::off); //adl çalışır
}

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

namespace nec {
class Myclass {
public:
struct Data {
};
};
void foo(Myclass::Data);
}

int main()
{
foo(nec::Myclass::Data{}); //nec'in Myclass'ının Data'ının geçici nesnesi ile foo'ya çağrı yapıyorum

}

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

//nec.h

namespace neco {
class Nec {
public:
void foo(int);
};

void func(Nec);
}

//#include "nec.h"

int main()
{
neco::Nec x;
x.foo(12); //legal 
func(x); //legal, adr seyasinde bulur
}

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

class Myclass {
public:
friend void foo(int);
friend void bar(Myclass);
};

int main()
{
Myclass m;
bar(m);
}

------------
//buradaki friend kullanımı da adl ile alakalıdır 
class Myclass {
public:
friend operator<<(std::operator&, const Myclass&);
};

int main()
{
Myclass m;
std::cout << m;
}

------------
//buradaki nec ismi de çakışabilir bunun için namespace alias vardır
namespace nec {
int a;
class Myclass {

};
}

------
namespace alias sentax yapısı aşağıdaki şekildedir

namespace nec_project {
int a;
class Myclass {
};
}

namespace nec = nec_project;

int main()
{
nec::a = 5;
nec::Myclass m;
}

--------

namespace eda {
namespace ali {
namespace can {
int x = 57;
}
}
}

namespace can = eda::ali::can;

int main()
{
eda::ali::can::x; 
can::x; //yukarıdaki yerine bu şekilde yazılabilicek
}

--------

namespace ali::veli::can {
int x = 5;
}

namespace ali {
int a = 9;
}

namespace ali::veli {
int v = 34;
}

int main()
{
std::cout << ali::a << "\n";
std::cout << ali::veli::v << "\n";
std::cout << ali::veli::can::x << "\n";
}

-----------

inline namespace

namespace ali {
inline namespace can {
int x = 10;
int y = 45;
}

int main()
{
ali::x = 5; //legal
ali::y = 10; //legal
}

-----------
#define OLDVERSION

namespace ali {
#ifdef OLDVERSION
  inline
#endif

namespace old_version {
class Myclass {

};
}

#ifdef NEWVERSION
  inline
#endif

namespace new_version {
class Myclass {

};
}
}

int main()
{
ali::Myclass
}

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

namespace ali::veli:: inline can { //c++20 ile geldi

}

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

unnamed namespace :
-------------------
internal linkage : farklı kaynak dosyalarda farklı varlıklar ise, static anahtar sözcüğü
external linkage : bir varlık birden fazla dosyada kullanılıyor ve aynı anlama geliyor ise

-------

static class Myclass { //Böyle bir şey yok

};

-------

namespace { //iç bağlantıda olduğunu söyler
int x; //iç bağlantıda
}

--------
//one defibition rule işlenmez

//mehmet.cpp
namespace {
int x = 10;
class Array{

};
}

//ali.cpp
namespace {
double x{};
class Array{

};

}

//hasan.cpp
namespace {
int x{ 213 };
class Array{

};
}

----------

namespace {
int x = 10;
class Array {

};
}

int main()
{
x = 90;
}

---------


namespace nec {
class Myclass {
public:
Myclass foo(Myclass);
};
}

nec::Myclass nec::Myclass::foo(Myclass m)
{
Myclass m;
return m;
}

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

operator overloading eksik klana yerler...

enum class WeekDay { //class is not a class, sadece scope özelliğini kullanır
Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday
};

int main()
{
WeekDay wd{WeekDay::Friday};

WeekDay wd{ WeekDay::Sunday };
for (int i = 0; i < 100; ++i) {
std::cout << wd++ << '\n'; //hata wd++, düzeltmek için operatror overloading kullanırız
}
}

-----------

enum class WeekDay { //class is not a class, sadece scope özelliğini kullanır
Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday
};

Weekday& operator++(Weekday& wd)
{
using enum Weekday; //c++ 20
wd == saturday ? Sunday : wd + 1 //+ kullanmıycağımız için aşağıdaki şekilde yaparız
return wd = wd == saturday ? Sunday : static_cast<Weekday>(static_cast<int>(wd) + 1)
                                      //weedday dönüştü   //inte dönüştü
}
Weekday operator++(Weekday& wd, int)
{
Weekday temp{ wd };
++wd;
return temp;
}

std::ostream& operator<<(std::ostream& os, const Weekday& wd)
{
static const char *const pwdays[] = {"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"};

return os << pwdays[static_cast<int>(wd)];
}

int main()
{

WeekDay wd{ WeekDay::Sunday };
for (int i = 0; i < 100; ++i) {
std::cout << wd++ << '\n';
}

std::cout << ++wd;
std::cout << wd++ << " " << wd;

}

===================================================================

Nested types/teype member/member types

class Myclass {
//typedef int value_type; //c dilinde
using value_type = int; //c++ dilinde nested type

enum color {Blue, Red,Green};

class Nec {

};
};


----------

class Myclass {
public:
using value_type = int; //c++ dilinde nested type

enum color {Blue, Red,Green};

class Nec {

};
};

int main()
{
value_type x; //hata olur
Color mycolor; //hata
Nec mynec; //hata

Myclass::value_type x;
Myclass::Color mycolor;
Myclass::Red;
}

--------

class Nec {
public:
class Erg; { //nec'İn erg türünden bir elemanı yoktur

};
private:
Erg ma[10];
Nec::Erg ma[10]; //böyle yazmaya gerek yok yukarıdaki yeterli
};

-------

class Nec {
public:
class Erg {

};
private:
void foo();
};

//cpp
void Nec::foo()
{
Erg e; //blok içinde arıyor bulamadıysa sınıf içinde arıyor
Nec::Erg e; //Bu şekild de olur
}

-------

class Nec {
public:
class Erg {

};
private:
void foo();
};

//cpp
void Nec::foo(Erg e)
{

}

-------

nested type ile yapılan en tipik hatalar:

1)

class Myclass {
ValueType mx;
typedef int ValueType; //Hata
};

------

2) 

struct ValueType {};

class Myclass { 
ValueType mx; //ValueType dışındaki
typedef int ValueType; 
};

-----

struct ValueType {};

class Myclass { 
typedef int ValueType; 
ValueType mx; //myclass value type'ı olur
};

-------

class Myclass { 

void foo()
{
ValueType x = 6; //legal, blok içinde arandıktan sonra class scope içinde aranır
}
///
typedef int ValueType;
};

//fonkisyonun inline olarak class definition içinde tanımlanmasıyla
fonksiyonun sınıf dışında normal bildiğimiz bir biçimde tanımlanması arasında isim arama 
kuralları açısından bir fark yoktur.

-------

class Myclass { 

void foo()
{
ValueType x = 6; 

typedef int ValueType; //illegal
}
};

void Myclass::foo()
{
ValueType x = 6;
}

-----------
//enclosing class
class Myclass {

//Nec is a nested type
//Nec is a inner type
class Nec{ 

};
};

----------

class Erg;

//forward declaration
//erg is an incomplete type

class Myclass {
class Nec;
};

----------

class Erg;

class Myclass {

class Nec; //incomplete type

};

class Nec { //Myclass içindeki ile farklılar

};
//nec is complete type here
class Myclass::Nec { //bu şekilde tanımı yapılır

};

class Erg {

};

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

class Myclass {
class Erg {
public:
void bar()
{

}
private:
void foo()
}
};

void func()
{
Erg e;
e.foo();
}
//myclass sınıfı erg sınfınnı private bölümüne erişebilir mi?
  -erişemez friend bildirimi lazım

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

class Myclass {
static void mbar();
class Erg {
public:
void foo()
{
Myclass::mbar(); //legal, modern c++ ile eklendi
auto sz = sizeof(mx); //legal
}

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

class Myclass {

class Nested {

};
};

int main()
{
Myclass::Nested x;//hata, private olduğu için
}

------------
//burası ilginç biraz

class Myclass {

class Nested {
public:
void nf1();
void nf2();
};
public:
static Nested foo();
};

int main()
{
Myclass::Nested x = Myclass::foo(); //legal değil
auto x = Myclass::foo(); //legal

x.nf1();
x.nf2();
}

--------
#include <vector>

class System {

public:
class Element {
void foo();
};
private:
std::vector<Element> mvec;
};


--------

class System {

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

void Element::foo() //illegal
{

}
private:

};

-----------
//system.h
class System {
public:
class Element {
void foo();
};

private:

};

//system.cpp
void System::Element::foo()
{

}

--------

//system.h
class System {
public:
Element& operator=(const Element&);
};

private:

};

System::Element::Element(const Element&) //copy ctoru
{

}

System::Element& System::Element::operator=(const Element& other)
{
return *this;
}

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

//çok kullanılan bir idioum ancak daha sonra detaylı görücez

pimple idiom
pointer to implementation
handle-body idiom
cheshire cat
compiler firewall
opaque pointer

Bu örüntü sınıfın private bölümünü client kodlardan gizlemeye yönelik

//tamer.h
class Tamer {
public:

private:
A ax;
B bx;
C cx;
int ival;
}

Neden sınıfımızın private bölümünü gizlemek isteriz?
  -A ax, B bx, C cx include edilmezdi ve compile time kısalırdır

--------

binary compatibility

A ax, B bx .. sıralarının değiştirilmesi veya yeni öğe eklenmesi yeniden derlenmeyi sağlar

öyle client kodlar var ki bazı değişiklikler yapınca yeniden derlenmesinı sağlıyor 
ancak gizlenince bunlar problem olmuyor

//pimple idiomu smart pointerlar'da detaylı anlatılacak
//sınıf nesnesinin içine pointer koyulur bu pointer incomplete bir türden, pointerın neyi gösterdiği konusunda client kodlararın bir bilgisi yok
sınıfın veri elemanlarını doğrudan sınıfın veri elemanı yapmaktan çıkartıp veri elemanlarını başka bir sınıfın veri elemanı yapıyoruz. böylece doğrudan kullanmak
yerine pointer ile arka planda kullanıyoruz

//tamer.h
class Tamer {
public:
void foo();
void bar();
Tamer();
private:
struct pimpl;
pimpl *mp;

};

//tamer.cpp
struct Tamer::pimpl{
A ax;
D dx;
C cx;
int ival;
bool m_flag;
}

Tamer::Tamer() : mp{new pimpl{}};

void Tamer::foo()
{
mp->ax
mp->bx
}

==========================================================================

İnheritance(Kalıtım)
-----------------------

oop terminology

C++ dilinin kendi kalıtım araçlarına yönelik
C++ özelinde oluşturulmuş terminology

is-a relationship

Her futbolcu bir sporucudur
Her mercedes bir arabadır
Her aslan bir hayvandır

Sporcu, Araba ve hayvana arent class/super class denir

araba'nın özelliklerinii alan fakat ilave özelliklere de sahip olabilecek kalıtım yoluyla oluşturulmus
sınıfa child class/subclass denir

zebra sınıfını animal sınıfından kalıtım yoluyla elde ettim
animal sınıfı superclass zebra sınıfı subclass

UML: Yaygun olarak kullanılan modellem dili

kaynak olarak kullanılan sınıfa base class denir
kalıtımla elde edilen sınıfa derived class


derive ==> türetme
derivition

base class (taban sınıfa)

derived class (türemiş sınıf)

-----------

3 ayrı kalıtım biçimi (kategorisi) var

public inheritance ==> OOP

a) public inheritance
b) private inheritance
c) protected inheritace

multiple inheritance 
multi-level inheritance 

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

Kalıtım sentaxı:
----------------

Kalıtım mekanizması ile bir sınıf oluşturmamız için 
bir complete type'a ihtiyacımız var

class Base; //hata
class {}; //legal

class Der : public Base {

};

-------

class Base {};

class Der : protected Base { // public/protected/private olabilir

};

-------

class Base {};

class Der : Base { };
//class Der : private Base { }; //aynı anlamda, default olarak private gelir

----------
class Base {};

struct Der : Base {}; //public kalıtımı

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

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

class Der : public Base {
public:
void f1();
void f2();
};

int main()
{
Der myder;

myder.bar();
myder.foo();
myder.baz();
myder.f1();
}


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

// bir kısmını kendi interfaceime katmak istiyorum bir kısmını istemiyorum diyorsak
uygulamamız gereken kalıtım değil composition

//ya interface'İn hepsini alırız ya hiçbirini

class Car()
{
public:
void start();
void run();
void stop();
};

class Mercedes : public Car{
public:

}

----------

class Car()
{
public:
void start();
void run();
void stop();
};

class Mercedes : public Car {
public:

};

int main()
{
Mercedes m;
Car* p = &m;
Car& cr = m; //ref. semantiği ile de geçerlidir

Car c;
c = m; //object slicing (nesne dilimlenmesi) bunu ASLA yapma
}

-------

#include <iostream>

class Car
{
public:
    void start();
    void run();
    void stop();
};

class Mercedes : public Car
{
public:
};

class Bmw : public Car
{
public:
};

class Audi : public Car
{
public:
};

class Skoda : public Car
{
public:
};

void car_game(Car *p);
void car_race(Car &r1, Car &r2);

int main()
{
    Mercedes m;
    Bmw b;
    Audi a;
    Skoda s;

    car_game(&m);
    car_game(&b);

    car_race(b, s);
}

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

class Base {

};

class Der : public Base {

};

---------
//base'in public fonksiyonları Der'in fonksiyonları olarak kullanılabilecek

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

class Der : public Base {
public:

};

int main()
{
Der myder;
myder.foo();
}
---------
//Der'in içinde  Base vardır

class Base {
int x{};
int y{};
};

class Der : public Base { //bu şekilde olursa base class object denir
int a{};
int b{};
Base b; // bu şekilde olursa member object denir
};

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

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

bir nesnenin içinde fiziksel olarak bir nesne vardır

containment söz konusu olduğunda member object denir
kalıtım söz konusu olduğunda base object denir (inheritance)

-----------

sınıfın private bölümü sadece kendisine açıktır

class Base {
private:
int mx;
void foo();
protected: //kendisinden kalıtım yoluya elde edilicek sınıflara hitap edicek interface 
int my;
int func();
public: //herkese açık

};

class Der : public Base {
void bar()
{
mx = 5;
}
};


-----------

public: herkese açık
private: sadece bana açık ve friend bildiri yapılan kodlara açık
protected :bana açık, clientlara kapalı ama kalıtım yoluyla benden elde edilecek sınıflara açık

----------

sınıflar tasarlanırken kalıtım yoluyla kullanılacak veya kullanılmayacak şekilde tasalanıyorlar

----------
//function overloading değildir
!! taban sınıfın sunduğu isimler ayrı bir scope'da türemiş sınıfların sunduğu isimler ayrı bir scope'da
aynı isimli fonksiyonlar overload değildir

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

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

----------
//bu duruma name hidding denir

int main()
{
int x = 10;

if (x > 5) {
int x = 45;
x = 99;
}
}

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

kalıtım ve isim arama :

der.a
ptr->a
Der::a

sol taraf olan isim yukarıdakilerden biriyse ve sağ operand olan isim önce türemiş sınıfın scope'unda 
orada bulunamaz ise taban sınıf kapsamında aranır


----------

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

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

int main()
{
Der myder;
myder.foo(); //illegal, 1607. satırda bulundu ancak parametre gönderilmediği için bulunamadı
//sol taraf türemiş isim foo türemiş sınıfta aranır

}


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

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

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

int main()
{
Der myder;

myder.foo(12); //Der::foo
myder.Base::foo(); //Base::foo
}

---------

class Nec {
public:
void foo();

};

int main()
{
Nec mynec;
mynec.foo();
mynec.Nec::foo();
}

----------

class Base {
public:
void foo(double);

};

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

int main()
{
Der myder;
myder.foo(3.4); //illegal access control(private), void foo(int);
}

!! kontrol sırası ==> name lookup > context control > access control

----------

class Base {
public:
void foo(double);

};

class Der : public Base {
public:
void bar()
{
foo(3.4); //legal
}
};

int main()
{

}

!! türemiş sınıfın bir üye fonskiyonu içinde bir isim nitelenmeden kullanılırsa
isim önce blokta
  sonra kapsayan blokta
    sonra türemiş sınıf tanımında 
      sonra taban sınıf tanımında 
        sonra namesapce'de aranır

--------------
//buradaki x'leri teker teker yorum satırlarına alarak hangix olduğunu öğren

int x;
class Base {
public:
int x;
};

class Der : public Base {
public:
void bar()
{
int x = 56;
{
int x = 78;
auto b = x;

auto b1 = Der::x; //1727. satırdaki x
auto b2 = this->x; //1727. satırdaki x
auto b1 = Base ::x;
}
}

int x;
};

int main()
{

}

------------
//mülakatta sorulabilecek sıfır sefiyesindeki bir soru

class Base {
public:
void foo(int);

};

class Der : public Base {
public:
void foo(int x)
{
  foo(4); //recorsive çağrı, 1746. satır çağrılır
  Base::foo(x); //recorsive değil
  foo(); //sentax hatası
}
};

int main()
{

}

----------

class Base {
public:
void foo(int);

};

class Der : public Base {
public:
void foo(int x)
{
int foo = 5;
foo(10); //hata kendi scobunda aranır
}
};

int main()
{

}

------------
!!private olduğu için çağrılmama gibi bir durum yoktur

class Myclass {
public:
void foo(float x);
void foo(double x);
private:
void foo(int);
};

int main()
{
Myclass m;
m.foo(1); //private olan seçilir ancak erişim kontrolünden dolay hatalı olur
}

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

class Base {

public:
void foo(int x);

void foo(double);
};

class Der : public Base {
public:
void foo(long);
void foo(int x)
{
Base::foo(x); //bu şekilde olabilir
}
void foo(double x)
{
Base::foo(x); //bu şekilde olabilir
}
};


int main()
{
Der myder;
myder.foo(12); //Der'in myder'i çağrılır

//aşağıdaki kodlara dokunmadan nasıl aşağıdakiler çağrılır
myder.foo(1.2); //Base::foo(double)
myder.foo(1); //Base::foo(int)
myder.foo(12L); //Der::foo(long)
}

----

daha kolay yolu vardır...

class Base {

public:
void foo(int x);
void foo(double);
};

class Der : public Base {
public:
using Base::foo; //bu şekilde enjecte edilir
void foo(long);
};

int main()
{
Der myder;

//aşağıdaki kodlara dokunmadan nasıl aşağıdakiler çağrılır
myder.foo(1.2); //Base::foo(double)
myder.foo(1); //Base::foo(int)
myder.foo(12L); //Der::foo(long)
}

----------

//multi - level inheritance
class A {

};

class B : public A {

};

class C : public B {

};

//direct base class (A B'nin taban sınıfı)
// indirect Base class (B C'nin taban sınıfı)

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

Der bir türemiş sınıf olsun

bir der nesnesi hayata geldiğinde önce der içindeki base class object hayata gelecek
sonra bildirimdeki sırayla member object'ler hayata gelecek
sonra akış der sınıfın ctor'ının anabloğuna giricek

Bir der nesnesi hayata bittiğinde


---------

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

class Der : public Base{

};

int main()
{
Der myder;//snetax hatası, Der'in defaıult ctoru delete edilmiş
}

--------

class Base {
public:
Base();
};

class Der : public Base{

};

int main()
{
Der myder; //hata yok
}

-------

class Base {
public:

};

class Der : public Base{

};

int main()
{
Der myder; //hata yok, Base'e default ctor yazar
}

-------

class Base {
Base();
};

class Der : public Base{

};

int main()
{
Der myder; //hata var, der'in ctorunu derleyici yazıcak derleyici base default ctoruna çağrı yapacak taban sınıfın default ctoru private olduğu için sentax hatası oluş
//base'İn default ctoru var ama private
}

----------

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

class Der : public Base {

};

int main()
{
Der myder;
}

-----------

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

class Der : public base {
public:
Der()
{
std::cout << "der def. ctor\n";
}

~Der()
{
std::cout << "der dtor\n";
}
};

int main()
{
Der myder;
}

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

class Base {
public:
Base(int x, int y)
{
std::cout << "Base(int x, int y) x = " << x << " y = " << y << '\n';
}
};

class Der : public Base {
public:
//Der() //taban sınıfın default ctoru oolmadığı için hata verir
Der() : Base(10, 20) //bu şekilde legal olur, Base{10,20} bu şekilde de olur
{
std::cout << "der def. ctor\n";
}
};

int main()
{
Der myder;
}

---------

!! tanımlanan fonksiyon delete edilemez, derleyici sadece örtülü olarak bildirmsesi gereken fonksiyonu delete edebilri
ya da fonksiyonu ben delete bildirimi yapabilirim

--------

class Base {
public:
Base(double d)
{
std::cout << "Base(double d) d = " << d <<'\n';
}

Base(int x, int y)
{
std::cout << "Base(int x, int y) x = " << x << " y = "<< y << '\n';
}

};

class Der : public base {
public:
Der() : Base{10, 20} 
{
std::cout << "der def. ctor\n";
}

Der(double dval) : Base(dval) {

}
};

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

----------

Eğer taban sınıf nesnemize türemiş sınıfın kodunu yazıyoruz , 
türemiş sınıf ctor içinde taban snıfın default ctorunu çağırmak istiyorsak bir şey yapmamıza gerek yok
türemiş sınıf için default ctor default edersek ya da derleyici implicitly declareted edip default ederse derleyici her zman t

--------

class Member {
public:
Member(int x)
{
std::cout << "Member(int x) x = " << x << '\n';
}
};

class Base {
public:
Base (double d)
{
std::cout << "Base(double d) d = " << d << '\n';
}
};

class Der : public Base {
public:
Der() : mx(29), Base(3.4) {
std::cout << "Der default ctor\n";
}

~Der()
{
std::cout << "Der dtor\n";
}
private:
Member mx;
};

int main()
{
Der myder;
}

//önce base, mx, en son Der hayata gelir

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

struct A {
A(int) {
std::cout << "A(int)\n";
}
};

struct B : A {
B(int x) : A(10) {
std::cout << "B(int)\n";
}
};

struct C : B {
C(int x) : A(x) {} //Hata olur dolaylı olarak çağırma yoktur, multi-level inheritance'da
C(int x) : B(x) { //legal
std::cout << C(int)\n";
} 
};

int main()
{
C cx(10);
}

--------------------
türemiş sınıftan taban sınıfa olana up sampling
tabandan türemişe operator kullanarak dönüşümlere down sampling
--------------------

class Base {

public:
};

class Der : public Base {

};

int main()
{
Der myder;
Base *p = &myder; /bu şekilde olabilir
Base & r = myder; //bu şekilde olabilir
Base mybase =myder; //object slicing yapma
}

-----------

class Base {

public:
void foo(); //void foo(Base*) gizli parametresi vardır
};

class Der : public Base {

};

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

---------------------------------
fonksiuonların yazımını derleyiciye bırakmaya rule of zero denir
-----------

kalıtımda özel üye fonksiyonlarının durumu :

-copy ctor
-move ctor
-copy assignment
-move assignment

--------

class Base {

public:
Base()
{
std::cout << Base default ctor\n";
}

Base(const Base&)
{
std::cout << "Base copy ctor\n";
}
};

class Der : public Base {

};

int main()
{
Der ader;
Der bder(ader);
//Der bder2(std::move(ader));
}

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

class Base {
public:
Base()
{
std::cout << "Base default ctor\n";
}
Base(const Base&)
{
std::cout << "Base copy ctor\n";
}
};

class Der : public Base {
public:
Der()
{
std::cout << "Der default ctor\n";
}
Der(const Der &)
{
std::cout << "Der copy ctor\n";
}
};

int main()
{
Der ader;
Der bder(ader);
}

!! buradaki sıralama çok önemli bir kural

-----------

class Base {
public:
Base()
{
std::cout << "Base default ctor\n";
}

Base(const Base&)
{
std::cout << "Base copy ctor\n";
}

Base(Base&&)
{
std::cout << "Base move ctor\n";
}
};

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

Der(const Der &other) : Base(other)
{
std::cout << "Der copy ctor\n";
}
};

int main()
{
Der ader;
Der bder(ader);
}

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

class Base {
public:
Base()
{
std::cout << "Base default ctor\n";
}
Base(const Base&)
{
std::cout << "Base copy ctor\n";
}
Base(Base&&)
{
std::cout << "Base move ctor\n";
}
};

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

int main()
{
Der ader;
Der bder = std::move(ader);
}

eğer türemiş sınıf nesnesi için türemiş sınıfın move ctorunu derleyici yazarsa 
derleyicinin yazdığı move ctor tıpkı containent compasitionda olduğu gibi memberlar için nasıl yapıyorsa
türemiş sınıf içindeki taban sınıf nesnesi içinde move ctor çağrılmasını sağlıycak

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

class Base {
public:
Base()
{
std::cout << "Base default ctor\n";
}
Base(const Base&)
{
std::cout << "Base copy ctor\n";
}
Base(Base&&)
{
std::cout << "Base move ctor\n";
}
};

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

Der(Der&& other) : Base(std::move(other)) 
{
std::cout << "der move ctor\n";
}
};

int main()
{
Der ader;
Der bder = std::move(ader);
}

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

atama operator fonksiyonları :

class Base {
public:
Base& operator=(const Base&)
{
std::cout << "Base copy assignment\n";
return *this;
}

Base& operator=(Base&&)
{
std::cout << "Base move assignment\n";
return *this;
}
};

class Der : public Base {
public:
Der& operator=(const Der& other)
{
Base::operator=(other);
//*(Base *)this = other; //bu şekilde de olur
std::cout << Der copy assignment\n";
return *this;
}

Der& operator=(Der& other)
{
Base::operator=(std::move(other));
std::cout << "Der move assignment\n";
return *this;
}
};

int main()
{
Der d1, d2;
d1 = d2;
d1 = std::move(d2);
}

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

class Car {
public:
void start()
{
std::cout << "Car::start\n";
}
};


class Volvo : public Car {
void start()
{
std::cout << "Volvo::start\n";
}
};

class Audi : public Car {
void start()
{
std::cout << "Audi::start\n";
}
};

class Renault : public Car {
void start()
{
std::cout << "Renault::start\n";
}
};

void car_game(Car* ptr)
{
ptr->start();
}

int main()
{
Audi a;
Renault r;
Volvo v;

car_game(&a);
car_game(&r);
car_game(&v);
}

--------------
run time polimorfiz

//dynamic binding 

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


class Volvo : public Car {
void start()
{
std::cout << "Volvo::start\n";
}
};

class Audi : public Car {
void start()
{
std::cout << "Audi::start\n";
}
};

class Renault : public Car {
void start()
{
std::cout << "Renault::start\n";
}
};

void car_game(Car* ptr)
{
ptr->start();
}

int main()
{
Audi a;
Renault r;
Volvo v;

car_game(&a);
car_game(&r);
car_game(&v);
}

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

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 

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