10. hafta

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

RTTI:
-----

polimorfik bir tür söz konusu olduğunda onun gerçek türü ve davranışı çalışma zamanında belli olur

çalışma zamanındaki type başka derleyicinin koda bakarak bulduğu type başka öğle durumlar var ki normalde başvurmıycağımız bir yöntem olsa da
programın çalışma zamanında bir nesnenin dinamik türünün ne olduğun tespit etmemiz söz konusudur
cpp bunlar için araç sağlar

-dynamic_cast
-typeid
  type_info


upcasting : türemiş sınıftan taban sınıfa 
donw-casting : taban sınıftan türemişe (programın çalışma zamanıyla ilgilidir)

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

dynamic cast iki farklı şekilde kullanılabiliyor :

dynamic cast down-casting'in güvenli bir şekilde yapılıp yapılamıycağını sınıyor

dynamic_cast<Mercedes *>(car_ptr) //türü Mercedes *
dynamic_cast<Mercedes &>(car_ref) //türü Mercedes &

Mercedes *p = dynamic_cast<Mercedes *>(car_ptr);


-----------

class Base {

};

class Der : public Base {

};

void foo(Base* baseptr);

int main()
{
Der* derptr = dynamic_cast<Der*>(baseptr); //hata, bir sınıfın polimorfik olması için en az bir virtual fonksiyona saship olmalı
//dynamic_cast geçerli olması için sınıfın polimorfiik olması gerekir

}

int main()
{

}

-----------

class Base {
public:
virtual ~Base() = default;

};

class Der : public Base {

};

void foo(Base* baseptr);

int main()
{
Der* derptr = dynamic_cast<Der*>(baseptr);
}

----------------------
//dynamic cast örneği (chatgbt)

class Base {
public:
    virtual ~Base() {}
};

class Derived : public Base {
public:
    void DerivedMethod() {}
};

int main() {
    Base* basePtr = new Derived;
    Derived* derivedPtr = dynamic_cast<Derived*>(basePtr);

    if (derivedPtr) {
        // dynamic_cast başarılı oldu, güvenli bir şekilde tür dönüşümü yapıldı
        derivedPtr->DerivedMethod();
    } else {
        // dynamic_cast başarısız oldu, tür dönüşümü güvenli değil
    }

    delete basePtr;
    return 0;
}

----------------------
bu kısım car_4.h içinde

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

!! dynamic cast operatörünün kullanımında 
hedef tür referans türü ise
down-casting güvenli bir şekilde yapılamıyor ise 
standart kütüphanemiizn

std::bad_cast sınıfı türünden 
std::bad_cast sınıfı
  std::expection
sınıfından kalıtım yoluyla elde edilmiştir
expection throw edilir

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

typeid: 
-------
typeid kullanıcak isek type_info include etmemiz gerekir, #include<typeinfo>

typeid(*ptr)
typeid(id)
typeid(10)
typeid(++x)

typeid(int)
typeid(Tesla)

typeid nesnelerinin hepsi sınıf türürnden const bir nesneye referans

-----------------
typeid kodu(chatgbt)
#include <iostream>
#include <typeinfo>

class MyClass {
};

int main() {
    MyClass obj;
    const std::type_info& typeInfo = typeid(obj);

    std::cout << "Type of obj: " << typeInfo.name() << std::endl;

    if (typeInfo == typeid(MyClass)) {
        std::cout << "obj is of type MyClass" << std::endl;
    }

    return 0;
}
----------------
#include<type_info>

int main()
{
std::type_info x; //hata verir çünkü default ctor yok
//kopyası çıkarılamaz ya da default init yapılarak type_info nesnesini oluşturabiliriz
}

------

int main()
{
int x = 10;
auto y = typeid(x); //copy ctor delete edildi
}

her ayrı (distinc) tür için bir type_info nesnesi var

int main()
{
int x = 10;
}

----------

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

auto sz = sizeof(a[30)]; //normalde ub ancak işlem kodu üretilmediği için ub değil
}

----------

!! typeid için işlem kodu üretilmez

int main()
{
int x = 12;

const auto& r = typeid(++x);
std::cout << "x = " << x << '\n';
}

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

class Nec {

};

int main()
{
Nec mynec;

typeid(mynec); //legal, polymorfic bir tür olması gerekmez
typeid(Nec); //static olabilir legal
}

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

type info sınıfını inceliyoruz...


class Nec {

};

int main()
{
Nec mynec;

std::cout << typeid(mynec).name(); //yazı adresi döndürür, ancak standart değildir, farklı yazılar çıkabilir yani

}

-----------

class Nec {

};

int main()
{
Nec mynec;
int ival{};

typeid(mynec).operator==(typeid(int))
}

-----

class Nec {

};

int main()
{
using namespace std;

int x = 10;
doyble dval = 5.78;
cout<<
(typeid(x) == typeid(int)) << "\n";
}

------

class Base {
//public:virtual ~Base(){};
};

class Der : public Base {

};

int main()
{
Der myder;
Base* ptr = &myder;

std::cout << (typeid(*ptr) == typeid(Der)) << "\n";
//type id ifadenin türü polimorfik olan ifadeye göre değişir
//polimorfic değil ise static türü esas alır
//polimorfic ise dinamik türü esas alır
}

-------

class Base {
public:
virtual ~Base(){}; //burası olursa dinamik türü esas alır 
};

class Der : public Base {

};

int main()
{
Der myder;
Base* ptr = &myder;

std::cout << typeid(*ptr).name << "\n";
}

-----------------
car_5.h içinde
-----------------
mülakatlarda soruluyor...

/// class A class B

a ve b aynı hiyerarşi içierisinde mi onu sorgulaman gerekiyor nasıl yaparsın ?
-static cast ile

class Base {

};

class Der : public Base {

};

class Nec {

};

int main()
{
Nec mynec;
Der *derptr = static_cast<Der *>(&mynec); //illegal olur 

Base mybase;
Der* derptr = static_cast<Der*>(&mybase); //legal
}


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

typeid(*ptr)

polimorfik tür söz konusu olduğunda eğer typeid operatörünün operandı olan ifade  
dereference edilmiş pointer ifadesi ise pointer değerinin nullptr olması durumunda 

std::bad_typeid

sınıfı türünden exception throw edilir.

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

//herb sutter

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

NVI (non-virtual interface)

------------
!! template method :taban sınıf türemiş sınıfa customization point vermek istiyorsa virtual function yapıyor
//oop patentlerinden biridir cp ile alakası yok

class Base {

virtual void attack();
public:
void fight()
{
attact(); //buna template method denir
}
};

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

std::string:
------------

c de yazılar char dizilerde tutulur c++ yazıları bir sınıf türünden nesne oluşturarak kullanıyoruz

---
#include <cstring> //c deki strcmp, strcpy tarzı fonksiyonları çağırmak için kukkanır 
---

#include <string> 

string STL'in başlık dosyalarından biridir
STL ==> stnadart Template library

----------

namespace Std olmasaydı sınıfı aşağıdaki şekilde implemente ederdik

int main()
{
std::basic_string<char, std::char_traits<char>, std::allocator<char>>
}

--------

//generic programlama ile alakası vardır, generic programlama olmasaydı
bütün sınıf fonksitonları çağırılacaktı

int main()
{
using  namespace std;

string str("Buğrahan serttas");

cout << str;
}

----------
STL has 4 components:
-Algorithms
-Containers
-Functors
-Iterators

-Bu bir sınıf şablonu (class template)
-container'dır

sequence containers:
vector
deque
list
forward_list
string
array

associative contaniners:
set
multiset
map
multimap

unordered associative containers:
unordered_set
unordered_multiset
unordered_map
unordered_multimap

------

std::string bir stl contanier'i
  sequence container

data structere
  dynamic_array

-------

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

String devam...
---------------

aslında bir sınıf şablonudur, basic string isimlli sınıf şablonundan bir açılımından bahsediyoruz aslında

!! reallocation' a diikat etmemiz gerekir mümkün olduğunca kaçınmamız lazım


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

bir sınıfla ilgili ilk sorulması gerekenler şunlar:
1-sınıfın genel farlık nedeni ne
2-bu sınıf kalıtım ile mi kullanılacak yoksa bir ilgisi yok mu
3-sınıf polimorfic mi değil mi
4-sınıf generic mi değil mi, yani sınıf şablonu olarak mı oluşturulmuş yok non-temlate'mi
5-sınıfın bize verdiği hizmetler
6-operator overloafing var mı funciton overloading var mı, fonksiyonların beklediği invariantlar var mı?

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

operator overloading'den çok fazla faydalanır, bunlar:

<<
>>
[ ]
+
+=
<=> spaceship
"mehmet"s
"mehmet"sv

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

sınıf fazla fonksiyon vardır templateler sayesinde sadece çağırdımız fonksiyonun kodu eklenir

---------------------
generic: türden bağımsız demek
---------------------

containers (kaplar)
algorithms (algoritmalar)
  veri yapıları üstünde koşturulacak algoritma
  <algorithm>
  <numeric>
iterators (iterators)
Functors
---------------------

kodu anlamaya çalışma

int main()
{
using namespace std;
string name{ "emrecan suster" };

reverse(name.begin(), name.end()); //burada çağırılan global bir fonksiyon

}

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

mülakatlarda algoritma sorularından en çok 
yazılar üstünde gelir

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

string sınıfının hem üye fonksiyonları var hemde yazı işleri bazı işleri üye fonksiyonlarına
bazı yazı işlerini global algoritma dediğimiz fonksiyonlara yaptırıyoruz

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

int main()
{
std::string::size_type //ideali bu türü kullanmaktır

}

------------------------
!! diğer sınıflarında (vector...) size_type'ı vardır

hangi veriler std::string::size_type türündendir

1- size değeri / lenght / yazı uzunluğu
2- kapasite türü
3- bazı stirng fonksiyonları bir ya da iki parametresine indeks değeri istiyolar
4- string::size_type npos

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

en zor kısımlardan biri

bazı parametrik yapılar var bunları iyi öğrenirsek çok daha iyi kavrarız

--------
!!BURASI ÇOK ÖNEMLİ

bazı fonksiyonların parametresi:
-const string&  ==> stringin tutuğu ifadenin tamamı üzerinde (whole string) 
-const string&, size_type idx ==> stringin idx paramteresinde başlarayak sonuna kadar demek (substring)
-const string&, size_type idx, size_type len ==> idx'den başlarayak len uzunluğunda işlem yapıcak (substring)
-const char* ==> null karakter ile sonlanan bir adres vermek zorundayız (cstring)
-const char*, size_type len ==> bu adresten başlarak len tane karakter (data parametre)
-char ==> sadece 1 tane karakter üzerinde işlem yapıca(
-size_type, char c ==> n tane c karakteri (fill)
-iterator beg, iterator end ==> (range parametre)
-std::initializer_list<char> {'B', 'A', 'B', 'A'}

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

initializer_list: bir dizi oluştur ve başladığı ve bittiği yerin adresini tutan elemanlara sahip bir  sınıf nesnesi haline getiriyor 
böylece bir fonksiyona aşğıdaki şekilde geçtiğimiz zaman uzunluğunu da geçmiş oluruz

int main()
{
std::initializer_list<int> x{1, 3, 5, 7, 9};

/*
const int ar[] = {1, 3, 5, 7, 9};
class initializer_list {
const int *ps;
const int *pw;
}
*/

}

-------

#include <initializer_list>

void foo(std::initializer_list<int> p)
{
std::cout << "&p = " << &p << '\n';
std::cout << p.begin() << "\n";
std::cout << p.end() << "\n";
}

int main()
{
std::initializer_list<int> x{1, 3, 5, 7, 9};
x.end(); //dizinin bittiği yerin adresini döndürür

std::cout << "&x = " << &x << '\n';
std::cout << x.begin() << "\n";
std::cout << x.end() << "\n";

foo(x); //adresleri farklı olur ancak begin ve end adresleri ayn olur
}

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

int main()
{
auto x = {1, 3, 5, 7}; //init. list
auto y{1, 3, 5, 7}; //hata
auto x{ 1 }; //legal, int x, init değil
auto t = {2, 5, 7. }; //hata olur aynı türden olması gerekir, c++ 14 ile geldi
 
}

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

mülakatlardaki en klasik sorulardan birisi

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

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

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

int main()
{
Myclass m1{3, 6, 8, 1};
Myclass m2 = {3, 6, 8, 1};

Myclass m1(10, 20); //int int çağrıır
Myclass m1{10, 20}; //init_list çağrılır 

}

---------------------
bu soru mülakkatta gelicek

#include <vector>
#include <initializer_list>

int main()
{
vector<int> vec1(100); //100 tane sıfır değeri ile başlatıcak
vector<int> vec2{100}; //init list 1 tane 100 değeri ile başlıycak 

std::cout << "vec1.size() = " << vec1.size() << '\n';
std::cout << "vec2.size() = " << vec2.size() << '\n';

}

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

int main()
{
using namespace std;

string s1(50, 'A');
std::cout << s1 << '\n';
string s2{50, 'A'}; //init listten dolay
std::cout << s2 << '\n';
}


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

string sınıfın üye fonksiyonları :

1)

void ps(const std::string& s)
{
std::cout << "|" << s << "|\n";
}

int main()
{
using namespace std;

string s1; //default ctor
ps(s1);

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

}

----

  void ps(const std::string& s)
  {
  std::cout << "|" << s << "|\n";
  }
  
  int main()
  {
  using namespace std;
  
  string s1;
  ps(s1);
  
  s1.empty(); //predicate'dir bool döndüren fonksiyonlara denir
  
  //cout << boolalpha; //bu şekilde yazarız true veya false istersek değeri
  cout << s1.empty() << "\n"; //0, 1 diye yazar
  //çok fazla yerde kullanılır empty
  //s1.size == 0 ile aynı anlamdadır
  }

-------------
2)

void ps(const std::string& s)
{
std::cout << "|" << s << "|\n";
}

int main()
{
using namespace std;
string str("ahmet eraslan");
ps(str);
cout << "str.size() = " << str.size() <<"\n"; 
}

------

void ps(const std::string& s)
{
std::cout << "|" << s << "|\n";
}

  int main()
  {
  using namespace std;
  
  char ar[] = { 'A', 'B', 'C'};
  char ar[] = "murathan";
  string str(ar + 5); //ub
  //string str(ar + 3, 2);
  //string str(ar, 20); //ub
  char arr[] = "murat";
  string strrarr, 6); //hata yok
  cout << "str.lenght() = " << strr.lenght() << '\n'; 
  
  ps(str);
  }

-------

void ps(const std::string& s)
{
std::cout << "|" << s << "|\n";
}

int main()
{
using namespace std;
size_t n;

cout << "kac tane: ";
cin >> n;
cout << string(n, '*');

}

--------

void ps(const std::string& s)
{
std::cout << "|" << s << "|\n";
}

int main()
{
using namespace std;

string str(20, '\0';
cout << "str.size() = " << str.size() << '\n'
}

---------

void ps(const std::string& s)
{
std::cout << "|" << s << "|\n";
}

int main()
{
using namespace std;

string s1(100, 'A');
string s2(s1); //copy
string s3(std::move(s1)); //move
 }

-----------

int main()
{
//char parametreli ctor yoktur

using namespace std;

std::string str('A'); //hata
//eğer tek bir karakterden oluşan yazı tutmasını istiyorsak

string s1("a"); //1
string s2(1, "A"); //2
string s3{'A'}; //3

cout << "s1.size() = " << s1.size() << '\n';
cout << "s2.size() = " << s2.size() << '\n';
cout << "s3.size() = " << s3.size() << '\n';

}

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

int main()
{
using namespace std;

string s1{ "cengizhan" };
string s2(s1, 3); 
cout << "s2 = " << s2 << '\n';
string s2(s1, 1,4); 
cout << "s2 = " << s2 << '\n';
string s2(s1, 3,50); 
cout << "s2 = " << s2 << '\n'; //hata yok
}

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

int main()
{
using namespace std;

string s1{50, 'A'};
string s2{66, 65, 66, 65};

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

-----------------
son ctor olan range ctor

int main()
{
using namespace std;
char str[] = {"gokhan girgin"};

string s1{str}; //cstr
string s1{str, 3}; //array
string s1{str, str + 4}; //range

cout << "s1 = " << s1 << '\n';
cout << "s2 = " << s2 << '\n';
cout << "s3 = " << s3 << '\n';

} 

//ctor bitti
--------------------------------------

size_type capacity()const;

int main()
{
using namespace std;

string str(153, 'A');

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

str += "gokhan";
cout << "str.capacity() = " << str.capacity() << '\n';

str.push_back('.');

str += "gokhan";
cout << "str.capacity() = " << str.capacity() << '\n';
}



!! kapasite stirng sınıfınfa ve vector sınıfında kapasitenin artış katsayısı
derleyiciye bağlıdır


------

int main()
{
    using namespace std;

    string str(40, 'A');
    int cnt{};

    // her reallocation olduğunda bu bilgileri yazıdırı
    while (str.size() < 500'000)
    {
        str.push_back('A');
        if (str.capacity() > cnt)
        {
            cout << ++cnt << ". reallocation\n";
            cout << "size = " << str.size() << '\n ';
            cout << "capacity = " << str.capacity() << '\n';
            cnt = str.capacity();
            (void)getchar();
        }
    }
}

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

yapılan en büyük hatalardan birisi gereksiz yere reallocationa sebep olmak

int main()
{
using namespace std;

string str;
char c = 'S';
for (int i = 0; i < 1000; ++i) {
str.push_back(c); //gereksiz reallocation çağrılır bunun yerine reserve fonksiyonunu kullanmak gerekir
}
}

--------------
reserve fonksyionu:

int main()
{
using namespace std;

string str(40, 'A');
str.reserve(600'000); //size arrtırmaz kapasite arttırır
auto cap = str.capacity();
int cnt{};

while (str.size() < 500'000) {
str.push_bacj('A');
if (str.capacity() > cap) {
cout << ++cnt << ". reallocation\n";
cout << "size = " <<str.size() << \n";
cout << "capacity = " <<str.capacity() << \n";
cap = str.capacity();
(void)getchar();
}
}
}

------

int main()
{
using namespace std;

string str(40, 'A');

str.reserve(600'000);
auto cap = str.capacity();
cout << "size = " << str.size() << '\n';
cout << "capacity = " << str.capacity() << '\n';

}

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

mülakkatta mutlaka sorulur

string yazıları her zman heap(free store)'de tutulmaz
derleyiciler SSO (smalls ignal opt.) yapabilir
SSO : uzunluğu küçük olan string nesnelerin string nesnesi içinde oluştutulması


int main()
{
using namespace std;

string str(40, 'A');
}

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

string sınıfının tuttuğu karakterlere ne şekilde erişiriz :

[]
front back()
at
iterator dereferencing


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

int main()
{
using namespace std;
string str{"burak kose"};
for (size_t i{}; i < str.lenght(); ++i) {
cout.put(str[i]); //aynı anlamda
//cout.put(str.operator[](i)); //aynı anlamda
}
}

-----------

int main()
{
using namespace std;

string str{ "mert" };
str[2] = 's';

cout << str << "\n";
}

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

int main()
{
using namespace std;

const string str{ "mert" };

str[2] = 's'; //hata
str.operator[](); //hata
auto c = str[0]; 
}

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

int main()
{
using namespace std;
const string str{ "mert" };
str[12]; //ub olur
}
//expection throw etmez
-------------

mülakatlarda sorulan tipik sorulardan biridir at ile [] operatörü arasındaki fark
at ile yazının bir karakterine erişiriz ancak expection twrow devreye girer [] ile devreye girmez

int main()
{
using namespace std;
const string str{ "mert" };
//burada expection throw'a girer
try {
auto c = str.at(345);
}
catch (const std::exception& ex) {
std::cout << "exception caught: " << ex.what() << '\n';
}
}

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

int main()
{
using namespace std;

string str{ "mert" };
cout << "str = " << str << '\n';

str.front() = 'd';
str.back() = 'i';
cout << "str = " << str << '\n';
}

---------------
range-based for loop (aralık tabanlı for döngüsü): derleyiciye bir kod yazdırırız bu kodu kendimizde yazabilirdik

int main()
{
using namespace std;

string str{ "bugün günlerden pazartesi. kirmizi pazartesi" };

//range : 1. konum ilk öğe konumu, 2. konum son eğeden bir fazlasının konumudur
//B------------S

vector ivec{2,5, 6,7,9,67};

lis
}

------
kodu anlamaya çalışma

int main()
{
using namespace std;

vector ivec{2,5, 6,7,9,67};
list ilist{5,23,2323,12,65,2,55,323};
string str {"bugrahan serttas "};

for (auto iter = ivec.begin(); iter != ivec.end(); ++iter) {
cout << *iter <<'';
}
cout <<'\n';

for (auto iter = ilist.begin(); iter != ilist.end(); ++iter) {
cout << *iter <<'';
}
cout <<'\n';

for (auto iter = str.begin(); iter != str.end(); ++iter) {
cout << *iter <<'';
}
cout <<'\n';

}

-------------
yukarıadki yerine şu şekilde yazabiliriz, kodu derleyiciye yazdırırız
//range based scope

int main()
{
using namespace std;

vector ivec{2,5, 6,7,9,67};
list ilist{5,23,2323,12,65,2,55,323};
string str {"bugrahan serttas"};

for (auto i = ivec)
cout << i << ' ';
cout << '\n'; 

for (auto i = ilist)
cout << i << ' ';
cout << '\n'; 

for (auto i = str)
cout << i << ' ';
cout << '\n'; 

}

--------------
//range based scopeu diziler içinde kullanabiliriz, hatta kendi oluşturduğumuz sınıflar içinde kullanılabilir

auto &i : a //değiştime amaçlı
const auto &i : a//okuma amaçlı

int main()
{
using namespace std;

int a[] = {2,3,432,23,2,32,2,2,1
for (auto i : a) { //for

}
}

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

int main()
{
using namespace std;

string str { "kirmizi pazartesi" };

for (auto c : str) {
c = '!'; //yazı değişmez
}
cout << str << '\n';
}

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

!! std::string bir STL kabıdır
iterator arayüzüne sahiptir

!! string sınıfının bazı üye fonksiyonları diğer stl arayüzleriyle ortak arayüze sahip
yani vector'e nasıl insert ediyorsak stringede o şekilde insert edebiliyoruz


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

yazı üstünde yazıyı değiştiren işlemler (modifiers) :

std::string get_name()
{
return "kerim denizoglu";
}

int main()
{
using namespace std;

string name = "tayyip erguder";

string str {"mustafa" }; //copy assignment

cout << "|" << str << "|\n";

str = name;  //copy

cout << "|" << str << "|\n";

str = get_name();// move assign.

cout << "|" << str << "|\n";

string str {"alican"}; 

cout << "|" << str << "|\n";

str = 'X'; //char parametreli atama

cout << "|" << str << "|\n";

str = {'a', 'l', 'i'}; //init list ataması

cout << "|" << str << "|\n";
  
}

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

string değiştirme işlemlerine devam...

std::string get_name()
{
return "kerim denizoglu";
}

int main()
{
using namespace std;

string name = "tayyip erguder";

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

name.resize(20);  //size'ı değiştirir, reserve kapasite değiştiriyordu
//name.resize(20, '!');
//name.resize(6); //bu şekilde kullarısak silme işlemi yapıcak
cout << "name.size() = " << name.size() << '\n';

cout << "|" << name << "|\n"; 
}

----------------------
mülakatlarda sorulan tipik soru

bir yazıyı tamamen nasıl boşaltırız

std::string get_name()
{
return "bugranan serttas";
}

int main()
{
using namespace std;

string name = "tayyip erguder";

cout << "name.lenght() = " << name.length() << '\n';
name.clear();//1. yol
name.resize(0); //2. yol, argüman sıfır olarak yollandı
name = ""; //3. yol
name = {}; //4. yol
name = string{}; //5. yol
cout << "name.lenght() = " << name.length() << '\n';

}

------------
yazıyı değiştiren bir başka fonksiyon, bu bütün sequence contanierlarda var

int main()
{
using namespace std;

string str {"bjarne stroustrup"};

cout << "str = " << str << '\n';

for (int i = 0; i < 10; ++i){
str.push_back('.');
cout << "str = " << str << '\n';
}
}

----------

int main()
{
using namespace std;
string s = "han";
cout << "str = " << str << '\n';
str += s;
cout << "str = " << str << '\n';
str += "oglu";
cout << "str = " << str << '\n';
str += m;
cout << "str = " << str << '\n';
str += {'x', 'y', 'z'};
cout << "str = " << str << '\n';

}

-----------
daha complexler için assign fonksiyonu var

int main()
{
using namespace std;
string s = "han";

string str{"deniz"};
str.assign("nurhan");
cout << "str = " << str << '\n';
str.assign(10, 'T'); //10 tane t karakteri
cout << "str = " << str << '\n';

string s = "neslihan";
str.assign(s, 3);
cout << "str = " << str << '\n';
str.assign(s, 1, 2); 
cout << "str = " << str << '\n';
//geri dönüş değerleri her zaman *this

}


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

string sınıfında çok önemli bir öğe ile tanışıyoruz

int main()
{
std::cout << "nops = " << std::string::npos; //legal
std::string::npos = 57687u; //hata, const bir nesneye atama yapamam

//npos hiçbir yazıya geçerli bir index olamaz garantisi verir
//yazı ne kadar büyük olursa olsun sıfır ile indexleme başladığı için npos o yazıya geçerli bir indeks olamaz
}

//string sınıfının arama fonksiyonları
//index döndürürler ama arananın bulunamaması durumunda
//öyle bir index döndürmeliki yazının geçerli bir index olmadığından 
//emin olacağımız için onu aranan değerin bulunamamasına işaret eden 
//bir özel değer olmalı bu stringin nposu

//bulunursa başladığı yerin indexini döndürür
bulunamassa string'in size type türünden npos döndürür.

---------------------
arama fonksiyonları:

std::string::size_type find
std::string::size_type rfind
std::string::size_type find_first_of
std::string::size_type find_last_of
std::string::size_type find first_not_of
std::string::size_type find_last_not_of

-hepsiin geri dönüşü indextir yani std::string::size_type
-aranana bulunursa bulunduğu yerin idexini bulunamassa npos döndürür
-bütün find fonksiyonları 1 parametreleri aramanın yapılacağı substrucın indexini alıyor
ve default olarak 0 değerini alır

//bugrahan serttas
//7, aramam 7 indeksiliden başlar
//0, aramam bütün substructen başlar

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

int main()
{
using namespace std;
string str;

cout << "bir yazi girin: ";
cin >> str;

cout << "girdiginiz yazi [" << str << "]\n";
cout << "aranancak karakter: ";
char c = 'a';

string::size_type idx = str.find(c);
//auto idx = str.find(c); //bu şekilde yazabilirdik
if (idx != string::npos) {
cout << "bulundu: idx = " << idx << '\n';
str[idx] = '*';
cout << "|" << str << "|\n";
}
else {
cout << "bulunamadi\n";
}
}
//str.find(c, 5); //yaparsak 5 indeksinden başlarayak arar

/* //c++17 ile if with initializer geldi bu şekilde kullanmaya çalış
if (auto idx = str.find(c); idx != string::npos) {
cout << "bulundu : idx = " << idx << '\n';
str[idx] = '*';
cout << "|" << str << "|\n";
}else{
cout << "bulunamadi\n";
}
*/

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

string'deki overloadingleri anlatıyor ancak çok fazla sayıda var
hepsini öğrenmek için kitabı incele

int main()
{
using namespace std;
string str;

getline(cin, str,); //boşluk kullanmamızı sağlar,
cout << "yaziniz : |" << str << "|\n";

if (auto idx = str.find("necati"); idx != string::npos) {
cout << "bulundu idx = " << idx << "\n";
str[idx] = '*';
cout << "[" << str << "]\n";
}
else {
std::cout << "buunamadi\n";
}

}

--------------
//bu özellik c++20 ile geldi

yazı aradığım varlıkla mı baslıyor?
yazı aradığım varlıkla mı bitiyor?

//starts_with kullanılabilir
//end_withs kullanılabilir

int main()
{
using namespace std;

string str;

getline(cin, str);
cout << "[" << str << "]\n";

if (str.starts_with("necati")) {
std::cout << "evet var\n";
}
else {
std::cout << "hayir yok\n";
}
}

--------------
//c++23 ile gelen başka bir özellik

int main()
{
using namespace std;

string str;

std::cout << "bir yazi girin: ";

getline(cin ,str);

if (str.contains("emrecan")) {
std::cout << "evet var\n";
}
else {
std::cout << "hayiy yok"
}
}

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

diğer fonksiyonlara bakıyoruz

int main()
{
using namespace std;

string str;

std::cout << "bir yazi girin: ";

getline(cin ,str);

str.rfind() //aramayı sondan başlatır  
}

-----------
find_first_of //yazının karakterlerinden herhangi birinin bulunduğu ilk yeri

int main()
{
using namespace std;

string str = "serhat istin";

str.find_first_of("patik"); //a'yı bulur aradığım karekterlerden birisi
str.find_first_not_of("resim"); //resim karakterlerinden biri olmayan ilk karakterin indexini bulur
//serhat'In h sının bulunduğu indexin yerini döndürür

str.find_last_of //sondan başlar
str.find_last_not_of //sondan başlar
}

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

int main()
{
using namespace std;

string s1 = "omer faruk";
string s2 = "selma deniz";

s1.append(s2, 5); //s1 yazısına s2'nin 5. indeksinden başlarayak ekler
//s1.append(s2, 1,5);
cout << "s1 = " << s1 << '\n';
}

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

3, string::npos //npos burada geriye kalanların hepsi anlamında kullanılır

int main()
{
using namespace std;

string s1 = "omer faruk";
string s2 = "selma deniz";

s1.append(s2, 1, string::npos);
cout << "s1 = " << s1 << '\n';
}

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

int main()
{
using namespace std;

char str[] = "mustafa aksoy";

string s = "omer faruk";

cout << "s = " << s << '\n';

s.append(str, 3);
//s.append(5, '*'); //fill paraö
cout << "s = " << s << '\n';
}

-----------------------
//burası biraz karmaşık dikkatli çalış

insert fonksiyonları
arrays fonksiyonları

2 farklı interface vardır
-STL container interfacer 
-iterator interface

---------

con.insert(iter, value); //stl genel insert interface'idir

insert fonksiyonları insert edilmiş ilk öğenin konumunu döndürürler

geri dönüş değeri her zaman arrays fonksiyonlarının silinmiş öğeden sonraki konumu olur
------
6 7 9 1 8 0 //9 silindi 
6 7 1 8 0 //haline döndü, silme fonksiyonun geri dönüş değeri 1'in konumu olur
-------

-------
6 7 9 1 8 0 //7 8 arası silnir 
  -     - 
6 8 0 // bu hale dönüşür geri dönüş değeri silme işleminden sonra silinmyen ilk öğenin konumu yani 8
-------

iterator inerface ile ekleme yapılanların ismi stl'de inserttür
silme işlemi yapanında ismi arraysdir

-----------
vector kütüphanesi için bu şekilde olur

using namespace std;
int main()
{
vector ivec{2, 3, 4, 7, 9,1 };

for (auto i : ivec) cout << i << ' '; 
ivec.insert(ivec.begin(), 6);
for (auto i : ivec) cout << i << ' '; 
cout << '\n';
}

-----------
aynı mantığı stringe uygularız

using namespace std;

int main()
{
string s {"mehmet bal"};

//iterator interface ile yazonon başına ! işareti ekle

cout << "[" << s << "]\n";
s.insert(s.begin(), '!');
//s.insert(s.begin() + 3, '*');
cout << "[" << s << "]\n";
}

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

int main()
{
using namespace std;
string s {"mehmetbal"};
//yazının ilk karakterini siler
while (!s.empty()) { 
cout << "|" << s << "|\n";
s.erase(s.begin())
}
}

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

int main()
{
using namespace std;

string s {"mehmetbal"};
//yazının ilk karakterini siler
while (!s.empty()) { 
cout << "|" << s << "|\n";
s.pop_back();

}
}

--------------
iterator insterface'i


int main()
{
using namespace std;
string s {"mehmetbal"};
//yazının ilk karakterini siler
while (!s.empty()) { 
cout << "|" << s << "|\n";
s.erase(s.end() - 1);
}
}

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


int main()
{
using namespace std;
string s{"mehmetbal"};

cout << "|" << s << "|\n";

s.erase(s.begin(), s.begin() + 3);
cout << "|" << s << "|\n";
}

-------------
mülakatlarda sorulur
//yazının sadece ilk ve son karakterlerini bırakma

using namespace std;

int main()
{
string s{"mehmetbal"};
cout << "|" << s << "|\n";

s.erase(s.begin() + 1, s.end() - 1);
cout << "|" << s << "|\n";
}

-------------
index interface'i


int main()
{
using namespace std;

string s{"mehmetbal"};   
s.insert(0, '!');
s.insert(0, 20, 'A');
s.insert(s.size(), "ekrem");
cout << "s = " << s << '\n';
}

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

int main()
{
using namespace std;
string s{"mehmet bal" };
string name{"murathan"};

s.insert(4, name, 2, 3); //s'İn 4 yerine, 2'den 3 karakterlik kısım 
cout << "|" << s << "|\n";
}

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

substr fonksiyonları :
!! yüksek maaliyetlidir

int main()
{
string str{"melike kaptan"};
//str.substr(idx, n); 1. parametre index, 2. parametresi o indexten başlayarak kaç tane karakerlik substring olduğu 
str.substr(); //str'nin kendisini elde ederiz ancak adeta onun kopyasını çıkarmış oluruz
cout << "|" << str.substr() << "|\n";
cout << "|" << str.substr(7) << "|\n";
cout << "|" << str.substr(7, 3) << "|\n";
}

------------------
erase index interface'i

using namespace std;

int main()
{
string str{ "melike kaptan" };
cout << "|" << str<< "|\n";

str.erase();
//str.erase(0, 1); //ilk karakteri siler
//str.erase(3,3); //3. indeksinden başlarayak tüm karakterler
cout << "|" << str<< "|\n";
}

-------------------
erase itarator interface

int main()
{
string str{ "melike kaptan" };
cout << "|" << str<< "|\n";
str.erase(str.begin(), str.end()); //erase all
str.erase(0, string::npos);
}

------------------
karşılaştırma işlemleri
c++20 spaceship

int main()
{
string name{"ayhan"};
string word{"ekrem"};

if (name == word); //legal
if (name == "ayhan"); //legal
if ("ayhan" == word); //legal

if (name < word) //legal
//geri dönüş değerleri bool
}

---------------------
compore fonksiyonları

c deki strcmp'ye benzer

int srcmp(s1, s2)

retval > 0 s1 > s2
retval < 0 s1 < s2
retval = 0 s1 == s2


if (strcmp(s1, s2) 

-------

int main()
{
string name{"ayhan"};
int result = name.compare();
//int döndürür 
result > 0

}

----------
data
allocate edilmiş bellek bloğunun adresini döndürür

int main()
{
string name{"bugun gunlerden pazartesi" };
name.data()
name.c_str()
const char *p = name.c_str();
puts(p);
name += "yarin da gunlerden sali olacak.";
cout << s << '\n'; 
cout << p << '\n'; //dangling olduk

}

-----------

int main()
{
string s{"bugun gunlerden pazartesi"};

auto p1 = &s[0];
auto p2 = &*s.begın()
auto p3 = s.data();

cout << (void*)p1 << '\n';
cout << (void*)p2 << '\n';
cout << (void*)p3 << '\n';

}

-----------
mülakatlarda çok sorulur
//shring (yüzmek)

int main()
{
string s(100'000, 'A');

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

str.erase(10);
cout << "str.size() = " << str.size() << '\n';
cout << "str.capacity() = " << str.capacity() << '\n';

//shrink
str.shrink_to_fit(); //kapasiteyi size'a uygun bir değere çekmeyi sağlar
cout << "str.capacity() = " << str.capacity() << '\n';

}