14. Hafta

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

Lambda expression
-----------------

Deleyiciye sınıf tanıtan nesne

pr value expression

Derleyicinin lambda ifadesi karşılığında oluşturduğu sınıf türüne closure type denir

Oluşan nesnenin kendisine closure object

En çok kullanılan durumu stl algoritmasına argüman olarak yollamak


--------------
Genel Sentax

[] : lambda introducer, derleyici labda ifadesi ile karşılaştığını bununla anlar

[]() : derleyici yazdığı sınıfın fonksiyon çağrı operatör fonksiyonun parametre parantezi
[](int x){}

[]() {} : code yazılan kısım
[]() { // code}

----------------
class xyz23_87ds {
public:
void operator()()const
{

}
};

int main()
{
[]() {}(); //sentax hatası olmaz, hiçbir şey yapmaz

[ //dışardan aldığı param ]( // içerden aldığı param.) { //code }(//içerden aldığı param değerinin yazılması);
[=](int x) {
//code
}(12)
-----
xyz23_87ds{}() //aynı anlamda

}

-----------------
//aşağıdakiler gelebilir

[]() {//code}
[]()constexpr{//code}
[]()noexcept{//code}
[]()mutable{//code}
[]()-> type{//code}

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

//parametre değişkeni yok ise () yazılmasa da olur

int main()
{
[] {};
}

--------------------
//eski cpp 'da niteleyicilerden biri var ise () kullanılmak zoruda idi

int main()
{
[]()mutable{};
}

//cpp 23 ile bu özellik gitti

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

en basit kavramlardan başlıyoruz 

int main()
{
[](int x) {return x * x;}
}

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

class xyz13981 {
public:
double operator()(int x)const
{
return x * x;
}
};

//aşağıda yazılan kodun karşılığı yukarıdaki koddur

int main()
{
[](int x) {return x * x * .5; } 
}

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

en fazla karşımıza çıkıcak durumlar:
isimlendirilmiş nesne kullanımı

/*class xyz13981 {
public:
double operator()(int x)const
{
return x * x;
}
};
*/

int main()
{
auto f = [](int x) {return x * x; };

std::cout << f(2) << "\n" << f(5) << '\n';
}

----------

hiç isimlendirmeden fonksiyon şablonuna argüman olarak göndermek

template <typename F>
void func(F f)
{
auto val = f(12);
}

int main()
{
func([](int x) {return x * x; });
}

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

#include "nutility.h"
#include <algorithm>
#include <vector>

int main()
{
using namespace std;

vector<string> svec;
rfill(svec, 100, rname);
print(svec); 

cout << 
count_if(svec.begin(), svec.end(), [](const string &s) {return s.lenght() == 7; })
}


/* //derleyiic bu şekilde yazar
class xyz_tamer_ {
public:
bool operator()(const std::string& s)const 
{
return s.lenght() == 7;
}
};
*/

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

int main()
{
using namespace std;

auto val = [](int x) {return x * x + 5; }(20); //fonksiyona çağrı olarak 20 değeri verildi
}

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

int main()
{
using namespace std;

auto x = [](int a, int b) {return a + b; }(4, 8); //a ve b'ye 4 ve 8 değeri verdik
}

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

labmda function içinde statik ömürlü nesneleri doğrudan isimleriyle kullanabiliriz.


int main()
{
int g = 5;

auto f = [](int a) {return a * g; }; //g isim aramadan dolayı hatalı olur, globalda bildirsek hata olmaz
}

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

int main()
{

auto iputc = [](int x) {
std::cout << x << '\n'; //cout global bir değişken olduğu için hata olmaz
};

iputc(35);
}

----------------
//derleyiciye bunu yazdırmak için capture clause denilen sentax oluşturulması gerekiyor

class bgrsrtts {
public:
bgrsrtts(int x) : mx(x) {}
int operator()(int a)const {
return a * mx;
}

private:
int mx;
};

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

int main()
{
int x = 10;
[x] //capture clouse, derleyicinin yazdığı sınıf elemanının bu türden olmasını istiyoruz kopyalama yapılmış oluyor
}

-----------

int main()
{
int x = 10;

auto f = [x]() {
++x; //illegal, x const olduğu için geçersizdir

}; 
}

-----------

int main()
{
int x = 35;

auto f = [x]()mutable { //x'in const üyeliği gider değiştirmek istendiği söylenir
++x;
};
}

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

int main()
{
using namespace std;

string str{"bugrahan serttas" };

auto f = [str]()mutable { //mutable kullanmassak hata olur
str[0] = 'T';
}
}

-------------
int g = 6;

int main()
{
using namespace std;

int x = 3, y = 5, z = 9;

auto f = [x, y, z, g](int a) { //hata olur g global olduğu için
return a * (x + y + z);
};
}

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

bütün değişkenleri capture etmenin kısa yolu aşağıdadır

int main()
{
using namespace std;

int x = 3, y = 5, z = 9;

auto f = [=](int a) {  // = koyulduğu zaman bütün değişkenler kullanılabilir
return a * (x + y + z);
};
}

----------

int main()
{
using namespace std;

int x = 6;

auto f = [x]()mutable {
x *= 10;
};
f();
cout << "x = " << x << '\n';

}

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

class mxt_12 {
public:
mxt_12(int &r) : mr {r} {}
void operator()()const
{
mr++; //hata olmaz, veri eleamnı değştirilmiyor gösterdiği eleman değiştiriliyor
*ptr = 567; //hata değil
ptr = 8778; //hata
}
private:
int& mr;
};

int main()
{
using namespace std;

int a = 75;

mxt_12 f(a);

f();

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

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

int main()
{
using namespace std;

int a = 67;

//[a]() //derleyici bana sınıf tanımla, sınıfın veri elemanını a ile init et demek
[&a]() //derleyici bana sınıf tanımla, sınıfın veri elemanını &a ile init et demek
{
++a;
};
cout << "a = " << a << '\n'; //67 olur
}

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

int main()
{
using namespace std;

int a = 67;
[&a]() {
++a;
}();

cout << "a = " << a << '\n'; //68 olur
}

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

int main()
{
using namespace std;

int a = 67;
int b = 23;
int c = 5;
double dx = 4.5;

auto f = [a, &b, &c]() {}; //bu şekilde capture edilebilir
auto f = [=]() {}; //hepsini copy olarka capture eder
auto f = [&]() {}; //hepsini &a, &b, &c, &dx olarak capture eder
auto f = [=, &dx]() {}; //dx hariç hepsini copy olarak capture eder dx &dx olarak
auto f = [&, a]() {}; //a hariç hepsi & olarak capture edilir
}

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

int main()
{
using namespace std;

auto f = [](int x)-> double { //çıkarım yapmaz direk geri dönüşü double yapar, trailing return type
return x * x;
};

auto ret = f(4);
}

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

int main()
{
using namespace std;

auto f = [](int x) {
if (x > 10) {
return x * x;
}
else {
return x * 5.6; //ambigidous dan dolayı hata var
//return x * 5; //legal
}
};

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

class Myclass {
public:
template <typename T>
void func(T)
{

}
};

int main()
{
Myclass m;

m.func(1);
m.func(1.1);
m.func(1.1f);
m.func('A');
}

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

class Myclass {
public:
template <typename T>
void operator()(T) 
{

}
};

int main()
{
Myclass m;
m(12);
m(1.2);
m('A');
}

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

yukarıdaki şekilde lambda fonksyionu yazılabilir

class xyz_12 {
public:
template <typename T>
auto operator()(T x)
{
return x * x;
}
};

//derleyici yukarıdaki şekilde yazar, istediğimiz argümanla çağırabiliriz

int main()
{
auto f = [](auto x) {
return x + x;
};
}

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

int main()
{
auto f = [](auto x) {
return x + x;
};
std::string name{"gurkan"};

auto a1 = f(12); //türü int değeri 24
auto a1 = f(3.5); //türü double değeri 7
auto a1 = f(name); //türü string değeri gurkangurkan
}

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

labmda ile ilgili ilginç birkaç özellik ile devam ediyoruz

int main()
{
auto f1 = []() {};
auto f2 = []() {};

//compile time'da f1 ve f2 türünün aynı olup olmadığı <type_traits> is_same ile bakılır

constexpr bool b = std::is_same_v<decltype(f1), decltype(f2)>;

std::cout << typeid(f1).name() << '\n';
std::cout << typeid(f2).name() << '\n';

}

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

int main()
{
auto f1 = []() {};

auto f2 = f1; //legal, aynı türdendir copy ile hayata geldi
}

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

int main()
{
auto f1 = []() {};
decltype(f1) f2; //cpp 20 öncesi hata 
}


stateless labmda : durumu olmayan 

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

int main()
{
auto f1 = []() {};
auto f2 = f1;

f1 = f2; //delete edilmiş çağrıya atama yapılıyor hata, cpp 20 sonrası legal
}

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

int main()
{
auto f = []() {};

decltype(f) f2;

f = f2; 
//cpp 20 ile yukarıdaki kodlarda hata olmaz
}

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

int main()
{
auto f = [](int x) {return x * x; };

int (*fptr)(int) = f;
}

-------------
işaret operatörü + önemi

//positive lambda

int main()
{

auto x = +[](int a) {return a * a; };

std::cout << typeid(x).name() << '\n';
}


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

class Myclass {

public:

};

int main()
{
Myclass m;
+m; //geçersiz
}

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

class Myclass {

public:
operator int()const
};

int main()
{
Myclass m;
+m; //geçerli
}

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

class Myclass {

public:
using fptr = double(*)(double);
operator fptr()const
};

int main()
{
Myclass m;
+m; //geçerli, 12. satır sayesinde
}

//lambdaların bu şekilde function pointer türüne dönüşüm yapan özelliği var
---------------
positive lamda : function pointer type yapar

eğer function pointer type ifadesi oluşturmak istiyorsak ve elimizde statıs lamda var ise
onu işaret operatörü + nın operanıd yapmak

int main()
{
// [](int a) {return a * a;}; //closure type
auto x = +[](int a) {return a * a;}; //function pointer türüne dönüştürdü

std::cout << typeid(x).name() << '\n';

}

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

template <typename F>
void foo(F x)
{
std::cout << typeid(x).name() << '\n';
}

int main()
{
foo(+[](int a) {return a * a; }); //function pointer type oldu
}

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

noexcept
--------

[]()noexcept{code}; //exception throw etmememe garantisini istiyorsak bunu kullanıcağız

int main()
{
auto f = [](int x) noexcept{return x * x; }; //exception göndermeme garantisi veriyor
 
auto f = [](int x){return x * x; }; //exception gönderebilir

noexcept(f(12))
}

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

//constexpr olmasını engelliycek bir durum olmadığı sürece constexpr kabul ediliyor

int main()
{
auto f = [](int x) {return x * x + 5; }; //constexpr, engelliycek bir durum yok
constexpr auto val = f(5);
}

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

int main()
{
auto f = [](int x) {
static int ival = 15;
return x * x + 5; };

constexpr auto val = f(5); //hata constexpr içinde sttaic olamaz, global olamaz, f(5) sabit değil
auto val = f(5); // legal olurdu
}

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

int main()
{
auto f = [](int x) constexpr {static int y{};
return x + y;};
}

-------------
c++ 20 ile gelen bir özellik

template <typename T>
class Myclass {

};

int main()
{
auto f = [](int x) {return x * x; };

Myclass<decltype(f)> m1;

std::cout << sizeof(decltype(f));
}

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

template <typename T>
class Myclass {

};

int main()
{
sizeof(decltype([](int x) {return x * x; })) //cpp 17 ye kadar hataydı
}

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

template <typename T>
class Myclass {

};

int main()
{
Myclass<decltype([] {}) > m1;
}


-------------
//non-type paramlarda cpp 20 de deverimsel nitelikte yenilikler geldi

template <auto x> //non-type param
class Myclass {

};

int main()
{

}

-----------
//artık gerçek sayı türleri non-type parametreye argüman olabiliyor

template <auto x> //auto non-type param olduğunu gösterir
class Myclass {

};

int main()
{
Myclass < [] {} > m; //
}

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

template <auto x = []{}> //non-type param ve default template argümanı
struct class Myclass {
inline static int ival = 5;
};

int main()
{
Myclass<> m1; 

m1.ival++;
m1.ival++;
m1.ival++;

Myclass<> m2;

std::cout << m1.ival << '\n'; //her bir lambda ifadesi farklı bir tür oluşturuyor bu yüzden m1 ve m2 aynı değil
std::cout << m2.ival << '\n';
}

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

int main()
{
int a = 5;
int b = 4;
std::string str{"alican"}

const int x = [=](int x) { //bu şekilde basit bir şekilde yapılabilir işelmler lambda kullanrak
//code
return a * b - 3 + x;
}(12);

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

int main()
{
using namespace std;

vector<int> ivec;
rfill(ivec, 30, Irand{-1000, 1000});
print(ivec);

sort(ivec.begin(), ivec.end(), [](int a, int b) {
return abs(a) < abs(b);
});

print(ivec);
}

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

stl algoritmalarına geri dönüyoruz

foreach : bir aralıktaki her bir öğe üzerinde belirli bir işlemi gerçekleştirmenizi sağlar.
-------
//for each geri dönüş değeri function object'in kendisidir

#include <algorithm>

template <typename Iter, typename F>
F ForEach(Iter beg, Iter end, F f)
{
while (beg != end) {
f(*beg++);
}
return f;
}

--------

int main()
{
using namespace std;

vector<string> svec;
rfill(svec, 1000, []{return rname() + '' + rfname(); }); //() yazmama nedeni, parametre değişkeni yok ise yazmaya gerek yoktur

for_each(svec.begin(), svec.end(), [](const auto& s)){
cout << s << '\n';
});
}

-----------

class Functor {
public:
void operator()(const std::string& s) {
if (s.size() > 12)
++m_count;
std::cout << s << '\n';
}
int get_count()const
{
return m_count{};
}

private:
std::size_t m_count{};
};

int main()
{
using namespace std;

vector<string> svec;
rfill(svec, 1000, []{return rname() + '' + rfname(); });

auto f = for_each(svec.begin(), svec.end(), Functor{}){

std::cout << f.get_count() << '\n';
}

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

int main()
{
using namespace std;

vector<string> svec;
rfill(svec, 100, rname);
print(svec);

for_each(begin(svec), end(svec), [](auto& s) {
s + = "can";
});
}

std::cout << "\n";
print(svec);
}

----------------
aşağıdaki kodda sıkıntı vardır, avoid raw loops

vector<Fighter> fighter_vec;

bool flag = false;
for (size_t i{}; i < figter_vec.size(); ++i) {
if (is_wounded(fighter_vec[i])) {
flag = true;
break;
}
}

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

any_of
-------

int main()
{
using namespace std;

vector<string> svec;
rfill(svec, 100, rname);

if (any_of(svec.begin(), svec.end(), [](const string& s) {
return s.contains('x');
}))
}

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

any_of : bunlardan herhangi biri
all_of : hepsini destekliyor mu
none_of : herhangi birini destekliyor mu

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

int main()
{
using namespace std;

int a[] = {1,3,5,7,9,13}; //buranın da contxexpr olması gerekir
bool b = any_of(begin(a), end(a), [](int x) {return x % 2 == 0;});
}

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

int main()
{
using namespace std;

vector<int> ivec;
bool b = all_of(ivec.begin(), ivec.end(), [](int x) {return x % 2 == 0};);

boolalpha(cout);
cout << "b = " << b << '\n';

}

----------------
arama algoritmalarına bakıyoruz,  aramam iterat

int main()
{
using namespace std;

vector<string> svec;
rfill(svec, 100, rname);
size_t len;

cout << "uzunlugu girin: ";
cin >> len;

if (const auto iter = find_if(svec.begin(), svec.end(), [len](const string& s) {
return s.size() == len;}); iter != svec.end()) {
std::cout << "bulundu: " << *iter << "indeks = " << iter - svec.begin() << '\n';
}
else {
std::cout << "bulunamadi\n";
}
}

//find_if_not : bu koşulu sağalamayanları bulur

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

replace  
---------

int main()
{
using namespace std;

vector<string> svec;
rfill(svec, 100, Irand{0, 9});
print(ivec);

replace(ivec.begin(), ivec.end(), 5, 9999); //değeri  5 olanların yerine 9999 yazar
}

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

reverse_copy : orijinal aralıktaki sıraları tersine çevirerek başka bir aralığa kopyalar.
replace_copy : , bir aralıktaki öğeleri başka bir aralığa kopyalarken belirli bir değeri başka bir değerle değiştirmenize olanak tanır.
remove_copy : silinmesi gereken haricinde diğerlerini kopyalıyor

-----------

int main()
{
using namespace std;

vector<string> svec;
rfill(svec, 20, rname);
print(svec);
list<string> slist

reverse_copy(svec.begin(), svec.end(),back_inserter(slist));
//vectördeki öğelerin tersini listeye kopyalıycağız

}

-----------

int main()
{
using namespace std;

vector ivec{1,2,4,3,5,32,423 };
vector<int> destvec(100);

/*
//kötü yazılmcı aşağdaıki şekilde yazar
auto iter = destvec.begin();
for (auto i : ivec) {
if (i != 1) {
*iter++ = i;
}
}
*/

auto iter = remove_copy(ivec.begin(), ivec.end(), destvec.begin(), 1);
std::cout << "toplam" << distance(destvec.begin(), iter) << "eleman kopyalandi\n";

print(destvec.begin(), iter);
}

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

remove_copy_if
--------------
//bu örneği yazmaya çalış

int main()
{
using namespace std;

vector<Date> dvec;
rfill(dvec, 1000, Date::random);
print(dvec, "\n");

//sadece kasim aynı olanları silerek dest_vec'e kopyalamk istiyoruz
vector<Date> dest_vec;

remove_copy_if(dvec.begin(), dvec.end(), back_inserter(dest_vec), [](const Date& d) {
return d.monthh() ==  11;
});
print(dest_vec, "\n");
}

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

int main()
{
using namespace std;

vector<int> ivec;
rfill(ivec. 1000, Irand{0, 9});

vector<int> dest_vec;

replace_copy(ivec.begin(), ivec.end(), back_inserter(dest_vec), 5, 3333);

print(dest_vec);
}

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

int main()
{
using namespace std;

vector<int> ivec;
rfill(ivec, 20, Irand{0, 9});
print(ivec);



replace_if(ivec.begin(), ivec.end(), [](int x){return x % 2 == 0; }, -1)

print(ivec);
}

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

int main()
{
using namespace std;

vector<int> ivec;
rfill(ivec, 20, Irand{0, 9});
print(ivec);

list<int> ilist;

replace_copy_if(ivec.begin(), ivec.end(), back_inserter(ilist), [](int x){return x % 2 == 0; -1})

print(ivec);
}

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

CONTANIERS
----------

dianmik dizi veri yapısı : öğelerin bellekte tek blokta ardışık olarak tutulduğu yerdir, sondan ekleme ve sondan silme sabit zamana

template <typename Elem, typename A = std::allocator<Elem>>
class Vector {

public:
void push_back(const T)

};

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

üye fonksyion düğüm içine erişebilir ancak algoritma düğüm içine erişemez

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

bütün contanierların nested type'ı vardır

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

template <typename C>
void foo(C&& r)
{
typename C::pointer
}

int main()
{
using namespace std;

vector<int>::difference_type
}

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

öyle member functionlar vardır ki contanierların hepsinde vardır

.size() : contanierda tutulan öğe saısı

.empty() : boş olup olmadığını bool döndürür

.clear() : size'ı sıfıra çeker her şeyi siler

.erase() : öğe silme, 
 2 overload'u vardır : 
 1- myvec.erase(ivec.begin());
 2- myvec.erase(ivec.begin(), ivec.end());

---------------
mülakatlarda çok sık sorulan bir soru : push_back ile emplace_back arasındaki fark nedir
neden push_back 2 ayrı overloadı var

contanierların insert fonksiyonların 2 tane overloada sahip oluyor
const T& : copy, L value
T&& : move, R vale

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

template <typename T>
class Vector {
public:

/*
template <typename U>
void foo(U &&) //universal ref
*/
void push_back(T&& r); //R value ref, nesne oluşturmak için sınıfın move ctoruna argüman geçilcek, nesnesnin kaynağını çalar
{
r //doğrudan bu şekilde çağrılmaz
std::move(r) //bu şekilde çağrılır
}

void foo(const T& r) //L value, T türünde nesnesnin ctor çağrılmasını sağlıycak, copy ctor, nesnenin kopyasını çalar
{

}

};

---------
//çok sık yapılan bir hata

vector<string> svec;

string str(50000);

svec.push_back(str); //copy

svec.push_back(move(str)); //move

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

insert fonksiyonları :
-insert 
-push_front
-push_back

-----------

template <typename T>
class Vector {
public:
void push_back(const T&r)
{

}

void push_back(T&& r) //r value
{
std::move(r)  
}
};

move ctor yok ise copy çağrılır
copy delete edilmiş sadece move var ise push_back çağrılırsa derleme zamanı hatası alırız, bunu çözmenin yolu std::move(r) ile r value yapmak

------------
çok sık hata yapılan alanlardan birisi

---------

emplace
emplace
emplace_back

---------
template <typename T>
class Vector {
public:
void push_back(const T&r)
{

}

void push_back(T&& r) //r value
{
std::move(r)  
}
};

//perfect forwarding edicek
template <typename ...Args>
void emplace_back(Args&& ...args)
{
T(std::forward<Args>(args)...)
}
};

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

template <typename T>
class Vector {
public:
void insert(Iterator iter, const T&r)
{

}

void push_back(Iterator iter,T&& r)
{
std::move(r)  
}
};

template <typename ...Args>
void emplace_back(Iterator iter ,Args&& ...args)
{
T(std::forward<Args>(args)...)
}

//gereksiz kopyalamanın önüne geçer

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

!! taşıma semantiği move, copy bunları iyice bilmeden mülakatlara girme

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

bazı sınıflar non copy non move, emplace kullnarak bunları kullanmadan 
sınıfın contrutırına çağrı yaparak kullanabiliriz

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

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

vector
------

aksi bir durum olmadılça vector kullanılacak 

template <typename T, typename A = std::allocator<T>>
class Vector {

};

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

access gruplarını inceliyoruz

int main()
{
using namespace std;

vector<int> ivec(100);

auto size = ivec.size(); 
auto cap = ivec.capacity();

cout << "size = " << size;
cout << "cap = " << cap;

ivec.push_back(1);

cout << "size = " << ivec.size();
cout << "cap = " << ivec.capacity();

}

//size = capacity ise reallocation yapılır

--------------------
#include <cstdlib>

int main()
{
using namespace std;

vector<string> svec;

rfill(svec, 20, []{return rname() + ' ' + rfname(); }); 

while(!svec.empty()) {
print(svec, "\n");
(void)(getchar)();
std::system("cls");
svec.pop_back();
}
}

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

#include <cstdlib>
#include <print> //cpp 23 ile geldi

int main()
{
using namespace std;

vector<int> ivec(10);

auto cap = ivec.capacity();
int cnt{};


print("size = {} capacity() = {}\n", ivec.size(), ivec.capacity());
ivec.reserve(6'000'000); //bunu çağırmak önemli
print("size = {} capacity() = {}\n", ivec.size(), ivec.capacity());
(void)getchar();


while (ivec.size() < 5'000'000) {
ivec.push_back(1);
if (ivec.capacity() > cap) {
print("{}. size = {} new capacity = {}\n",++cnt, ivec.size(), ivec.capacity())};
cap = ivec.capacity();
(void)getchar();
}
}
}

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

int main()
{
using namespace std;

vector<int> ivec;

auto beg = ivec.begin(); //begin ve end diferans edilemez
auto beg = ivec.end();

ivec.front(); //ilk konuma referans döndürür, boş contanierda çalışması ub
ivec.back(); //son konumda refernas döndürür,  boş contanierda çalışması ub

}

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

int main()
{
using namespace std;
vector<int> ivec(20); //20 tane öğe ile başlatır, 20 öğeyi value init yapar
}

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

//hata verir, çalışması için default ctor olması gerekir
class Myclass {
public:
Myclass(int);
};

int main()
{
using namespace std;

vector<Date> mvec(20); 
}

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

int main()
{
using namespace std;

vector<Date> mvec(20); 

for (const auto& dt : mvec) {
cout << dt << '\n'; 
}
}

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

int main()
{
using namespace std;

Date bdate {23,02, 2001};
vector<Date> mvec(20, bdate); 

//range - based for loop

for (const auto& dt : mvec) {
cout << dt << '\n'; 
}
}

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


int main()
{
using namespace std;

vector<int> vec1(20, 5); 
vector<int> vec2{20, 5}; 

cout << "vec1.size() = " << vec1.size() << '\n';
print(vec1);
cout << "vec2.size() = " << vec2.size() << '\n';
print(vec2);
}

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

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

Myclass(std::initializer_list<int>)
{
std::cout << "Myclass(std::initializer_list<int>\n";
}
};

int main()
{
using namespace std;

Myclass m(12);
Myclass m{12};

}

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

template <typename T>
class Myclass {};

int main()
{
Myclass<double> mx;
Myclass<int> my;

mx = my; //Hata
}

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

int main()
{
using namespace std;

list<int> mylist{2,5, 7, 1,9,4};

vector<int> ivec = mylist;
vector<int> ivec{mylist.begin(), mylist.end()}; //range ctor çağrıldı
vector<double> ivec{mylist.begin(), mylist.end()}; //legal template olduğu için

}

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

int main()
{
using namespace std;

const char* const p[] = {"furkan", "mert", "damla", "melike", "serhat"};

vector<string> svec{begin(p), end(p)}; //legal, string2 cstring atanabilir
}

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

int main()
{
using namespace std;

string s[] = {"ali", "can", "naz", "eda" };

vector<const char*> vec{begin(a), end(a)};
}

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

int main()
{
using namespace std;

vector<int> ivec;
rfill(ivec, 100, Irand{0, 40});
print(ivec);

//öğeleri küçükten büyüğe sırala herbir öğeden 1 tane olsun

sort(ivec.begin(), ivec.end());
ivec.erase(unique(ivec.begin(), ivec.begin(), ivec.end());
print(ivec);
}

------------------
#include <set>

//range ctor'a örnek veriyoruz

int main()
{
using namespace std;

vector<int> ivec;
rfill(ivec, 100, Irand{0, 40});
print(ivec);
auto myset = set<int>{ivec.begin(), ivec.end()}

ivec.assign(myset.begin(), myset.end());

print(ivec);

//contaniera başka bir contanier doğrudan atama operatörü ile atayamayız
//ama assign fonksyionun range overloadu ile atayabiliriz
}

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

contstructerları incelemeye devam ediyoruz...

initializer_list ctor: ctad'danda faydalanır 

//eski cpp'da bu şekilde yazılırdı
int main()
{
using namespace std;

const int a[] = {3,6,7,9,2,45};
vector<int> ivec(a, a + sizeof(a) / sizeof(*a));

print(ivec);
}

-----------

int main()
{
using namespace std;

vector<int> ivec{4, 5, 7, 1, 9, 3}; //initializer list sayesinde bu şekilde tutabilirz

print(ivec);
}

-----------

//ancak bazı durumlarda dikkat etmemiz gerekir

int main()
{
using namespace std;

list<int> mylist{2,5,6,8,1,3,8};

auto myvec = { mylist.begin(), mylist.end() };
vector<list<int>::iterator> myvec = {mylist.begin(), mylist.end() };
}

----------
gördüğümüz ctor'lar

default ctor
range ctor
initlist ctor
field ctor

-----------

std::vector<int> foo();

int main()
{
using namespace std;

vector<int> ivec(10000);

auto myvec = std::move(ivec);
}


------------
using namespace std;

void foo(vector<string>&& x)
{
//no code flow now
}

int main()
{
using namespace std;

vector<string> svec(100'000);

foo(std::move(svec)); //bu kod çalışınca maindeki string vektörünü 
//foo fonksiyonuna taşımış olmayız 

}

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

using namespace std;

void foo(vector<string>&& x)
{
auto y = x; //yine taşıma olmaz, 
auto y = move(x); //burada olur
}

int main()
{
vector<string> svec(100'000);

foo(move(svec));
}

----------------
!! bir nesneyi r value referans ile çağırdık diye o nesneyi çalmış olmayız
fiilen çalınması için move ctor veya move assign edicez

using namespace std;

void foo(vector<string>&& x)
{
vector<string> temp; 
temp = move(x);
}

int main()
{
vector<string> svec(100'000);

foo(move(svec));
}

---------------
Bir öğeye nasıl erişiriz
1- [] : exception throw etmez
2- at : exception throw eder
3- iteratör diref ederek

----------

using namespace std;

int main()
{
vector<string> svec{"burhan", "ferhan", "nurhan", "alpkan"};
svec.operator[](2) = "mustafa"; //legal
svec[2] += "can"; //legal, += sol operandı için sınıfın üye fonksiyonu çağrılıyor o ref döndürüyor string += fonksiyonu çağrılır

}

-----------

int main()
{
vector<string> svec{ "burhan", "ferhan", "nurhan", "alpkan" };

svec.at(2)[0] = 'T'; //turhan yaptık
//svec.at(2).operator[](0) = 'T'; //derleyici bu şekilde yazar

}

----------

int main()
{
vector<string> svec{ "burhan", "ferhan", "nurhan", "alpkan" };

try {
auto x = svec[678]; //hata, exception throw etmez
auto x = svec.at(35); //hata, exception throw eder
}
catch (const std::out_of_range& ex) {
std::cout << "exception caught: " << ex.what() << '\n';
}
}
------------

int main()
{
vector<string> svec{ "burhan", "ferhan", "nurhan", "alpkan" };

svec.front() += "can";
svec.back() += "can";

print(svec);
}

-----------

int main()
{
vector<string> svec{ "burhan", "ferhan", "nurhan", "alpkan" };

for (size_t i{}; i < svec.size(); ++i) {
svec[i];
}
}

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

!! köşeli parantez operatör fonksiyonu sadece vector, deque, string, array de vardır
                                              -----   -----  -----   -----
------------
//sadece okuma amaçlı kullanıcak isek cbegin, cend çağrılmalı, 
const iteratör verir


int main()
{
vector<string> svec{ "burhan", "ferhan", "nurhan", "alpkan" };

for (auto iter = svec.cbegin(); iter != svec.cend(); ++iter) {
*iter += "can"; //hata olur 
}
}

----------
//range base for loop döngünün tamamını dolaşmak içindir

int main()
{
vector<string> svec{ "burhan", "ferhan", "nurhan", "alpkan" };

vector<string> svec{};
rfill(svec, 100, []{return rname() + ' ' + rfname(); })
auto iter = std::find_if(svec.begin(), svec.end(),
[](const string &s){return s.contains('e'); });

if (iter != svec.end()) {
while (iter != svec.end()) {
cout << *iter++ << " ";
}
}
}

---------

int main()
{
vector<string> svec{};
rfill(svec, 10, []{return rname() + ' ' + rfname(); })

for (const auto& s : svec)
cout << s << '\n';

cout << "\n";

for (auto riter = svec.rbegin(); riter != svec.crend(); ++riter)

cout << "\n";
}

----------

int main()
{
vector<int> ivec(10);

for (double i : ivec) {  //legal, int ==> double ancak string olmaz int to string yok

}
}

----------

for (auto x : expr) {

}

auto &&r : expr;

// derleyici bu şekilde yazar
for (auto iter = r.begin(); iter != r.end(); ++iter) {
auto x = *iter;
}


-----------
//back fonksiyonu çok önemlidir olmasaydı aşağıdaki şekilde kodlar yazılırdı

int main()
{
vector<int> ivec(100);

ivec[ivec.size() - 1]

}

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

contanierı değiştiren interface'ler :

push back tekrarı
-----------------

template<typename T>
class Vector {

public:
void push_back(const T&) //l value
{
new[address] T(r) //copy ctor ile hayat getirir
}

void push_back(T &&r) //r value
{ 
new[address] T(std::move(r)) //move ctor ile hayat getirir
}

}

-----------

emplace_back tekrarı
--------------------
// forwarding eder

template<typename T>
class Vector {

public:
void push_back(const T&) //l value
{
new[address] T(r) //copy ctor ile hayat getirir
}

void push_back(T &&r) //r value
{ 
new[address] T(std::move(r)) //move ctor ile hayat getirir
}

template<typename ...U>
void emplace_back(U&& ...args)
{
new[address]T(std::forward<U>(args)...);
}
}

------------
#include <algorithm>
#include <list>
#include <set>

using namespace std;

int main()
{
vector<string> svec{"ali", "kemal", "naz", "derin" };

print(svec);
svec.push_back("murat");
print(svec);
 
}

---------

using namespace std;

int main()
{
vector<string> svec{"ali", "kemal", "naz", "derin" };

print(svec);
svec.insert(svec.begin(), "deniz");
svec.insert(next(svec.begin()), "deniz");

print(svec);

}

-----------

using namespace std;

int main()
{
vector<string> svec{"ali", "kemal", "naz", "derin" };

print(svec);
svec.insert(svec.end(), "taylan");

print(svec);

}

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

insert overloadları
-------------------
//push back ile 1 tane ekleme yapabiliriz, 
insert ile range overloadunu ve init list overloadunu kullanabilirim

svec.insert(next(svec.begin()), "tamer");

svec.insert(next(svec.begin()), {"tamer", "tansu", "taylan"});

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

int main()
{
vector<string> svec{"ali", "kemal", "naz", "derin" };

print(svec);
svec.insert(svec.end(), {"gul", "eda", "nur" });

print(svec);

}

----------

int main()
{
vector<string> male_vec{"ali", "polat", "ali" ," ceö" };
list<string> female_list {"gizem", "dilan", "figen", "seda" };

male_vec.insert(male_vec.begin(), female_list_begin(), female_list.end());

print(male_vec);
}

-----------

int main()
{
using namespace std;

vector<string> svec{"ali", "gul", "tan", "eda" };
auto iter = svec.insert(svec.begin() + 1, {"mert", "emel", "naci"});

cout << *iter << '\n';
}

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

ekleme ve silme işlemini birden fazla öğe için yapıcak isek onu yapabilen overloadı çağırın
başka bir overloadı çağırıp döngüye sokma

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

int main()
{
using namespace std;

vector<int> ivec(100);

cout << "ivec.size() = " << ivec.size() << '\';

ivec.assign({2,4,6,8});

print(ivec); 
}

---------

int main()
{
using namespace std;

vector<int> ivec(100);
list<double> mylist{8,7,6,5};

cout << "ivec.size() = " << ivec.size() << '\n';

ivec.assign(mylist.begin(), mylist.end());

print(ivec);
}

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

int main()
{
using namespace std;

vector<int> ivec(100);

ivec.assign(10, 3333);

print(ivec);

}

----------

int main()
{
using namespace std;

vector<int> ivec(2,5,7,8,6,5,6,4,3,4,5,3);
print(ivec);
ivec.resize(3);
cout << ivec.size() = " << ivec.size() << '\n';
print(ivec);
}

----------

int main()
{
using namespace std;

vector<int> ivec(2,5,7,8,6,5,6,4,3,4,5,3);
print(ivec);

ivec.resize(10);

print(ivec);
}

---------

int main()
{
using namespace std;

vector<int> ivec(2,5,7};
print(ivec);

ivec.resize(10, 8);

print(ivec);
}