Menü Kapat

C++ Değişkenleri Ve Sabitleri

Değişkenler ve Sabitler

Değişkenler program içerisinde değeri değiştirilebilen verilerdir. Sabitler ise tanımlandıktan sonra değiştirilemez. Değişken tanımlarken büyük-küçük harfe dikkat edilmesi gerekir. degisken ile Degisken aynı şeyler değildir. Değişken isimleri sayı içerebilir ama sayı ile başlayamazar. Değişkenler _ ile başlayabilirler.

Bir değişken tanımlanma sırasında değer alabilir. Bu değer program içerisinde sonradan değişebilir. Aynı zamanda değişken ilk tanımlamada değer almak zorunda değildir.

Değişken tanımlama:

değişken_türü değişken_adı;

Örneğin:

int x;

 

 

Değişkene değer verme

int x = 5 // Copy initialization

int  y(10); // Direct initialization

int z{5}; // Uniform initialization (C++11)

 

Direkt değer verme daha iyi performans gösterebilir. Ayrıca birkaç güçlü yana sahiptir. Bunun dışında direkt initialization sayesinde atama ve ilk değer verme işlemlerini birbirinden daha rahat ayırabiliriz.

Uniform initialization bir takım sebeplerden dolayı diğer iki tanımlamadan daha iyidir. Diğer iki tanımlama türüyle veri listeleri tanımlanamaz. Boş bir süslü parantez ile tanımlanan veri otomatik olarak sıfır değerini alır.

int a{6}; //Calisir

int b{};  //Calisir, sifir degeri alir.

int c{5.5} // Derleyici hata atar. integer degisken double deger alamaz.

 

Değer atama

bool degisken;

degisken = false; // Kopyalayarak atama

 

İlk değer verilmemiş değişkenler

C++ dilinde değişkenlere varsayılan olarak değer ataması yapılmaz. Eğer programcı tarafından değer atamsı yapılmamışsa değişken ramde saklandığı yerin önceki verisini tutmaya devam eder.

Çoklu değişken tanımlama

int a,b,c; // Uygun


/*  Uygun  */
int a;
int b;
int c;

int a(5), b{4}, c = 0; Uygun

int a, int b; // derleme hatası

 

  • Global Değişkenler

    Fonksiyon dışında yapılan tanımlamalar globaldir, istenilen yerde bu değişkene ulaşılabilir.

    Örnek:

    #include <iostream>
    using namespace std;
    
    int g; //Global değişken g
    
    int main () 
    {
       int a, b; //Yerel değişken a,b
       a = 10;
       b = 20;
       g = a + b;
       cout << g;
       return 0;
    }

     

    Yukarıda ki örnekte g bir global değişken, a ve b ise yerel değişkendir. Ana fonksiyonda a’ya, b’ye ve G’ye ulaşım sağlanbilir fakat a’ya ve b’ye ana fonksiyon dışında erişim sağlanamaz.

  • Statik Değişkenler

Program işlediği sürece bellekte kendisine belirli bir yer ayrılan değişken türüdür. Program çalışma süresince sadece bir kere tanımlanır. Örneğin bir fonksiyon içerisindeki bir statik değişken fonksiyon ne kadar çaırılırsa çağırılsın bir kez tanımlanır.

#include <iostream>

void ArttirVeYazdir()
{
    static int s_deger = 1;
    // Degisken statiktir.

    ++s_degisken;
    std::cout << s_degisken << std::endl;

} // s_degisken yok edilmedi.

int main()
{
    ArttirVeYazdir();
    ArttirVeYazdir();
    ArttirVeYazdir();

}

 

Programın çıktısı:

2
3
4

Auto Deyimi

Auto deyimi eğer değişken tanımlanırken değer alıyorsa kullanılır. Örneğin bir double değişkene 5.5 değerini vereceksek derleyici tanımlayacağımız değişkenin zaten double olduğunu çözebilir. Örneğin:

double x{ 5.6 };  //Derleyici 5.6'nin double literal oldugunu biliyor.

auto x { 5.6 }; //Yukaridakiyle ayni is yapilir. Derleyici x'in double oldugunu biliyor.

auto kullanıldığı zaman, derleyiciye, tanımlanan değişkenin atanacak değerin türü olacağı bildirilir. Bu işlem fonksiyon parametreleri için kullanılmaz. Örneğin:

int max(auto x, auto y)

{

    return (x > y ) ? x : y;

}

Bu çalışmayacaktır çünkü derleyici parametrelerin türünü derleme zamanı çözemeyecektir.

 

C++14 ile birlikte auto deyimi fonksiyon dönüş tipi olarak kullanılabilir hale geldi.

Örneğin:

auto topla(int x, int y)

{

   return x + y;

}

 

Sabitler

İki tür sabit vardır. Literaller ve sembolik sabitler.

Literaller

Literaller kodda direkt olarak yazılan ifadelerdir. Sabitlerdir çünkü değerleri değiştirilemez.

Örneğin

bool AmIAlive = true; // true bir literaldir ve değeri değiştirilemez.

int yas = 20; // 20 bir int literaldir ve degistirilemez.

char *isim = "Alperen"; // Alperen bir string sabitidir.

char A = 'A' // Char literal

double PI = 3.14159 // 3.14159 bir double literaldir.

double avogadro = 6.02e23;

 

Sayısal sabitler bazı eklere sahip olabilirler. Bu ekler o sabitin türünü belirler. İsteğe bağlıdırlar. Derleyici genellikle hangi sabiti kullanmak istediğinizi anlayabilir.

Data Type

Suffix

Meaning

int

u or U

unsigned int

int

l or L

long

int

ul, uL, Ul, UL, lu, lU, Lu, or LU

unsigned long

int

ll or LL

long long

int

ull, uLL, Ull, ULL, llu, llU, LLu, or LLU

unsigned long long

double

f or F

float

double

l or L

long double

İkilik, sekizlik ve on altılık sayı sabitleri

İkilik sayı sabitlerinin başına “0b”, sekizliklerin başına “0” ve on altılıkların başına “0x” koyulur.

int y = 0b01011001;

int x = 0765;

int f = 0xFF;

 

Sembolik sabitler

Normal değişkenlerin değerleri değiştirilebilirdir. Const değişkenler ise değiştirilemezler. Örneğin pi sayısı, dünyanın çekim ivmesi gibi değerlerin değişmediğini biliriz. Yazdığımız kodda da değişmemesi gerekmektedir. Bunun için değişken tanımının başına “const” ifadesini koyarız.

Const değerlere ilk değer ataması yapmak zorunludur.

Örneğin:

const double gravity { 9.8 }; // Dogrudur ve tercih edilir.
double const PI { 3.14 }; // Calisir ama onerilmez.

const int X; //Derleyici hatasi.

 

Const değişkenlere ilk değer atması olarak başka bir değişkenin değeri atanabilir. Örneğin:

std::cout << Yasiniz?;
int yas;
std::cin >> yas;

const int Kullanicininyasi(yas);

 

Constexpr

Constexpr değişkenler const değişkenler gibi sabitlerdir ama constexpr değişkenler derleme zamanı çözülmelidirler.

örneğin:

constexpr pi(3.14); /* Derleyici derleme sirasinda pi'ye atanacak degeri cözebildi. Sikinti yok */

int x;

std::cin >> x;

constexpr int foo(x) /* Derleme hatasi. Derleme sirasinda atanacak deger bilinmiyor. */

 

Önişlemci Kullanarak sabit tanımlama

C de çok kullanılan önişlemci sabitleri C++ da yazarken çok önerilmez. Çünkü dilin mekaniklerine aykırı bir kullanımı vardır ve yer yer ikiliklere sebep olabilir.

#define SABIT 100

int x = SABIT;

Tür dönüşümleri

Bir veri tipinin başka bir veri tipine çevrilmesidir. Bazı tip dönüşümleri veri kaybına sebep olurken bazılarını da yapmak mümkün değildir. C++ üstü kapalı (implicit) birçok dönüşümü otomatik olarak yapabilir. Örneğin, aşağıda int bir veri long bir veriye dönüştürülmüş.

int myInt{12};
long myLong;
myLong = myInt;

Bu durumda veri, daha büyük bir veri tipine dönüştürüldüğü için veri kaybı olmadı. Ama aşağıdaki durumlarda böyle bir durum söz konusu.

Dönüşüm

Olası riskler

Büyük kayan noktalı sayıyı, küçük kayan noktalı sayıya

Hassaslık kaybı ya da sınırların dışına taşma

Kayan noktalı sayıdan tam sayıya

Kesirli kısmın kaybı ya da sınırların dışına taşma

Büyük tam sayıdan küçük tam sayıya

Sınırların dışına taşabilir

Açık (explicit) tip dönüşümleri

C++ da beş farklı tip dönüşümü vardır. C-stili, static, dynamic, const ve reinterperet dönüşümler. Burada C-stili dönüşüm ve statik dönüşümler anlatılacak.

C stili dönüşüm

Bu dönüşümde parantez operatörü kullanılır. Parantezin içine yazılan tip dönüştürülecek tip olur. Örneğin:

int i1 = 10;
int i2 = 4;
float f = (float)i1 / i2;

 

Aynı zamanda bu şekilde de yapılabilir. (Daha çok fonksiyona benzeyen bir şekilde)

int i1 = 10;
int i2 = 4;
float f = float(i1) / i2;

 

static_cast
char c = 'a';
std::cout << static_cast<int>(c) << std::endl; // a değil 97 yazdırır.

Statik dönüşümün en iyi yanı, derleme zamanı kontrol yapmasıdır. Böylece mantıksız olabilecek işlemlerden kaçınılır.

Bir yorum yazınız. Yorumlarınız bizim için değerlidir.