#include<iostream>
#include<iomanip>
using namespace std;
int main()
{
/* fixed << setprecision Birlikete Kullanımı */
double deger = 123.456789; //Çıktısı 123.457 geri kalan rakamları yuvarladı
//double yerine float olarak da kullanılabilir
cout << deger << endl;
cout << setprecision<<deger<< endl; //çıktısı 00007FF7EA5613E3123.457 şeklinde olur. Bilimsel Gösterimdir dijit sayısı bilimsel olarak atanmıştır.
cout << setprecision(2) << deger << endl; //çıktısı 1.2e+02 şeklinde olur. Bilimsel gösterim dijit sayısı 2 olarak verilmiştir.
cout << setprecision(3) << deger << endl;// çıktısı 123 şeklinde olur.
cout << setprecision(4) << deger << endl;// çıktısı 123.5 şeklinde olur. Dijiti yuvarlar.
//setprecision(N) manipülatörü toplam anlamlı rakam kadar (significant digits) sayısına N değeri kadar ayarlar
// noktadan sonraki digits sayısını (N) gösterimini ayrlamak için fixed ile setprision birlikte kullanılır.
cout << fixed << setprecision(2) << deger << endl; //Çıktısı 123.46 şeklinde noktadan sonra 2 dijit olarak yuvarlayarak ayarlar
cout << fixed << setprecision(4) << deger << endl; //Çıktısı 123.4568 olarak noktadan sonra 4 dijit olarak ayarlar
cout << fixed << setprecision(0) << deger << endl; //Çıktısı 123 olarak ayarlar dijit değeri 0 olduğundan dijiti almaz
/* Arttırma ve Eksiltme Kullanımı Operatörleri */
/* Arttırma Operatörleri */
int x = 7;
/*x = x + 1;
cout << x << endl; //Çıktısı 8 'dir. 1 arttırdık
*/
x++; //yukarıdaki örnek arttırma işleminin daha pratik yoludur. (postfix)
cout << x << endl;//Çıktısı 8 'dir. 1 arttırdık
/* Eksiltme Operatörü */
int y = 10;
y--; //(postfix)
cout << y << endl; //Çıktısı 9 'dur. 10 'u bir azalttık.
//Prefix artırma
int z = 7;
++z;
cout << z << endl; //Çıktısı 8 'dir.
int k = 10;
--k;
cout << k << endl; //Çıktısı 9 'dur. 10 'u bir azalttık.
cout << "******************************************"<< endl;
//Prefix ile Postfix Arasındaki fark
//
//Değişkenin önceki değeri kullanılır, ardından değeri 1 arttırılır.
//Postfix (x++) => ++ veya -- değişkenin sağındaysa buna postfix denir.
cout << "***************Postfix ++ **************************" << endl;
int n = 7;
int f = n++;
cout << "n 'in degeri : " << n << endl;
cout << "f 'nin degeri : " << f << endl;
/* Çıktısı n 'in degeri : 8 // n değişken değerini 1 arttırdı
f 'nin degeri : 7 // f değerinin bir önceki n değerini 7 olarak aldı
Bu işlem postfix işlemi
*/
cout << "***************Postfix -- **************************" << endl;
int d = 7;
int e = d--;
cout << "d 'in degeri : " << d << endl;
cout << "e 'nin degeri : " << e << endl;
/*
d 'in degeri : 6 // d 'nin değeri 7 iken 1 azalttı 6 oldu
e 'nin degeri : 7 // e 'nin değeri ilk değerini 7 olarak aldı
*/
//Prefix ++ veya -- operatörünün solda olması
//Değikenin değeri önce ++ ise arttırılır, önce -- ise azaltır sonra kullanır
cout <<"*************** ++Prefix ***************<< endl;
int p = 7;
int a = ++p;
cout << "p 'in degeri : " << p << endl;
cout << "a 'nin degeri : " << a << endl;
/* Çıktısı
p 'in degeri : 8 // p'nin değerini 1 arttrıdı
a 'nin degeri : 8 // p'nin değeri a 'ya atadı
*/
cout << "******************* --Prefix ******************************" << endl;
int t = 7;
int q = --t;
cout << "t 'in degeri : " << t << endl;
cout << "q 'nin degeri : " << q << endl;
/* Çıktısı
t 'in degeri : 6 // t 'nin değerini 1 azalttı 6 oldu
q 'nin degeri : 6 // t 'nin değerini q 'ya atadı 6 oldu
*/
//Prefix Postfix'e göre daha hızlıdır. Büyük projelerde Prefix 'in etkisi daha fazladır.
/*
Postfix (x++) yaparken işlemci, değişkenin eski değerini bir yerde geçici olarak (temporary object) saklamak zorundadır çünkü önce eski değeri döndürecektir.
Prefix (++x) yaparken ise eski değeri saklamaya gerek duymaz, doğrudan arttırır ve yeni değeri döndürür.
Basit int tiplerinde modern derleyiciler bunu aynı hıza getirir ama ileride "Iterator" (işaretçiler gibi yapılar) kullanmaya başladığında, Prefix kullanmak gerçekten de performansı etkiler.
Operatör,Adı,İşlem Sırası
++x,Prefix,"Önce arttır, sonra değeri ver"
x++,Postfix,"Önce değeri ver, sonra arttır"
*/
return 0;
}