c++ variables

tnrdll

C++ iç içe ternary (üçlü) operatör kullanımı

C++ programında, ternary operatörü; iç içe bir yapıda da kullanılabilir.

kosul ? ifade1 : (kosul2 ? ifade2 : ifade3) ;

  • Eğer kosul doğru ise ifade1 çalışacaktır.
  • Eğer kosul yanlış ise içerideki ternary çalışacaktır.
#include <iostream>
#include <string>
using namespace std;

int main() {

    int rakam;
    string sonuc;

    cout << "Rakam giriniz (0-9): ";
    cin >> rakam;


    // rakam 0 ise sonuc değişkeni "Sıfır" olur.
    // rakam -1 ise sonuc değişkeni "Negatif" olur.
    // rakam 1 ise sonuc değişkeni "Pozitif" olur.
    sonuc = (rakam == 0) ? "Sıfır" : ((rakam > 0) ? "Pozitif" : "Negatif");

    cout << "Girilen rakam: " << sonuc;

    return 0;
}

tnrdll

C++ iç içe if…else kullanımı

C++ programında, bir koşula bağlı olarak farklı koşullar da kullanılabilir. Bu durumda If deyimi, iç içe (nested) yapıda kullanılabilir. 

#include <iostream>
using namespace std;

int main() {
    int num;
    
    cout << "Bir tamsayı giriniz: ";  
    cin >> num;    

    // sayı 0 değilse çalış
    if (num != 0) {
        
        // sayının 2 ile bölümünden kalan 0 ise çifttir
        if ((num % 2) == 0) {
            cout << "Sayı çifttir." << endl;
        }
         // aksi durumda
        else {
            cout << "Sayı tektir." << endl;
        }  
    }
    // sayı 0 ise
    else {
        cout << "0 çift ya da tek sayı değildir." << endl;
        cout << "Birler basamağında yer alirsa çift sayıyı oluşturur" << endl;
    }
    
}
#include <iostream>

using namespace std;

int main(){
    
    int a; 
    cin >> a;
    
    if (a <= 9) {
    
        if (a==1) {
           cout << "one";
        }
        else if (a==2) {
           cout << "two";
        }
        else if (a==3) {
           cout << "three";
        }
        else if (a==4) {
           cout << "four";
        }
        else if (a==5) {
           cout << "five";
        }
        else if (a==6) {
           cout << "six";
        }
        else if (a==7) {
           cout << "seven";
        }
        else if (a==8) {
           cout << "eight";
        }
        else if (a==9) {
           cout << "nine";
        }
    
    
    }
    else{
        cout << "Greater than 9";
    }
    
    return 0;
    
}
tnrdll

C++ if…else kullanımı

C++ programında, belirtilen koşula bağlı olarak (conditional) bir eylemin yapılması söz konusu ise if deyiminden yararlanılır. If deyimi kullanılırken, karşılaştırma işleçlerinin yanı sıra mantıksal işleçler de kullanılabilir.

if (sayi > 10)Eğer sayi 10’dan büyük ise
koşul sağlanır. (TRUE)
if (deger != 5)Eğer değer 5’e eşit değil ise
koşul sağlanır. (TRUE)
if (sayac == 100)Eğer sayaç 100’e eşit ise
koşul sağlanır. (TRUE)
if (sonuc > eski_sonuc)Eğer sonuç, eski sonuçtan büyük ise
koşul sağlanır. (TRUE)
if (sayi > 17 && durum == “M”)Eğer sayi, 17’den büyük
VE
aynı zamanda durum M ise
koşul sağlanır. (TRUE)
if (sayac == 50 || toplam < 100)Eğer sayac 50’ye eşit
VEYA
toplam 100’den küçük ise
koşul sağlanır. (TRUE)

Koşulun sağlanmaması durumunda bir kod bloğu çalıştırmak istersek else deyiminden yararlanırız.

if: eğer
else: aksi halde (değilse) anlamına gelir.

if (koşul) {
// koşul sağlanıyorsa çalışır.
}
else{
// koşul sağlanmıyorsa çalışır.
}

#include <iostream>


using namespace std;

int main()
{
    int yas;

    cout << "Kac yasindasin? : ";
    cin >> yas;
    cout << endl;


    
    if (yas >= 18){
      
        // yas 18'den BÜYÜK ya da EŞİTSE çalışır.
        cout << "Oy kullanabilirsiniz." << '\n';
      
    }else{
      
        // yas 18'den BÜYÜK DEĞİL ya da EŞİT DEĞİL ise çalışır!
        // yani 18'den küçükse...
        cout << "Oy kullanamazsiniz." << '\n';
    }


    /*
     * bu satır ise her zaman çalışır.
     * çünkü if ya da else bloğu içerisinde
     * yer almamaktadır.
     */
    cout << "Program sona erdi" << '\n';


    // sadece if şeklinde de kullanılabilir
    if (yas < 18){
        cout << "18 yasindan kucuksunuz." << '\n';
    }



    // if else arasına ekstra koşullar ekleyebilirsiniz (else if)
    if (yas < 6){
        cout << "anaokul ogrencisi" << '\n';
    }
    else if (yas >= 6 && yas < 12){
        cout << "ilkokul ogrencisi" << '\n';
    }
    else{
        cout << "ogrenci" << '\n';
    }


    return 0;
}

tnrdll

C++ const değişkenler

C++ const değişkenler, değiştirilemez ve sadece okunur değişkenlerdir. Sabitler olarak da bilinirler.

C++ programlarında, aşağıda belirtilen veri türlerine sahip değişmezler yer alabilir:

  • Tam sayı (integer) sabitleri.
  • Kayan noktalı (float, double) sabitler.
  • Karakter (char) sabitleri.
  • Karakter dizisi sabitleri.

veri türü const isim = değer;

float const PI = 3.14;

Bir değişmez (sabit) tanımlandıktan sonra, programın herhangi bir yerinde değerini değiştirmek olanaksızdır.

#include <iostream>

using namespace std;

float const PI = 3.14;

int main() {

    cout << PI;
    return 0;

}

tnrdll

C++ register değişkenler

Değişkenlerin tümü bellek üzerindeki alanları kullanır ancak C++ register değişkenler bu durumdan müstesnadır.

Bir değişkenin register olarak tanımlanması; derleyiciye, değişkenin RAM içerisinde değil, cpu register içerisinde depolanacağını bildirmektir.

Bazı uygulamalarda, değişkenlere çok daha hızlı biçimde erişmek söz konusu olabilir. Böyle durumlarda, register değişkenler tanımlanarak; bellek alanları yerine, makinenin hızlı bellek yazmaçları kullanılabilir.

Her ne kadar değişken register ile tanımlanmış olsa da, register içerisine kayıt edileceği kesin değildir. Bu alanların miktarı sınırlı olduğundan, fazla sayıda register değişken tanımlanırsa amacına ulaşmaz. Kısacası, o anki donanımın durumuna bağlıdır. Eğer CPU içerisinde değişken için boş ve uygun olan bir register yok ise derleyici fazla bulduklarını normal bellek alanlarına yerleştirir.

#include <iostream>

using namespace std;

int main() {

    register int a = 100;
    cout << a;
    return 0;

}

tnrdll

C++ auto değişkenler

C++ programlama dilinde auto değişkenler, değişken türünün, başlangıç değerine göre kendiliğinden belirlenmesi amacıyla kullanılır. Başlangıç değeri atanmış değişkenlerin türü otomatik olarak belirlenmektedir.

C++ auto değişkenler, yerel değişkenler gibi çalışmaktadır. Geçerli oldukları fonksiyondan veya kapsamdam (scope) çıkılınca hafızadan atılır ve yeniden geçerli oldukları kısma veya fonksiyona girildiğinde yeniden oluşturulurlar.

C++ programlama dilinde tanımlanan tüm değişkenler aksi belirtilmediği sürece default olarak otomatik tanımlanır.

Bir değişkenin otomatik olduğu doğrudan belirtilerek de ifade edilebilir.

#include <iostream>

using namespace std;

auto topla(int a, int b) {

    auto sonuc =0;

    sonuc = a + b;
    return sonuc;

}

int main() {

    //otomatik algılar fakat mutlaka 
    //değer ataması yapılmalıdır
    auto toplam = 0;
    auto sonucMsg = "Sonuc: ";

    toplam =  topla(5, 6);
  
    cout << sonucMsg << toplam;
    //Sonuc: 11 yazdı.

    return 0;

}

tnrdll

C++ statik değişkenler

C++ statik değişkenler, oluşturulduğu andan itibaren global değişkenler gibi davranarak program çalışma süresince bellekte kalırlar. Fonksiyon kapsamı (scope) sonuna gelindiğinde bellekten atılmazlar.

Statik değişkenler, ilk tanımlandıkları değeri muhafaza ederler. Bir kez tanımlandıktan sonra üzerine yeni bir değer tanımlanamaz. 

#include <iostream>
using namespace std;

void say()
{
    //statik değişken tanımlandı, 
    //count = 0 oldu. 
    
    //tekrar çağrıldığında
    //count = 0;
    //yeniden tanımlanmayacak
    static int count = 0;
    cout << count << " ";

    // count değeri 1 arttırıldı
    count++;
}

int main()
{
  	//5 kez say fonksiyonu 
    //çalıştırılacak
    for (int i=1; i<=5; i++)

        say(); //0 1 2 3 4 yazdı

        /**
         * static int count = 0; yerine
         * int count = 0 
         * olarak tanımlansaydı,
         *
         * her döngüde count = 0 
         * olarak yeniden tanımlanacaktı
         * ve ekrana 0 0 0 0 0 yazacaktı
         */

    return 0;
}

Farklı bir örnek ve ekran çıktısı

#include <iostream>
using namespace std;

void fonk1(void) {
  
    //normal, yerel değişken.
    //her seferinde a = 1
    //çalışır
    int a = 1;
    cout << a << " ";
    a = a + 5;
    cout << a << " ";
}
void fonk2(void) {
    
    //statik davranışına dikkat!
    //a = 0 bir kez çalışacak
    //ve bir daha çalışmayacak
    static int a = 0;
    
    cout << a << " ";
    a = a + 9;
    cout << a << " ";
}

int main() {
 
    fonk1();
    fonk2();
    cout << endl;
    fonk1();
    fonk2();
    return 0;
}
tnrdll

C++ extern değişkenler

C++ extern değişkenler, dış değişkenler olarak da adlandırılırlar. Extern değişkenler, dışarıda tanımlanmış global değişkenlere bir nevi linktir. Fonksiyon dışarısındaki global değişkenlere erişmek için kullanılırlar.

Fonksiyon bloğunun dışarısında tanımlanmış fakat ana fonksiyondan önce, header dosyasından ya da kütüphane olarak dahil edilmemiş invisible bir global değişken, kullanılmak istendiği yerde, başına extern ifadesi eklenerek çağrılabilir.

Bazı durumlarda, bir program dosyası içerisine tanımlanan global değişkenlerin, başka bir programda da geçerli olması istenebilir. Böyle bir durumda da extern değişkenler kullanılır.

Aşağıdaki extern (dış) değişken kullanımına dikkat edelim

* a değişkeni extern olarak belirtilmeseydi, dışarıdaki a değişkenine erişemeyecekti.
#include <iostream>
using namespace std;

int main() {

    //extern olarak belirtilmeseydi 
    //ekrana 0 yazardı
    extern int a;
    
    cout << a;
    //100 yazdı.
}

int a = 100;
tnrdll

C++ global değişkenler

C++ global değişkenler, tüm fonksiyonların dışarısında tanımlanırlar ve genellikle programın en üstünde yer alırlar.

Global değişkenler, programın çalışma süresi boyunca değerlerini korurlar. Yerel değişkenlerde olduğu gibi, kapsam (scope) ya da bulundukları fonksiyon sona erdiğinde bellekten atılmazlar.

Tanımlanmış bir global fonksiyona, program çalıştığı sürece tüm fonksiyonlardan erişilebilir.

Basit bir örnek

#include <iostream>

using namespace std;

//global değişken 
//fonksiyonların dışarısında
//tanımlanır
int a = 100;

int main() {
    cout << a; 
    //100 değerini ekrana yazar
    return 0;
}

Global değişkenlerin fonksiyonlar aracılığı ile çağrılması

//global değişkenler
int a = 100;
int b = 200;

void fonk1(){
    cout << a << '\n';
}

void fonk2(){
    cout << b << '\n';
}

int main() {
    fonk1(); //100 yazdı.
    fonk2(); //200 yazdı

    return 0;
}

Global değişkenlerin güncellenmesi

#include <iostream>
using namespace std;

//global değişkenler
int a = 100;
int b = 200;

void fonk1(){
    a++;
    cout << a << '\n';
}

void fonk2(){
    b--;
    cout << b << '\n';
}

int main() {
    cout << a << '\n'; //100 yazdı
    cout << b << '\n'; //200 yazdı
    fonk1(); //101 yazdı
    fonk2(); //199 yazdı
    cout << a << '\n'; //101 yazdı
    cout << b << '\n'; //199 yazdı
    return 0;
}

Tavsiye edilmese de, global değişken ile aynı isimde yerel değişken tanımlanabilir

* Program hatasız çalışır ama IDE ya da editörünüz, sizi bu hususta uyaracaktır.
#include <iostream>
using namespace std;

//global değişken
int a = 100;

void globalDegeriGoster(){
    cout << a << '\n';
}

int main() {
    //tavsiye edilmese de, 
    //global değişken ile aynı isimde 
    //yerel değişken tanımlanabilir.
    int a = 50;
    cout << a << '\n'; //50 yazdı

    globalDegeriGoster();//100 yazdı

    return 0;
}
tnrdll

C++ local variables (yerel değişkenler)

C++ local variables (yerel değişkenler), bir fonksiyon ya da blok içerisinde tanımlanan değişkenlerdir. Yalnızca tanımlandıkları blokta kullanılırlar. Bulundukları kapsam dışarısından, dış fonksiyonlardan erişilemezler.

Yerel değişkenler, program yürütüldüğünde aktif hale geçerek kendisi için ayrılan bellek alanlarını kullanırlar.

Yer aldıkları blok sona erdiğinde, bu bellek alanları kendiliğinden iptal olur ve değişken içeriği tamamen yok olur. Bu sayede, bellek alanları, yeniden kullanılabilmek üzere boşa çıkmaktadırlar.

#include <iostream>

using namespace std;


int main() {
    
    /*
     * main fonksiyonu içerisinde 
     * kullanılacak yerel değişken 
     * tanımlamaları
     */
    int a, b, c;
    int toplam;

    //değişkenlere değer atama
    a = 100;
    b = 200;
    c = 300;

    toplam = a + b + c;

    cout << toplam;

    return 0;
}

void digerFonksiyon(){

    // HATALI KULLANIM. 
    // diğer fonksiyondaki yerel 
    // değişkene erişilemez ve 
    // yeni değer atanamaz.
  
    // main fonksiyonu sona 
    // erdiğinde a değişkeni de 
    // bellekten kaldırılmıştır.
    a = 10; !!!
}