2. Hafta

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

int * const p = &x; //top level const
const int * p = &x //low level const 

!! referans semantiğinde bu const gereksiz çünkü referansların tanımı gereği
başka bir nesneye bağlanması mümkün değildir

const int & r = x; //sadece okuma amaçlı

T * ===> const T * //legal
const T* ===> T * //illegal

-----------

struct Data {
int a;
};

void func(const Data&);

int main()
{
Data mydata = {23};
const Data cdata = {23};
func(mydata);
func(cdata);
}

----------

int * func(void)
{
int x = 10;

return &x; //hayatı bitmiş değeri geri dönüş ile yollamayız static olması gerekiyor
//dangling pointer
}

----

int & func(void)
{
int x = 10;
return x; //referans semantiği ile de u.b.
}

-------------------------
int (*func())(int, int)
{

}

trailing return type ile yazımı
auto func() -> int (*)(int, int)
{

}

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

struct Data {
int x,y,z;
};

Data& bar(Data & r) //fonksiyon adlığı nesneyi döndürüyor
{
++r.x;
++r.y;
++r.z;

return r;
}

int main()
{
using namespace std;

Data mydata{1, 5, 7};
Data & dr = bar(Mydata);

cout << dr.x << dr.y<<dr.z<<"\n";
}

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

pointer ile yazımı

struct Data {
int x,y,z;
};

Data * bar(Data * r) //fonksiyon adlığı nesneyi döndürüyor
{
++r->x;
++r->y;
++r->z;

return p;
}

int main()
{
using namespace std;

Data mydata{1, 5, 7};
Data * dr = bar(&Mydata);

cout << dr->x << dr->y<<dr->z<<"\n";
}

------------------------------------------------
!! R value ve L value ifadelerini böyle incele

int x = 5;
++(x = 9); 

++ operatörünün operandı L value olmalı ancak (x= 9) r value o yüzden sentax hatası

---------------------------------------------------
!! eğer referans const L value referans ise R value expression ile ilk değer verebiliriz

int main()
{
int x = 10;

double &r = x; //illegal
const double &r = x; //legal
}

           L value         const L value    R value
T &     :  bağlanabilir    bağlanamaz       bağlanamaz
const T&:  bağlanabilir    bağlanabilir     bağlanabilir

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

// c dilinde bu şekilde yazmak okuyucaya x başka yerde de kullanılcak anlamı verebilir
int main()
{
int x = 10;
if (x > 10){
//use x
}
}

//c++ da yukarıdaki ifadeden dolayı böyle yaz
int main()
{
if (int x = foo(); x > 10){
//use x
}
}

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

!! referans == pointer (asembly tarafında)

int main()
{
int x = 10;
int * p = &x;

int ** ptr = &p; 
// pointerın pointerı olur ancak referansın referansı olmaz
}


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

pointerları default init yapılır, referans yapılamaz:
int *ptr;                               int &r;

pointer to pointer kavramı vardır, referansın yerine referans olma yoktur
int **p;                             int && r;

nullptr var, null referans yoktur:

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

int main()
{
int ar[10]{};
int&r = ar; //dizinin ilk elemanına referans olmaz

}

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

int main()
{

myclass &l //l value
myclass &&r //r value
}

---------
int foo();

int main()
{
int x = 20;

int&& r = x;
}

//r value refeansı l value expression ile init. yapılamaz

int & foo();

int main()
{
int x = 20;
int && r = foo();
}

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

type deduction (tür çıkarımı) : öyle yerler var ki türü açıkça yazmamamıza rağmen tür çıkarımı ile türü kastetmiş oluruz

!! tür çıkarımı run time ile ilişkisi olmaz derleme zamanında olur her şey

auto type deduction :
---------------------
!! tür çıkarımı auto için yapılır

int main()
{
auto x = expr; auto yerine gelicek türü derleyici bulur
}

--------

AAA : almost always auto

--------
Aşağıdaki 3 ifadeninde kuralı farklıdır

auto x = expr;

auto &y = expr;

auto &&z = expr; //universal reference

----------
auto x = expr;

int main()
{
auto x = 10; //int x = 10;
}

------

int main()
{
const int x = 10;
auto y = x; //const int y = x; olmaz, const düşer
}

------

int main()
{
int x = 10; //x'in türü int
int* x = 10; //x'in türü int*
int & r = x; //r'nin türü int

auto y = r; // auto türü int, int & değil
}

----

int main()
{
int a[10]{};
const int b[10]{};

auto b = a; //int * b = a;
auto p = b; //const int *, arraylerde const düşmez
}
-----

int main()
{
auto ps = "mucahit"; //const char * = ps
}

------

int func(int); //türü int(int)
&func //türü int (*)(int)

-------

int func(int);

int main(int);
{
auto x = func; // int (*x)(int) = func;
}

------

int main(int);
{
int x = 10;
int * p = &x;

const auto y = p; //int * const y
}

------------------------------------------
auto &y = expr;

int main()
{
const int x = 10;

auto& y = x; //const int & = y, burada const düşmez 
}

-------

int main()
{
int a[5]{};

auto &b = a; //int (&b)[5] = a; 
}

-----

int main()
{
auto & x = "eren"; //const char (&x)[5]
}

--------

int foo(int);

int main()
{
auto f = foo; //auto ==> int(int)
int(&f)(int) = foo;
}

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

using : typedef yerine kullanılır

using Word = int;

typedef const int * cptr; //using ciptr = const int *

typedef int inta20[10]; //using inta20 = int[20]

typeded int (*FCMP)(const char*, const char *); //using FCMP = int (*)(const char*, const char *)


-------------------------------------
c++ dlinde referansa referans olmamasına karşın 
öyle yerler var ki referansa referans oluyor

reference collapsing :
---------------------

using rref = int&&;
rref && x = 10;
-----

T&  &   ===>  T&
T&  &&  ===>  T&
T&& &   ===>  T&
T&& &&  ===>  T&&

-----
using lref = int&;

int main()
{
int x = 45;
lref& r = x; //l value

int x = 45;
rref&& r = x; //r value olur

}

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

Kaç çeşit referans vardır :

R value --> int& x =
L value --> int&& x =

Universel referans 
------------------

auto &&r = 

Yukarıdaki durumda yani r bir universal referance ise 
- her değer kategorisindeki ifadeye bağlanabilir
           L value / R value (Pr || X)
           const ya da non cost

int main()
{
int x = 5;
const int y = 67;

auto && r1 = x;
auto && r2 = 10;
auto && r3 = y;
}

--------
auto &&r = x;

eğer ilk değer veren ifadenin değer kategorisi L value ise
o zaman auto için yapılan çıkarım sol taraf referans türü olur
ama r değişkenin türü yine "referans collapsing" ile l value ref. olur T &

int &&r = 10;
eğer ilk değer veren ifadenin değer kategorisi R value ise
o zaman auto için yapılan çıkarım sol taraf referans olmayan tür olur ==> T
ama r değişkenin türü yine l value ref. olur

!! kural : Universal referansa l value ile ilk değer verirsek l value referans olur 
                               R value ilk ilk değer verirsek R value referans olur 

int main()
{
auto && x = 10; //int && x = 10;
}

int main()
{
int ival { 4 };
//int& && -> referans collapsing devreye girer derleyici gözüyle int & x yazmış oluruuz
  auto && x = ival; //int && x = 10;
}

... devamı daha sonra işlenicek

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

declytype specifier :
---------------------

decltype(expr) : 
//derleyici gözüyle bir tür bilgisi, derleme(compiler) time ile ilgili

!! decltype specifier ile yapışan tür çıkarımında iki ayrı kural seti var

------------------
1. kural seti : decltype expr isim olmalı

declytype(x)
declytype(a.b)
declytype(ptr->c)

------------------
2. kural seti : decltype operandı isim olmayan bir ifade olması

decltype(10)
decltype(x + 10)
declytype((x))

-------------------
1. kural seti örnekleri :

int main()
{
int x = 120;
decltype(x) //int yerine her yerde kullanılabilinir
decltype(x) y; //int y

const int x = 120;
decltype(x) //const int

int x = 5;
int & r{ x };
decltype(r) y = x; //int &y = x;

int &&r = 10;
decltype(r) x = 56; //int&& x

int && r = 10;
decltype(r)& x = 56; // hata olur sol taraf ref. r value ile ilk değer verilmez
}

int && r = 10;
decltype(r)&& x = 56; //legal, sağ taraf referansına sağ taraf referansı olur
//int  &&r = 56; 
}

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

int main()
{
int a[5]{};
//int[5]
decltype(a)b = a; //hata var
//int b[5] = a; diziye diziyle ilk değer verilmez
}

----

int main()
{
int [5]{};
decltype(a) b = {1, 4,}; //legal
}

----

int main()
{
int a[20]{};

decltype(a) * p = &a;
auto p = &a; //bu şekilde de yazılır
int(*p)[20] = &a; //bu şekilde de yazılır
}

-----------------
2. kural seti örnekleri :

Diyelim ki, (T bir tür olmak üzere) exp ifadesinin türü T olsun

eğer exp ifadesinin primary value category'si
           PR value ise elde edilen türü T 
           L value ise elde edilen türü T&
           x value ise elde edilen türü T&& 

---------

int main()
{
int x = 10;
decltype(x + 5); //int, (x + 5) PR value ise elde edilen türü T 
}

---------

int main()
{
int a[5]{};
decltype(a[2]); //int&, a[2] L value ise elde edilen türü T&
}

--------

int foo();
int & bar();
int && baz();

int main()
{
//foo() ==> PR value
//bar() ==> L value
//baz() ==> x value
}

-------

int main()
{
int x = 10;
int y = 20;

decltype(x)a = y; //int a = y;

decltype(x)a = y; //int &b = y

}

-----------------------------------------
!! sizeof operatörünün operandı için işlem kodu üretilmez

unevaluted context (işlem kodu üretilmeyen bağlam) : işlem kodu yürütülmiyceği için tanımısz davranış olmasının önemi yok

int main()
{
int * ptr = nullptr;
auto x = sizeof(*ptr); //ub yok
}

--------

int main()
{
int a[5]{};
int ival = 72;

auto b = a[5];

int x = 98;

int y;

auto c1 = a[5]; //ub
auto c2 = y; //ub
auto c3 = ival << x; //ub

sizeof c1 = a[5]; //ub değil işlem kodu üretilmez
sizeof(y); //ub değil işlem kodu üretilmez
sizeof(ival << x); //ub değil işlem kodu üretilmez
}

!! decltype verilen ifade unevaluted context

int main()
{
int x = 10;
decltype(++x) y = x; //x'in değeri hala 10 çünkü işlem kodu üretilmez

}

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

default argument (varsayılan argüman) : gereksiz risk almasından kaçınamsında kullanılıyır
---------------

void foo(...); //c'de geçerli değl c++ da geçerli

varsayılan argüman derleyici zamanında gerçekleşir

// normalde bu fonksiyonun 3 parametre değişkeni var ama ben 3. parametre değişkenine
argüman göndermeme hakkına sahibim

------

void func(int,int, int = 0); 

int main()
{
func (1,2,3);
func(1,2); //1,2,0
}

-----

void func(int = 1, int = 2, int = 3);

int main()
{
func(50,60,70);
func(50,60); //func(50,60,3);
func(50); //func(50,2,3);
func(); //func(1,2,3);           
}

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

int main()
{
int a = 10;
int b = 10;
int c = a+++b;

}

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

!! maximal munc kuralı : int c = a+++b; // a++ + b

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

void foo(const char*= "mustafa");
void foo(const char* = "mustafa");

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

void foo(int x, int y = x); //sentex hatası

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

int foo(int x = 5);
int bar(int x = foo());

int main()
{
bar(); //bar(foo(5));
}

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

ali.h

void foo(int,int,int);

//include "ali.h"

void foo(int, int, int = 10);

int main()
{
foo(2,5);
}

----------

void foo(int, int, int = 67);
void foo(int, int = 5, int);

int main()
{
foo(1); //foo(1, 5, 67);
}

-----------

// önceden belirlenmiş değerlerin girilmesi için kullanılabilinir
void process_date(int day = -1, int mon = -1, int year = -1)

int main()
{
process_date(); //process_date(2,8,2023);
}

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

void print_date(int day = -1, int mon = -1, int year = -1)
{
if (year == -1){

}

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

constexpr : değişkenin oluşturduğu ifade sabit ifadesi olarak kullanılabilir

const int x = 10;

!! const anahtar sözcüğü ile tanımlanan bir değişkene sabit
bir ifadeyle ilk değer verme mecburiyeti yok.

!! constexpr anahtar sözcüğü ile tanımlanan bir değişkene sabit
bir ifadeyle ilk değer verme mecburiyeti var.

int main()
{
int y = 245;
constexpr int x = y; //hata 
// x'in türü const int
}

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

constexptr int * const p = &g
constexptr int * p = &g //752 ile aynı anlamda
constexptr const int * p = &g //752 ile farklı anlamda


int foo();

const int x1 = foo(); //legal
constexpr int x2 = foo(); //illegal, constexpr ifadesine ilk değer veren ifade sabit ifadesi olmalı

const int x = 45; //legal
const int y = x * x//legal;

constexpr int ival = x*x + y * y; //legal

constexpr int primes[] = {2,3,2,2,1,3,,4,1,12}; //legal

constexpr int x = primes[4]; //legal

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

constexpr function :
--------------------

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

1. her fonksiyon constexpr fonksiyon olamaz
constexpr olması için belirli koşulları sağlaması gerekir

-static ömürlü yerel değişkene sahip olmayacak

constexpr int foo(int x)
{
static int y = x;
return y * y - 3;
}

2. eğer bir contexpr tüm paramterlerine sabit ifadeleri ile çağrı yapılırsa
fonskiyonun geri dönüş değeri derleme zamanında elde ediliyor


constexpr int x = foo(exp1, exp2, exp3) //bütün ifadeleri constexpr ise kendiside constexpr'dir

!! constexpr en önemli görevi compiler zamanda değeri belli olan ifade için run time'da kodu koşturmaz

x = sqrt(sin(y * 5) + cos(z * b)) //bütün değerleirn sabit ve hesaplamalrın derleme zamanında yapıldığını düşünelim

!! constexpr : benim tüm paramterlerime gönderdiğin değerler sabit ise geri dönüş değeri compiler time'da verilir
sabit ifadesi değil ise runtime'da belli olur

-----------

constexpr int ndigit(int x) //başına constexpr koyulduğu zaman hata vermiyor ise tüm şartları sağlamıştır
{
if ( x == 0)
return 1;

int digit_count{};

while (x) {
++digit_count;
x /= 0;
}
return digit_count
}

int main()
{
int x = 433;
const int x = 765;

constexpr auto val = ndigit(x * y - 19) //sabit ifadesi olmadığı için hata olur, başına constexpr konulup test edilebilinir
}


constexpr bool isprime(int val)
{
if (val < 2)
return false;
if (val % 2 == 0) return val == 2;
if (val % 3 == 0) return val == 3;
if (val % 5 == 0) return val == 5;

for (int i{7}; i * i <= val; i += 2){
if (val % i == 0)
return false
}
return true;
}

int main()
{
const int x = 4324;
const int y = 1243;

constexpr auto b = isprime(x * y - 14); //eğer asal ise hata vermez 
}


----------------------------
ODR  (One definitian rule)
inline functions
constexpr functions

bunlar birbiri ile ilişikilidir

=================================================================
!! bu kısım çok önemli

ODR (one definition rule): tek tanımlama kuralı
--------------------------
öyle yazılımsal varlıklar varki bunların tanımları programda tek olucak ancak bildirimleri birden fazla olabilir

int foo(int) //fonksiyonuun bildirimi

int foo(int)
{
//fonksiyonun tanımı
}

int g; //bildirimi
int g = 50; //tanımı

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

inline functions: ODR ' ihmal etmeme garantisi veriyor
-----------------

//ahmet.cpp
int foo(int x, int y)
{
return x * y - 5;
}

//bugra.cpp
inline int foo(int x, int y)
{
return x * y - 5;
}

!! aynı isimde 2 fonksiyon tanımlanmasına rağmen ODR ihmal edilmemiş olur (inline sahesinde)

!! bir fonksiyonun tanımını başlık dosyasına koyup aynı zamanda ODR'ı ihlal etmek istemiyorsan inline kullan 

statik ömürlü global değişken ve staitk ömürlü snıfların statik veri 
elamanları heoder on the file oluşturulamaz

//eskiden bu şekilde çözülürdü, inline sadece fonksiyonar için kullanılırdı

bugra.h
inline  int & get_g()
{
static int g = 10;
return g;
}

c++ 17 ile değişkenlerinde inline olma özellği geldi
inline int g = 10;



Neleri başlık dosyasına koyarsam ODR  ihlal etmemiş olurum
1) inline fonksiyon tanımları
2) inline değişken tanımları (c++17)
3) user-defined types tanımları
4) constexpr fonksiyonları imlicitly in

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

C++ dilinde enumaration types :
-------------------------------

enum Color {Blue, black, white, red};
- enum color türdür
- sabitlerdir
- tam sayı türündeler
- blue = 0, black = 1, ...

aritmetik türlerden enum türlerine implicit conversion yok

int main()
{
Color mycolor;
mycolor = 3; //cpp'de hata
}

C++ dilinde (modern c++ öncesi) enum türlerinin istenmeyen özellikleri :

1. underlying type derleyiceye bağlı olduğu için enum türleri başlık
dosylarında incompliete type olarak kullanılamıyor

2. enum türlerinden tamsayı türlerine dönüşüm yok

3. enumatör scopu enumutöre sahip türün scopu ile aynıdır

//traffic_light.h
enum TrafficLight {Red, Yellow, Green};
enum TrafficLight : int {Red, Yellow, Green}; //hata bu şekilde düzeltildi yeni sürümlerde

//screen.h
enum ScreenColor{Magente, White, Black, Red}
enum class ScreenColor{Magente, White, Black, Red} //yeni versiyonlarda geldi

//hata olur (isim çakışmasından dolayı, Red)



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

scoped enums

traditional enum
conventional enum
unscoped

enum class
scoped enums