4. Hafta

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

class hatırlatma:
----------------

class Nec {
public:
  void func(int);
};

int main(void)
{
Nec mynec;
auto p = &mynec;

//mynec.func(13);
(*p).func(34);
p->func(46); 
}

---------------------
protected : kalıtım ile işimize yarıycak

--------------------
// sınıfın üye fonksiyonları sınıfın private bölümüne erişebilir

class Nec {
public:
void func(Nec &r);
private:
int mx, my;
};

//nec.cpp
Nec gnec;
void Nec::func(Nec &r)
{
mx++;
r.mx = 56;
--gnec.my;
}

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

//nec.h
class Nec {
public:
  void func() //ODR çiğnenmez
  {
    ///
  }
private:
  int mx, my;
};

-----------
constexpr int foo(int x)
{
return x * x;
}

int main()
{
int a[foo(10)];

constexpr auto val = foo(5); //bu şekilde derleme zamanında çalışma garantisi olur

std::array<int, foo(29)> ar{};
}

---------------------------------------------------
!! bu şekilde headder ve cpp dosyalarında yazılır class

//bugra.h
#ifndef BUGRA_INCUDED
#define BUGRA_INCUDED

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

#endif

//bugra.cpp
#include "bugra.h"

#define PUBLIC
#define PRIVATE

PUBLIC void Myclass::foo(int x)
{

}

PRIVATE void Myclass::bar(int x, int y)
{
///...
}

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

this keyword:
-------------

- 'this' is a keyword

- 'this' is a pointer, hangi nesne için çağrıldıysa o nesnenin adresini kullanır

- herhangi bir başlık dosyasını eklememize gerek yoktur

- sadece non-static'de kullanılır, global(free function) veya static de kullanılamaz

void foo()
{
this; //hata verir
}

----

class Myclass {
void func()
{
this; //hata vermez
}

static void foo()
{
this; //hata verir
}
}

----
!! hangi nesne için çağrıldıysa o nesnenin adresini kullanır

class Myclass {
public:
void foo()
{
std::cout << "this = " << this << '\n';
}
private:
int mx{}, my{};
};

int main()
{
Myclass m;

std::cout << "&m = " << &m << '\n'; //aynı adres yazar
m.foo(); 
Myclass* pm = &m; //aynı anlama gelir
pm->foo();
}

----

- this is a pr value  

class Myclass {
public:
void foo();
private:
int mx{}, my{};
};

void Myclass::foo()
{
Myclass m;
this = &m; //sentax hatası olur
}

----

class Myclass {
public:
void foo();
private:
int mx{}, my{};
};

void Myclass::foo()
{
Myclass mz;
*this = mx; //hata olmaz

(*this).mx = 56;
this->mx =56;
Myclass::mx = 56;
mx = 56; //hepsi aynı anlama gelir
}

int main()
{
Myclass m;
m.foo();
}


!! non-static üye fonksiyonu içinde this fonksiyon hangi nesne iiçn çağrıldıysa onun adresi olur
                                    ----

!! non-static üye fonksiyonu içinde *this fonksiyon hangi nesne iiçn çağrıldıysa onun kendisi  olur
                                    ------

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

this kullanımının önemli olduğu alanlar

class Myclass {
public:
void foo();
private:
int mx{}, my{};
};

void gfunc1(Myclass* p)
{

}

void gfunc2(Myclass& r)
{

}

void Myclass::foo()
{
//gfunc çağırmanın tek yolu this çağırmaktır
gfunc1(this);
gfunc2(*this);

}

int main()
{
Myclass m;
m.foo();
}

----------

C# java gibi dillerde fluent API terimi vardır
c++'da bunun yerine chainig terimi kullanılır

class Myclass {
public:
Myclass& foo();
Myclass& bar();
Myclass& baz();

private:
int mx{}, my{};
};

Myclass& Myclass::foo()
{
++mx;
++my;

return *this;
}

Myclass& Myclass::bar()
{
++mx;
++my;

return *this;
}

Myclass& Myclass::baz()
{
++mx;
++my;

return *this;
}
int main()
{
Myclass m;

//m.foo();
//m.bar();
//m.baz(); //bu şekilde yazmak yerine aşğıdaki gibide yazılabilinir

//m.foo().bar().baz();   //channing
}

--------

int main()
{
using namespace std;

int x{34};
int y{323};
double dval{4565.1};

cout << x << y << dval; //channing örneği

cout.operator<<(x)..operator<<(y).operator<<(dval); //301 ile aynı anlamda 
}

---------

this pointerını mecburi kılan kısımmlar:
!! bir üye fonksiyonu içinde nesnenin kendisini veya adresini global bir fonksiyona göndermemiz gerektiği 
zaman kullanırız

class Tamer {
public:
Tamer* foo() {return this};
Tamer* bar() {return this};
Tamer* baz() {return this};
};

int main()
{
Tamer* p = new Tamer;

p->bar()->foo()->baz();
}

!! bu durumlar dışında this keywordü çok kullanma, çirkin bir görüntü

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

const member function:
---------------------
!! burası çok önemli 

Mutator : Değiştirici
Accessor : Erişimci

void func(T *);
void foo(T &);

void func(const T*);
void foo(const T&);

class Fighter {
public:
  void shoot();
};

---

class Nec{
public:
  void foo(); //mutator, non-cost member function
  void foo()const; //accessorx, const member function
};

---------------------------------
sentaks kuralları: 

a) const üye fonksiyonları içinde 
sınıfın non-static veri elemanlarına atama yapamayız

b) const üye fonksiyonu içinde non-const üye fonksiyonu doğrudan ismi ile çağırılamaz ( const T* ==> T* olmaz)

c) const sınıf fonksiyonları için sadece sınıfın const üye fonksiyonlarını çağırabiliriz

class Myclass {
public:
void foo()const
{
(*this).mx = 56; //hata olur
mx = 34; //hata, 371 ile aynı anlamda

Myclass m;
auto b = mx; //Legal
m.mx; //legal

bar(); //illegal, const T* ==> T* olmaz
}

void bar()
{
foo(); //legal
}

private:
int mx;

};

---

class Myclass{
public:
void foo()const
{
bar(); //burada hata olmaz
//const fonksiyonlar const çağırabilir
}
void bar()const;

private:
int mx;
};

int main()
{
}

------

class Myclass{
public:
void foo()const;
void bar()const;

private:
int mx;
};

int main()
{
Myclass m;
m.foo(); //hata olmaz
m.bar(); //hata olmaz

}

----

class Myclass{
public:
void foo()const;
void var();

private:
int mx;
};

int main()
{
const Myclass m;
m.foo(); //hata olmaz
m.bar(); //hata olur //const t* ==> t* dönüşüm yoktur

}

----

class Myclass{
public:
Myclass* foo()const
//const Myclass* foo() //böyle yaparsak hata olmaz, const t* ==> const t* dönüşüm olur
//const Myclass* foo()const //böyle yaparsak hata olmaz
{
return this; //hata olur const t* ==> t* dönüşüm olmaz
}

private:
int mx;
};

int main()
{
const Myclass m;

m.bar(); 

}

-----

class Myclass{
public:
Myclass& foo()

{
return *this; //hata olmaz 
}

private:
int mx;
};

int main()
{
const Myclass m;

m.bar(); 
}

-----

class Myclass{
public:
const Myclass& foo()
//Myclass& foo()const //hata olur
{
return *this; //hata olmaz, t& ==> const t& dönüşüm var
}

private:
int mx;
};

int main()
{
const Myclass m;

m.bar(); 
}

-----

class Myclass{
public:
void foo(); //burası nesneyi değiştirmek istiyor

private:
int mx;
};

int main()
{
const Myclass m; //burası kendini değiştirmek istemiyor
m.foo(); //hata olur
}

-------

class Myclass{
public:

private:
};

void foo(Myclass*); //function overloading olur
void foo(const Myclass*);
void foo(Myclass* const); //function redaclaration

-------

class Myclass{
public:

private:
};

void foo(Myclass*); //function overloading olur
void foo(const Myclass*);

int main()
{
Myclass m;

foo(&m); //549 çağrılı
}

-----

class Myclass {
public:
void foo();
void foo()const; //ovarloading olur

private:
};

int main()
{
Myclass m;
m.foo();//562 çağrılır

const Myclass m;
m.foo(); //564 çağrılır
}

------

#include <iostream>
#include <string>

int main()
{
using namespace std;

const string name{ "TAMER"};

std::cout << name << '\n';
auto c = name[0];
name[0] = 'K'; //buraya hata verir
std::cout << name >> '\n';
}

-----

class String {
public:
char & front();
const char & front()const;
};

int main()
{
string name;
name.front() = 'A'; // hata olmaz

}

-----

class String {
public:
char & front();
const char & front()const;
};

int main()
{
const string name;
name.front() = 'A'; // hata olur

const string name;
auto val = name.front();

}

------

int main()
{
using namespace std;
string name{ "mert" };
//const string name{ "mert" }; //bu şekilde hata olır

name.front() = 'b'; //Hata olmaz
name.back() = 'k';
}

-----

mülakatlarda en sık sorulan sorulardan birisi

class Fighter {

public:
void foo()const
{
m_age++; //hata olur 
//++debug_call_count; //sentax hatası olur, bunu aşmak için mutable kullanılır

}
private:
  std::string m_name;
  int m_age;
  int power;
  //int debug_call_count; //üye fonskiyonların kaç kez çağrıldığına bakacak
  mutable int debug_call_count;

!! mutable sayesinde artık debug_call_count değiştirilmesi hata olmaz
};
int main()
{

}


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

// bir sınıf nesnesinin hayata gelmesi için sınıfn üye fonksiyonunun çağrılması gerekir

constructor (kurucu işlev): sınıf nesnesini hayata getiren fonksiyon
destructor (sonlandırıcı işlev): sınıf nesnesinin hayatını bitiren fonksiyon

constructor(ctor):
------------------
-sınıfın non-static member function olmalı global olamaz
-constructor keyfi olarak isimlendirilemez, sınıfın ismi ile aynı olmalı
-const member function olamaz
-geri dönüş değeri yoktur
-sınıfın constructarları birden fazla olabilir, overload edilebilir
-public olmak zorunda değildir, private ya da protected olabilir
-sınıfın construcları member selection ile çağrılamıyor

class Myclass {
public:
Myclass();
Myclass() const; //hata
int Myclass() //Hata;

-sınıfın constructarları birden fazla olabilir, overload edilebilir

Myclass(int);
Myclass(double);
Myclass(int, int);
Myclass(double);

};

------
-sınıfın construcları member selection ile çağrılamıyor

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

int main()
{
Myclass m;
Myclass* p { &m };
m.foo();
p->foo();

m.Myclass(); //hata
p->Myclass(); //hata
}

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

default constructer:
(varsayılan kurucu işlem)

-parametresi olmayan ya da tüm parametreleri default argument alan constructerdır

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

destructor (dtor): Bir sınıf nesnesinin hayatının (lifespan) bitmesini sağlayan fonksiyon
-----------------
~Myclass //bu şekilde gösterilir

-sınıfın non-static member function olmalı global olamaz
-destructor keyfi olarak isimlendirilemez, sınıfın ismi ile aynı olmalı
-const member function olamaz
-geri dönüş değeri yoktur
-Bir sınıfın destructor'ı paramtere değişkenine sahip olmayan
-sınıfın destructor birden fazla olabilir, overload edilebilir
-public olmak zorunda değildir, private ya da protected olabilir
-sınıfın construcları member selection ile çağrılamıyor
-sadece ileride öğreniceğimiz özel bir seneryoda kullanılmak üzere bir sınıfın  dtor'ı ismiyle çağırabiliriz
  placement new

class Myclass {
public:
~Myclass();
}

int main()
{
{
  Myclass m;
} 
}

!! sınıfın 
a) default ctor'ı 
b) destructor'ı 

aynı zamanda sınfın "special member function" kategorisindedir.

special member functions:

default ctor (constructor)
destructor 
copy ctor
move ctor (C++)
copy assignment
move assignment (C++)

Bu fonksiyonlara special member denmesinin nedeni
bu fonksiyonların kodlarının (belirli koşullar sağlandığında) derleyici tarafından bizim için yazılabilmesi

derleyicinin bunların kodunu yazması ==> default etmesi

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

storage duration (storage class):

-automatic storage class
-static storage class
-dynamic storage class
-thread-local storage

Global sınıf nesneleri :
-------------------------
eğer global ise main fonksiyonu çağrılmadan hayat başlar

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

~Myclass()
{
  std::cout << "myclass destructor\n";
}
};

Myclass g;

int main()
{
std::cout << "main basladi\n";

std::cout << "manin sonra eriyor\n";
}

-----------

class Myclass {
public:
Myclass()
{
  std::cout << "myclass default ctor this =" << this << '\n';
}

~Myclass()
{
  std::cout << "myclass destructor this = " << this << '\n';
}


void foo()
{
std::cout << "Myclass::foo() this " << this << '\n';
}

};

class Nec {
public:
Nec()
{
  std::cout << "Nec default ctor this =" << this << '\n';
}

~Nec()
{
  std::cout << "nec destructor this = " << this << '\n';
}


void foo()
{
std::cout << "Nec::foo() this " << this << '\n';
}

};

Myclass g_myc; //sırayla çağrılır
Nec g_nec; //hayata daha sonra gelen daha önce veda edicek(son giren ilk çıkar)

int main()
{
std::cout << "main basladi\n";
std::cout << "main sonra eriyor\n";
}

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

aynı programın farklı kaynak dosyalarında tanımlanan global sınıf nesnelerinin

ctor'larının çağrılma sırası
dil tarafından belirlenmiş değildir

emrecan.cpp
  A ga;
bilge.cpp
  b gb;
melike.cpp
  C gc;

çağrılmas sırası 
ga gb gc , bu şekilde de olabilir
gc ga gb bu şekilde de olabilir

bu soruna static init. fiasco denir.
          -------------------

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

class Myclass {
public:
Myclass()
{
  std::cout << "myclass default ctor this =" << this << '\n';
}

~Myclass()
{
  std::cout << "myclass destructor this = " << this << '\n';
}
};

void foo()
{
static Myclass m;
}

int main()
{
std::cout << "main basladi\n"; //bunların çıktılarını incele
foo(); //birden fazla çağırsakta aynı sonuç karşımıza çıkar static olduğu için tekrar oluşturulmaz
foo();
foo();
std::cout << "main sona eriyor\n";
}

!! static anahtar sözcüğü ile tanımlanan yerel sınıf nesneleri ancak o fonkssiyon çağrıldığında hayata gelicek
ve programın sonuna kadar hayatları devam edicektir. tekrar çağrırsak aynı nesne olur

-------------------
!!!

class Myclass {
public:
Myclass()
{
  std::cout << "myclass default ctor this =" << this << '\n';
}

~Myclass()
{
  std::cout << "myclass destructor this = " << this << '\n';
}
};

int main()
{
std::cout << "main basladi  [1]\n"; //ilk bu yazı çıkar
{
  std::cout << "main devam ediyır [2]\n"; //sonra bu
  Myclass m; //Myclass constructerın çağırılıcak
  std::cout << "main devam ediyor  [3]\n"; //sonra bu çıkıcak
  //4 yazısı çıkmadan destructor çağırılacak, çünkü nesnein closing braceine gelmeden önce destructor çağırılır
}

std::cout << "main sona eriyor[4]\n"; //en son burası çağırılıcak  
}


--------

class Myclass {
public:
Myclass()
{
  std::cout << "myclass default ctor this =" << this << '\n';
}

~Myclass()
{
  std::cout << "myclass destructor this = " << this << '\n';
}
};

void foo()
{
Myclass m;
}

int main()
{
foo(); //otomatik ömürlü olduğu için her çağrı için önce constructor sonra destructor  çağırılacak
foo();
foo();
foo();
}

---------

class Myclass {
public:
Myclass()
{
  std::cout << "myclass default ctor this =" << this << '\n';
}

~Myclass()
{
  std::cout << "myclass destructor this = " << this << '\n';
}
};

Myclass g;

int main()
{
Myclass m1;
{
Myclass m2;
{
Myclass m3;

}
}
}

-----------

!! çok popüler bir cpp sorusu

//birden 100'e kadar sayıları ekrana yazdırın ama döngü kullanmadan

class Myclass {
public:
Myclass()
{
static int cnt{ 0 };
std::cout << ++cnt << ' ';
}
};

int main()
{
int a[100]; //her nesne hayata geldiğinde contructar meydana gelicek 
}

--------------------------------
RAII idiyomu constructerın kaynağı edinmesi nesnenin bu kaynakları kullanabilmesi 
nesnenin işi bittiği zaman destructarın o kaynakları geri vermesi


!! bir sınıfın default consteructerının olması olmamasına göre çok daha doğal ve sık karşılaşılınır
yüzde 90-95 default constructer bulnur

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

int main()
{
Myclass m1; //sınıf nesneleri default init. yapıldığında default constructer çağırılır
Myclass m2{} //value init. default constructer çağırılır
}

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

parametreli constructer :

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

int main()
{
Myclass m1(10); //direct init
Myclass m2 = 20; //copy init
Myclass m3{57}; //direct list init
}

------

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

int main()
{
Myclass m1(10, 20); //2 paramtereli constructer çağırılıcak
Myclass m1{30, 40}; //bu şekilde de olur
}

------

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

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

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

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

int main()
{
Myclass m1(10); //def ctor
Myclass m2(3.434f);

Myclass m3(2, 4);
Myclass m4(2., 4.);
}

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

constructer init. list / member init. lis: 
sınıfın constructerının sınıfın non-static veri elemanları init. yapma sentexı

önce sınfın veri elemanları init ediliyor ondan sonra programın akışı 
constructerın ana bloğuna giriyor

class Myclass {
public :
Myclass()
{

}
private:
T tx;
U ux;
W wx;
}


---------

class Myclass {
public:
  Myclass()
  {
    mx = 0; //burada init. yapılmıyor yeniden değer veriliyor init çoktan yapılmış
    my = 0; //ilk değer vermek için constructer init. list / member init. list kullanılmalı
//BÖYLE ATAMA ASLA YAPMA
  }
private:
int mx, my;
};

--------
constructer init. list sentax:

class Myclass {
public:
Myclass();

private:
int mx, my;
};

Myclass::Myclass() : mx(10), my(20) {}
Myclass::Myclass() : mx{10}, my{20} //bu şekilde de olur
{
//ana blok olmak zorunda
}

------

class Myclass {
public:
Myclass() : mx(19), my(20) {}
void print()const
{
std::cout << "mx = " << mx << " my = " << my << "\n";
}
private:
int mx, my;
};

int main()
{
Myclass m1;
m1.print();
}

-------

class Myclass {
public:
//ub 
Myclass() : mx(19), mx(my / 3) {}

private:
int mx, my;
};

int main()
{

}

----------
class Point {

public:
point(double x, double y) : mx{x}, my{y} {}
void print()const
{
std::cout << "(" << mx << ", " << my << ")\n";
}
private:
double mx, my;
};

int main()
{
Point p1{4., 7.};
p1.print();
}

-----

class Myclass {
public:
Myclass()
{ //burada sentax hatası olur nedeni derleyicinin eklediği kodun mx'İ default init. etme girişimi

}
private:
const int mx;
}

------

class Myclass {
public:
Myclass()
{
mx = 7; //yine hata olur çünkü burası init.  değil yeniden atama
}
private:
const int mx;
}

------

class Myclass {
public:
Myclass(int &r) : mx(r) //hata olmaz
{

}
private:
int &mx;
};

------

class Myclass {
public:
Myclass(int &r) : mx(r)
{

}
private:
int &mx;
};

int main()
{
using namespace std;

cout << "ival = " << ival << '\n';
Myclass m(ival);
m.foo();

cout << "ival = " << ival << '\n';  
}

------

!! sınıfın veri elemanı eğer referans ise ya da const ise constexture init. list kullanmak zorundıyız

-----

!! çok tipik yapılan bir hata

class Person {
public:
Person(const char * p)
{
m_address = p;
}

private:
std::string m_address;
};

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

modern c++'da en fazla yanlış anlaşılan konu

class Myclass {

public:
void print() const
{
std::cout << mx << ' ' << my << '\n';
}

private:
int mx = 10;
int mx(10); //hata
int mx = {10}; //legal
int my = 20;
};

//modern c++ c++11 ile geldi
//yukarıdaki duruma
//default member init.
//in-class init.

//derleyici sınıfın default constructerlarını default ederken bütün elemanları default init yapmak zorunda

int main()
{
Myclass m; //garbage value olur çünkü derleyici default init yaptı
m.print();
}

-------

class Myclass {

public:

Myclass() : mx(46), my(98) //hata olmaz cevap 46, 98 değeri yazar
//default member init kullanmıyorum diyoruz
{

}

void print() const
{
std::cout << mx << ' ' << my << '\n';
}

private:
int mx = 6; //burada biz bunları init. yapmış olmuyoruz, derleyiciye ben init. yapmassam sen bu değerler ile init yap diyoruz
int my = 9;
};

int main()
{
Myclass m;
m.print();
}

----------
//ileri bir örnek
class Person {
public :
void print() const
{
std::cout << "isim : (" << m_name << ")\n";
std::cout << "soyiism : (" << m_surname << ")\n";
}
private :
std::string m_name;
std::string m_surname;
};

int main()
{
Person pnec;
pnec.print();
}

-------

class Point{
public:

private:
double mx{}, my{}, mz{};
};

int main()
{
using namespace std;
}


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


delete : bu fonksiyon var ama bu fonksiyona çağrı yapılırsa çağrı sentax hatası oluşturucak
-------

class Myclass {
public:
Myclass(int) = delete;
void foo(int, int) = delete;
};

void func(int) = delete;

int main()
{
func(12); //delete edilmiş bir fonksiyon çağrı yaptığın için sentax hatası
}

------

void func(int);
void func(double) = delete;
void func(long);


int main()
{
func(1.2); //hata olur
func(1); //hata olmaz
}

---------

// mülakat sorusu
öyle bir fonksiyon oluşur ki sadece int iile çağrılsın

template <typename T>
void func(T) = delete;

void func(int);

int main()
{
func(2.3);
}

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

sınıfların özel üye fonksiyonları:
----------------------------------

defauult ctor
destructor
copy ctor
move ctor
copy assignment
move assignment

//derleyici bizim yerimize fonksiyonları default eder


yukarıda fonksiyonlardan herhangi biri 3 statüden biri olabilir

-not declared : fonksiyonun olmaması demektir
-user declared : özel üye fonksiyonun kullanıcı tarafından bildirilimesine denir
  a) user defined
  b) = default
  c) = delete
-implicitly declared : bir fonksiyonun programcı tarafından açıkça bildirilmediği, ancak kullanıldığında derleyicinin otomatik olarak bir bildirim oluşturduğu durumu ifade eder. 
  a) default
  b) delete

------------
not declared  :

class Myclass {
public:
Myclass(int); //not declared
};

int main()
{
Myclass m;
}

--------
user declared :

class Mycşlass {
public:
//deafult bildirimi derleyicye bunu bildiyorum ama emrediyorum sen tanımlıycaksın demek
Myclass() = default; //user decalred
};

--------

class Myclass {
public:
Myclass() = delete; //user declared, var ama çağrılması sentax hatası anlamında
};

---------
implicitly declared :
sınıfın özel üye fonksiyonunu bildirmesekte derleyici bunu örtülü olarak bildirir

!!bir özel üye fonksiyon implicitly declareted derleyici bunun kodunu yazarken sentax hatası oluşturur derleyici sentax hatası vermek yerine
özel üye fonksiyonu delete eder. 

class Myclass {
public:

private:
int &r; //sınıfın default constructerı delete edildi
çünkü derleyici default init yapar referans değişkenlerinnin default init yapılması sentax hatası ondan delete eder
};

int main()
{
Myclass m;
}

-------
class Myclass {
public:

private:
const int x; //derleiyici default inşt yapar (imlicitly declaret) const nesnenin default init yapılması geçerli değil
bundan dolayı delete edilir  
};

int main()
{

}
----------

class Member {

};

class Tamer {
private:
Member mx; //default init yapıldı
//default init yapılan sınıf türünden ise onun default init edilmesi default constructarın çağrılması demektir
};

int main()
{
Tamer tx; 
}

-------

class Member {
public:
Member(int); //memberın default constrıctır yok
//tamerin default constructarını derleyici default ettiğinde olmayan bir default constructara çağrı yapacak ancak default constructerı yoktur
bu da sentax hatasıı olucak, bu yüzden delete etmek zorunda
};

class Tamer {
//implicitly decllared delete
private:
Member mx; 

};

int main()
{
Tamer tx;  //hata olur
}

----------
BURADAKİ KURALLAR ÇOK ÖNEMLİ

1) hangi durumda derleyici bir sınıfın bir "special member function" default eder
2) Nasıl default eder?


!! invariant: bazı önemli bilgilere denir sınıfın içinde yer alır. mesela üçgen ile ilgili bir sınıfta kenarların negatif olmaması invariant bir bilgidir   
!! eğer biz bir koruma yapmıycaksak invariantların kontrolünü programcıya bırakıcaksak invariant uygulamıycaksak böyle sınıflar ilave kurallara sahip bunlara arrigınt denir

class Myclass { // yanlış bir kod hem elemanları gizlemiş hemde referans vermiş

public:
int & get_mx()
{
return mx;
}

int &get_my()
{
return my;
}

private:
int mx;
int my;
};

int main()
{
Myclass m;
m.get_mx() = 5;
m.get_my() = 33;
}

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

copy constructor (cc):  
---------------------

eğer bir sınıf nesnesi hayata değerini aynı türden 
bir başka sınıf nesnesinden alarak geliyor ise

Person necati {...};

Person ali = necati; //copt constructor çağırılır

----------
!! bir fonksiyonun paramtere değişkeni fonksiyon tanımı içinde kullanılmıyacaksa asla ona isim vermeyin
int func(int x, int y)
{
return x *x
}
-----------

class Nec {
public:
Nec() //default construcor
{
std::cout << "default ctor this : " << this << '\n';
}

~Nec() //destrucator
{
std::cout << "destructor this: " << this << '\n';
}
};

void foo(Nec) //copy constructor çağırılıyor
{

}
int main()
{
Nec mynec;
std::cout << "&mynec = " << &mynec << '\n';

foo(mynec);
std::cout << "main devam ediyor\n";
//2 tane dectructor çağırılır çünkü copy constructor çağırılıyor
}

----------

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

Nec(const Nec& r)
{
std::cout << "copy ctor this : " << this << '\n';
std::cout << "&r in copy ctor : " << &r << '\n';
}

~Nec() //destrucator
{
std::cout << "destructor this: " << this << '\n';
}
};

void foo(Nec)
{

}
int main()
{
Nec mynec;
std::cout << "&mynec = " << &mynec << '\n';

foo(mynec);
std::cout << "main devam ediyor\n";
//2 tane dectructor çağırılır çünkü copy constructor çağırılıyor
}

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

copy constructer devam...

!! copy constructer ne zmaan çağırılıyor
a) sınıf nesnesi hayata getirmek gerekiyor
b) sınıf nesnesini hayata getirirken aynı sınıf türünden bir başka sınıf nesnesi ile onu init yapmak gerekiyor

copy constructer çağrılmasını bekledğimiz tipik sneryolar

class Nec {

};

int main()
{
Nec x; //default ctor
Nec n1 = x; //copy ctor
Nec n2(x); //copy ctor
Nec n3{x}; //copy ctor
auto n4(x); //copy ctor
auto n5{x}; //copy ctor

!! biz user declaretede yapmaz isek derleyici tarafından implicit olarak bildirilir
}

//derleyicinin örtülü olarak (implicitly) bildirdiği ve tanımladığı herhangi bir special member function 
sınıfın non-sttaic, inline, public memer functionlarıdır


----------------
class A {};
class B {};
class C {};

class Myclass {
public:
~Myclass()
{
}

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

------------
rule of zero : sınıfın özel üye fonksiyonlarını derleyici tarasıfından yazılmasını sağlamaktır 

class Myclass {

public:

private:
int mx{}, my{}, mz{}; //default member init.
};

----------
class Date {
public:
Date() = default; // user declareted yapıp tanımını derleyiciye bırakabiliriz
Date(int, int, int); //bu şekilde sınıfın default const not declaret hale gelir
//dolayısıyla derleyici bunu default etmez default etmesini istiyorsak yukarıdaki uygulayabiliriz

private:
  int m_day{1};
  int m_mon{1};
  int m_year{1900};
};

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

value type : 
value semantics : her nesnenin değeri kendine
nesneler birbirine atandıkları zaman bağımsızlıklarını koruyolar 

x = y

// mülakat sorusu
string sınıfı bir value type'Mı ? evet

Date x{12, 6, 2021};

Date y = x;

if (x == y) {

}

//x'i değiştirirsek y kendi değerini korumalır (value type)
y'i değiştirirsek x kendi değerini korumalır

!! bu açıdan bakılınca pointerlar value type değildir

int main()
{
char str[] = "damla kubat";

char * p1 = str;
char * p2 = p1;

p1[5] = '\0';
std::cout << p2;
}


-----

derleyicinin yazdığı copt constructer

class A {};
class B {};
class C {};

class Myclass {
public:
  Myclass(const Myclass& other) : ax(other.ax), bx(other.bx), cx(other.cx) {}
private :
  A ax;
  B bx;
  C cx;
};

---------

class Date {
public:
  Date() = default;
  Date(int d, int m, int y) : md(d), mm(m), my(y) {}

void set_year(int y)
{
my = y;
}
void print()const{
std::cout << md << '-' << mm << '-' <<my <<'\n';
}
private:
  int md{1}, mm{1}, my{1900};
};

int main()
{
Date today{18, 8 ,2023};
today.print();

auto mydate = today;
mydate.print(); //aynı tarih yazar
//bu sınıfın copt constructerı vardır çünkü ümlicitly declareted

mydate.set_year(2023);
mydate.print();

today.print();
}

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

// üretimde çok büyük olasıkla copy constructer derleyici tarafından yazılacak

neden copy constructer kendimiz yazmamız gerekir

bazı durumlarda biizm sınfımızın veri elemanları kaynak ya da kaynkları kontorl eden handlelar(pointer veya referans)

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

#include <iostream>
#include <string>
#include <cstring>

class Addrees
{
public:
  Addrees(const char *p) : mlen(std::strlen(p)), mp{static_cast<char *>(std::malloc(mlen + 1))}
  {
    if (!mp)
    {
      throw std::runtime_error{"not enough memory"};
    }
    std::cout << static_cast<void *>(mp) << "adresindeki bellek blogu edinildi\n"; // yazının tutulduğu adresi yazdırır
    std::strcpy(mp, p);
  }
  ~Addrees()
  {
    std::cout << static_cast<void *>(mp) << "adresindeki bellek blogu geri verildi\n";
    std::free(mp);
  }
  void print() const
  {
    std::cout << mp << '\n';
  }
  std::size_t lenght() const
  {
    return mlen;
  }

private:
  std::size_t mlen;
  char *mp;
};

void process_address(Addrees x)
{
    std::cout << "process_address fonsksiyonu cagrildi\n";
    x.print();
    (void)getchar();
}

int main()
{
  using namespace std;
  
  Addrees adx{"buyukdere mah. ozan sokak. no 12 istanbul"};
  adx.print();
  cout << "adress uzunlugu " << adx.lenght() << '\n';
  
  process_address(adx);
  std::cout << "main devam ediyor\n";

  adx.print(); //ub, dangling pointerdan dolayı,
  //derleyicinin yazdığı copy constrectır işleri bozdu
  //bu durumu düzeltmek için copy constructerı kendimiz yazarız 
  //her snıf türünden nesneler kopyalamaya açık olmayabilir bu yüzden kendimizi yazmamaız gerekebilir
}

----------

shollow copy : sadece pointerların kopyalanamsı
deep copy : kaynakların kopyalanması