C++’ta Değişkenler, Değişmezler ve Temel Operatörler

C++ dili C dilini kapsayan bir dil olduğundan, söz dizimi açısından birçok özelliği ondan almaktadır. Aslında bu eğitim serisinde C tarafında hali hazırda anlatılan şeyleri tekrar anlatmayı düşünmüyordum. Ancak C++ dilinde, C dilindeki bu özelliklere ek pek çok farklı yaklaşım eklenmiştir. Bu nedenle bu bölümün tamamında yer alacak yazılarda, temel özellikler ile ilgili özet geçip yeni eklenen özelliklere de değineceğim. Böylelikle doğrudan C++ ile alakalı bilgileri daha kolay kavramış olacaksınız.

C yazılarımda aslında temel türlerden, değişkenlerden ve aritmetik işlemlerden bahsetmiştim. Şimdi bu bilgilerin fazla ayrıntısına girmeden anlatacak ve C++’ta nelerin değiştiğine değineceğim. Öncelikle tür (type) kavramından başlayalım. C++’ta her bir ismin ve ifadenin bir türü vardır. Bu tür bilgisi sayesinde bu isim veya ifadeye hangi işlemlerin uygulanabileceğine karar verilir. Örneğin sayi isimli ve int türünden bir değişken bildirimi yapalım:

int sayi;

Bu değişkenin sahip olduğu int tür bilgisi, bu değişkenin programda bir tamsayı tuttuğunu belirtir. Derleyici de buna göre aksiyon alıp gerekli gördüğü yerde uygun dönüşümleri sağlayacaktır. Az önce bahsettiğim bildirme (declaration) kavramını yine C yazılarımda açıklamıştım. Bir değişkeni bildirmek demek, aslında onun varlığını programa tanıtmak demektir. Yani yukarıda derleyiciye “sayi isimli bir değişken var ve bu int türündedir” demiş oluyoruz.

Bunun yanında bir de nesne (object) diye bir kavram bulunmaktadır. Evet bu biraz nesne yönelimli programlamaya yönelik bir kavram gibi gözükse de aslında belli bir türde değer tutan bellek alanı anlamına gelmektedir. Bu kavram aslında C dilinde de yer almaktadır. Değer (value) ise belli bir türe göre yorumlanmış bit topluluğudur. Buradan yola çıkarak anlayabiliriz ki değişken (variable) dediğimiz şey aslında isimli nesnelerdir.

Dilin kendisi tarafından sağlanan türlere temel türler (fundamental types) adı verilmektedir. C++ dilinde C’ye göre çok daha fazla temel tür bulunmaktadır. Ben hepsinden ayrıntılı bir şekilde burada bahsetmeyeceğim. İlgilenenler buradaki sayfayı inceleyebilirler. Burada karşımıza sık çıkanları açıklamları ile beraber listeleyeceğim:

• void: Bu tür aslında değerlerin boş kümesini belirtir. Yani nesnenin türsüz olduğunu göstemenin bir yoludur. Ancak normal değişkenler doğrudan void türünde tanımlanamazlar. Genellikle gösterici değişkenleri ile beraber ve fonksiyon geri dönüş türü olarak kullanılır.
• int: Temel tamsayı türüdür. C++ standartlarında en az 16-bit olması garanti altına alınmış olsa da boyutu derleyiciye göe değişir. short, long ve long long gibi pek çok varyasyonu bulunmaktadır. Ayrıca signed ve unsigned anahtar kelimeleri ile işaretli veya işaretsiz olarak bildirilebilir.
• bool: true ve false olmak üzere iki değer tutabilen bir türdür. Bu türün boyutu implementasyona bağlıdır ve 8-bit (1 byte) değerinden daha büyük olabilir.
• char: Tek bir karakter tutabilen bir türdür. Tıpkı int gibi signed veya unsigned olarak bildirilebilir.
• float: 32-bitlik ondalıklı sayı tutabilen bir türdür.
• double: 64-bitlik ondalıklı sayı tutabilen bir türdür.
• long double: Boyutu derleyiciye bağlı olmak üzere genellikle 80-bitlik (10 byte) ondalıklı sayıları tutabilen bir türdür.
• nullptr_t: C++11 standartları ile gelen bu tür hiçbir yeri göstermeyen (null) göstericileri belirten nullptr anahtar kelimesinin türünü belirtir.

Tamsayı türleri arasındaki şu ilişki C++ standartlarında garanti altına alınmıştır:

1 == sizeof(char) <= sizeof(short) <= sizeof(int) <= sizeof(long) <= sizeof(long long)

Bu arada sizeof opratörü ile bir türün, ismin veya ifadenin bellekte kaç byte yer kapladığını bulabileceğimizi hatırlayalım. Şöyle bir örnek ile çeşitli türlerde nasıl değişkenler bildirebileceğimizi ve türlerin boyutlarını kendi derleyicimizde nasıl öğrenebileceğimizi özetleyelim (çıktı sizin derleyicide değişiklik gösterebilir):

// Code 2.1.1: Code2_1_1.cpp
// Değişkenler ve Türler

#include <iostream>

using namespace std;

int main()
{
    int integer;
    unsigned int uInteger;
    long long longLongInteger;
    unsigned long long uLongLongInteger;
    bool test;
    char character;
    unsigned char uCharacter;
    float singlePrecision;

    cout << sizeof (integer) << endl;
    cout << sizeof (uInteger) << endl;
    cout << sizeof (short) << endl;
    cout << sizeof (unsigned short) << endl;
    cout << sizeof (long) << endl;
    cout << sizeof (unsigned long) << endl;
    cout << sizeof (longLongInteger) << endl;
    cout << sizeof (uLongLongInteger) << endl;
    cout << sizeof (test) << endl;
    cout << sizeof (character) << endl;
    cout << sizeof (uCharacter) << endl;
    cout << sizeof (singlePrecision) << endl;
    cout << sizeof (double) << endl;
    cout << sizeof (long double) << endl;

    return 0;
}

Değişkenleri sadece bildirerek bir yere varmamız pek mümkün değildir. Onların görevlerini düzgün bir şekilde yerine getirmelerini istiyorsak, onlara çeşitli değerler atamamız gerekmektedir. Genellikle C’den gelen bir alışkanlıktan dolayı bu ilk değer atama işini “=” operatörü ile yaparız. Bu operatörde sol tarafta yer alan ifade bir nesne belirtmelidir. Sağ tarafta ise bellekte yer kaplayan bir nesne olması gerekli değildir. Peki nesneler dışında C++’ta neleri kullanabiliriz?

C++ dilinde belli bir değişkene değer vermek ve çeşitli ifadelerde çeşitli amaçlar için kullanılmak üzere değişmez (literal) adı verilen ifadeler vardır. Bu ifadeler kaynak koda bir kez gömülürler ve programın sonuna kadar değerlerini korurlar. Ayrıca bu ifadeler bir nesne belirtmezler. Aslında kaynak kodda kullandığımız çeşitli sayılar, karakterler, String’ler ve daha pek çok şey bu kategoriye girmektedir. Elbette yazılan değişmezler de kodda belli bir türe sahip olurlar. Yazım biçimine göre bu tür değişiklik gösterir. C++’ta bulunan değişmez türleri ve açıklamları şöyledir:

Tamsayı değişmezleri aslında kodda yazdığımız bütün negatif ve pozitif tamsayıları kapsar. Varsayılan olarak bu sayılar int türünde ele alınır ve eğer bir ön ek almamışlarsa 0-9 arasındaki bütün rakamları içerebilirler (yani onluk tabanda ele alınırlar). Bununla birlikte sayıları sekizlik, onaltılık ve ikilik tabanda yazma imkanımız da vardır. İkilik tabanda yazma olayı C++14 ile birlikte gelmiştir. Bütün tabanlarda yazılabilecek tamsayı değişmezlerini ve örneklerini şu şekilde sıralayabiliriz:

Bu değişmezlerin varsayılan olarak int türünde ele alındığını söylemiştik. Ancak bazı son ekler ile bunların türünü değiştirmek de mümkündür. Örneğin l veya L son ekini kullanarak bu değişmezlerin long türünde olduğunu belirtebiliriz. Aynı şekilde ll veya LL son ekini kullanarak bu değişmezlerin long long türünde olduğunu belirtebiliriz. Bu özellik C++11 standartları ile beraber gelmiştir. Bunlara ek olarak u veya U son eki ile bu değişmezlerin unsigned yani işaretsiz bir tür olduğunu belirtebiliriz. Değişmezlerin işaretsiz olma son eki diğer son ekler ile beraber kullanılabilir. Birkaç örnek vererek konuyu pekiştirelim:

06456 // int (sekizlik tabanda)
565468l // long (onluk tabanda)
12312431324LL // long long (onluk tabanda)
0xFA12B23llu // unsigned long long (onaltılık tabanda)
989898lU // unsigned long (onluk tabanda)
0b01010010101U // unsigned int (ikilik tabanda)

Son olarak da C++14 ile birlikte gelen tek tırnak işareti (‘) ile uzun sayıları ayırma olayından bahsedelim. Bu aslında derleyici tarafından yoksayılan bir durumdur. Tamamen kullanıcılar için bu sayıları okunabilir kılmak amacıyla dile eklenen bir özelliktir. Şu iki örnek ile konuyu anlayacağınızı düşünüyorum:

unsigned long long test1 = 19'984'323'734'012llu
unsigned long long test2 = 204'9104'2536'7847'0512LLu

Şimdi de karakter değişmezlerinden biraz bahsedelim. Bu değişmezler tek tırnak arasında yer alırlar. Eğer tırnaklar arasında bir karakter yazıldıysa ve tırnakların önünde herhangi bir ön ek yoksa, C++ bunları char türünde algılayacaktır. Ancak bazı ön ekler ve birden fazla karakter yazımı ile bu durum değişebilir. Hemen derleyicinin bu karakter değişmezini hangi durumda nasıl algılayacağını örneklerle gösterelim:

Burada u ve U ön ekleri C++11 ile dile eklenmiştir. Ayrıca u8 ön eki C++17 ile dile ilk başta char olarak eklenmiş, daha sonra C++20’de anlamı char8_t olarak değiştirilmiştir. Şimdilik sadece ilk yazım biçimini bilmeniz yeterlidir. Diğerleri ile ilgili ayrıntılı bilgileri sonraki yazılarımda vermeyi düşünüyorum.

Ondalıklı sayı değişmezleri ile ilgili yine pek çok farklı kombinasyon bulunmaktadır. Ancak bizim şimdilik bilmemiz gereken şey bu değişmezlerin ondalık kısmının “.” ile ayrıldığıdır. Ayrıca “.” işaretinden öncesini veya sonrasını belirtmemek de mümkünüdür. Bu durumda belirtilmeyen kısım 0 olarak ele alınacaktır. Bu bahsettiğim yazım biçimlerinde yazılan ondalıklı sayılar, C++ dilinde varsayılan olarak double türünden algılanırlar. Örnek:

123.566
131.
.35643

Yine C yazılarımda bahsettiğim gibi e veya E harfi ile pozitif veya negatif üs belirtmeniz mümkündür. Ayrıca f veya F son eki ile değişmezin türünü float olarak değiştirebilirsiniz. l veya L kullanarak da türü long double olarak değiştirebilirsiniz. Bir de tamsayı sabitlerinde olan tek tırnak (‘) ile ayırma özelliği ondalıklı sayı değişmezlerinde de mevcuttur (C++14 ve sonrası için). Daha fazla örnek yazalım:

121. // double
45E-2 // double
56.89e9F // float
890.098132l // long double
.23e3 // double
3.14159'26535'89793'23846'26433'83279'50288 // double

Boolean değişmezleri ise iki tanedir: true ve false. Bu değişmezler C++’ta bool olarak ele alınırlar. Bunun dışında String değişmezleri çift tırnak (“) arasına yazılırlar. Bu değişmezlerin türleri (N karakter sayısı olmak üzere) const char[N] olarak ele alınır. Ancak bu konuya şu an girmeyeceğim. Ayrıca nullptr ve kullanıcı tanımlı değişmezlere de daha sonraki yazılarda değineceğim. Şimdi C derslerinden aşina olduğumuz artimetik, karşılaştırma, mantıksal ve birleşik atama operatörleri ile ilgili bilgileri özet geçelim. Öncelikle aritmetik operatörleri (arithmetic operators) örnekleri ile beraber listeleyelim:

Tüm aritmetik operatörler sonuç geri döndürürler. Yani uygulandıkları terim veya terimleri etkilemezler. Bunun yanında tek terimli “+” ve “–” operatörleri ardışık kullanımda sağdan sola bir öncelik yönüne sahip iken, diğerleri soldan sağa öncelik yönüne sahiptirler. Bu operatörlerin aynı seviyede bir arada kullanımında ise tek terimli “+” ve “–” operatörleri en öncelikli, “*“, “/” ve “%” operatörleri onlardan bir düşük öncelikli, iki terimli “+” ve “–” operatörleri ise en düşük öncelikli olarak ele alınırlar. Elbette parantez kullanımı önceliği arttırabilir. Örneğin aşağıdaki ifade hesaplanırken önce parantez içindeki “+“, daha sonra “*“, daha sonra “%“, daha sonra “/“, daha sonra parantez dışındaki “+” ve en son da “–” işleme alınarak 20 sonucu elde edilir:

int a = (8 + 2) * 2 + 1 – 5 % 3 / 2;

Bunun yanında if gibi yapıların koşul kısmında sıkça kullanılan karşılaştırma operatörlerini (comparison operators) inceleyelim:

“<=>” operatörü C++20 ile dile eklenmiştir ve diğerlerinden biraz daha farklı bir operatördür. Bu operatör ile iki nesnenin birbirinden küçük olma, büyük olma veya birbirine eşit olma durumlarını tek seferde karşılaştırabilirsiniz. Ancak şu an onun ayrıntılarına girmeyeceğim. “==” ve “!=” operatörleri (“<=>” hariç) diğer operatörlerden daha önceliklidirler. Ayrıca bu operatörlerin hepsi soldan sağa bir öncelik yönüne sahiptirler. Yine “<=>” operatörü haricindeki diğer tüm operatörler sonuç olarak true veya false geri döndürürler. Şimdi de mantıksal operatörleri (logical operators) inceleyelim:

Bu operatörler aslında klasik önerme mantığına dayanmaktadırlar. Mantıksal işlem sonucunda true veya false değerini geri döndürürler. Eğer bu operatörlerin terimlerinden biri bool türünde değilse, öncelikle bu türe dönüşüm yapılır. Şimdi son olarak atama operatörleri (assignment operators) ile arttırma ve azaltma operatörlerini inceleyelim:

Atama operatörleri değişkenler üzerinde etki bırakır ve hesaplama yönleri sağdan sola doğru olur. Yani önce sağ taraftaki ifadeler hesaplanır, daha sonra sol tarafa atama yapılır. Bunun yanında arttırma ve azaltma operatörleri değişkenlerin değerini bir arttırma veya bir azaltma görevini yerine getirirler. Eğer bu operatörler terimin önünde kullanılırsa öncelik yönleri sağdan sola, arkasında kullanılırsa öncelik yönleri soldan sağa olacaktır. Girilen yıllar arasındaki artık yıl sayısını bulan program örneği ile operatörler konusunu sonlandıralım:

// Code 2.1.2: Code2_1_2.cpp
// Belli Aralıktaki Artık Yıl Sayısını Bulma

#include <iostream>

using namespace std;

int main()
{
    int year1, year2;
    int total = 0;

    cout << "1. yili girin: ";
    cin >> year1;

    cout << "2. yili girin: ";
    cin >> year2;

    int i = year1;
    while(i != year2)
    {
        if(((i % 4 == 0) && (i % 100 != 0)) || (i % 400 == 0))
        {
            total += 1;
        }
        i++;
    }

    cout << year1 << " ile " << year2 << " arasindaki artik yil sayisi: " << total << endl;

    return 0;
}

Bunlara ek olarak çeşitli bitsel operatörler bulunsa da bunlar şimdilik konumuzun dışındadırlar. Şimdi C++’ta bir nesneye ilk değer verme ile ilgili birkaç konudan bahsedip yazıyı bitirelim. C++’ta bir nesneye ilk değer vermeden onu kullanmanız tanımsız davranışa (undefined behavior) neden olacaktır. İlk değer verme (initialization) işlemi bir nesneyi bildirdikten sonra ona ilk değerini atama anlamına gelmektedir. Bu atama işlemini yukarıdaki örnekte gördüğünüz total veya i değişkenlerinde olduğu gibi yapabilirsiniz. Yani bir nesneye ya bir değişmez ile ya da başka bir değişkenin veya ifadenin değeri ile ilk değer vermeniz mümkündür. Yine year1 ve year2 değişkenlerinde olduğu gibi bir nesnenin ilk değerini kullanıcıdan almanız da mümkündür.

C dilinde genellikle “=” ile ilk değer verme notasyonu kullanılsa da C++ dilinde nesneye ilk değer verme ile ilgili pek çok notasyon getirilmiştir. Şimdi buarada biraz bu notasyonlardan ve farklarından bahsedelim. Öncelikle bu notasyonların neler olduğuna bakalım:

double a = 9.7;
double b {9.7};
double c = {9.7};
double d (9.7);
double e = (9.7);

Yukarıdaki 5 değişkene de farklı notasyonlar ile aynı ilk değer verilmiştir. İlk notasyon zaten C’den aşina olduğunuz notasyondur. Süslü parantezlerle yapılan ilk değer verme işlemi liste ile ilk değer verme (list initialization) olarak adlandırılır. Bu tip bir ilk değer verme işleminde süslü parantezler arasına yazılan ifadelerin türleri değişkenin türü ile aynı olmalıdır. Yoksa derleme zamanında hata ile karşılaşırsınız. Örneğin aşağıda ilk satırda bir int değişkenine double türünden bir değişmez atanabiliyorken, ikinci satırda derleyici hata verecektir:

int test1 = 9.8; // test1 = 9
int test2 {9.8}; // HATA!

Yani süslü parantezlerle yapılan ilk değer verme işleminde katı bir tür kontrolü mevcuttur. Eğer dönüştürülen tür veri kaybına neden oluyorsa buna izin verilmez. Ancak veri kaybı gibi bir durum söz konusu değilse ilk değer verme işlemi başarıyla yapılır. Örneğin aşağıdaki kodlarda bir hata yoktur:

double test1 {9}; // test1 = 9.0
double test2 = {8}; // test2 = 8.0

Çünkü double türünden int türüne olan dönüşüm veri kaybına neden olabilirken, tam tersi bir dönüşümde veri kaybı mümkün değildir. Normal parantezler ile ilk değer vermede ise herhangi bir daraltıcı dönüşüm (narrowing conversion) olup olmadığına bakılmaz. Bir de süslü parantezlerin içini boş bırakarak o değişkene varsayılan ilk değeri vermeniz mümkündür. Örneğin aşağıdaki değişkene 0 ilk değeri atanacaktır:

int a {};

Ancak normal parantezler ile bunu yapmanız pek önerilmez. Çünkü derleyici bunu bir fonksiyon çağrısı olarak algılayacaktır. Derleyici buna bir hata vermese bile yalnış sonuçlar elde etmenize neden olacaktır:

int b ();

Şimdi C++11 ile anlamı değişen auto anahtar kelimesinden kısaca bahsedelim. Bu anahtar kelime ile bir nesnenin tür bilgisini başta belirtmenize gerek kalmaz. Ona atanan ilk değerden tür bilgisi algılanır. Aşağıdaki örnekleri inceleyelim:

auto a = 12; // int
auto  b = false; // bool
auto c = 9.8; // double
auto d = 7.66f; // float
auto e = 'A'; // char

Gördüğünüz gibi değişkene verilen ilk değerimn türünden yola çıkarak, nesnenin tür bilgisi otomatik olarak algılanmıştır. Burada aslında bir tür dönüştürme tehlikesi olmadığından “=” ile ilk değer verme notasyonunu rahatlıkla kullanabilirsiniz. Ancak parantezler ile ilk değer verme notasyonunu kullanmanızda da bir sakınca yoktur. Genellikle bu anahtar kelimeyi tür bilgisi çok uzunsa veya çok fazla isim alanının içinde yer alıyorsa kullanmak daha etkili olur. Böylelikle hataya açık ve uzun yazımlardan kurtulmuş oluruz. Ayrıca daha sonra göreceğimiz genelleyici programlamada (generic programming) tahmin edilmesi zor tür bilgileri için bu anahtar kelime oldukça önemli hale gelecektir.

Bu yazıda C dilinden aşina olduğumuz çeşitli temel kavramları C++ dilinde gelen yenilikleri ile beraber anlatmaya çalıştım ve mümkün olduğunca da yeni standartlar ile nelerin değiştiğine değinmeye çalıştım. Bu yazıda bazı konulara çok ayrıntılı girmedim. Çünkü bunların ayrıntılarını ileriki yazılarda göreceğiz. Ayrıca zaten C’de yer alan ve C++’ta herhangi bir değişikliğe uğramamış özelliklere de çok fazla değinmedim. Kesinlikle C++ ile ilgili yazılarımı okurken C’ye biraz da olsa aşina olmanızı tavsiye ederim.