C++ ile Storage Sınıfları

C++ ile Storage Sınıfları

Herkese merhabalar, bu yazıda sizlere C++ programlama dili ile Storage Class yapılarından bahsedeceğim. Bu yapılar ile programdaki değişkenlerin depolama zamanlarını ve depolama alanlarını belirleyeceğiz.

Hadi başlayalım

İlk olarak Storage class yapılarının görevleri nelerdi konusunu açıklığa kavuşturalım.

Storage Class nedir
Storage class yapıları: bir fonksiyonun veya değişkenin tanımlanması esnasında, onun amacını, görünürlüğünü ve bellekten ne zaman silineceğini belirten anahtar kelimelerdir. Örnek olarak: Bir değişkenin programın heryerinden erişilebilmesini veya bir değişkenin aynı olmamakla birlikte benzer değerlerinde alabilmeleri storage class anahtar kelimeleri ile sağlanır.

C++ programlama dilinde 5 tane storage class anahtar kelimesi bulunmaktadır:
  • auto ile tanımlanan değişkene benzer tiplerdeki değişkenler atanabilir. Örnek olarak int olarak kullanılan bir değişkene double veya float değerler atanabilir.
  • register ile tanımlanan bir değişkenin erişim hızını arttırmak amacıyla yer varsa CPU üzerindegi registerlarda tutulması istenir. Yer yoksa normal bellekte tutulur.
  • extern ile programın herhangi bir yerinde tanımlanan bir değişken başka biryerde başlatılır ve diğer yerlerden bu değişkene erişilerek veri okuma yazma yapılabilir. Static yapısına benzer global olarak kullanım sağlanır.
  • static ile tanımlanan bir değişkene programın her yerinden erişilebilir ve global olarak kullanılabilir hale gelir.
  • mutable ile cons olarak tanımlanan bir sınıfın içerisinde barındırılan bir değişkenin değiştirilmesine izin verilir. İlgili değişken mutable olarak tanımlanır.
Aşağıda storage sınıfı kullanımı örnekleri bulunmaktadır.

storage_sinif_adi degisken_tipi degisken_adi;
extern int x;
static double y;
class T{
     mutable int z;
}
Aşağıdaki tabloda storage sınıflarının detaylı bilgileri verilmiştir.
Anahtar Kelime Sınıfı Tutulma Süresi Görünürlük Başlangıç Değeri
auto Automatic Metod Bloğu Local Garbage
extern External Bütün Program Global 0 (Sıfır)
static Static Bütün Program Local(Tanımlandığı sınıf ile çağrılır) 0 (Sıfır)
register Register Metod Bloğu Local Garbage
mutable Mutable Sınıf içi Local Garbage

AUTO

auto storage sınıfı tanımlayıcısı kullanılarak bir değişken tanımlanır ve bu tanımlama esnasında herhangi bir değişken tipi tanımlamasına gerek yoktur. Çünkü derleyici zaten o değerin ne olacağını derleme esnasında biliyor olacaktır. Bu tarz durumlarda programı yazarken değişken tipi belirtmeyiz ve auto ile tanımlama yaparız. auto kullanılarak yapılan tanımlama biz geliştiricilere zaman kazandırmış olur.

auto storage sınıfı kullanıldığında derleyici uygun değişken tipini bulmak için ek zaman harcayacaktır. Dolayısıyla derleme süresi bir miktar uzayacaktır fakat sonuç olarak program uygun değişken tipi ile derlenmiş olacağından çalışmasında herhangi bir hız problemi olmayacaktır.

C++14 ten beridir fonksiyon tanımlamalarında dönen değer tipi olarakta kullanılmaya başlanmıştır.

Aşağıdaki örnek c++ programında auto sınıfının kullanımı görülmektedir.

ilk olarak aşağıdaki kütüphaneleri ekleyelim. Projenin geri kalanında eklenmiş olarak varsayılacaktır.


#include <iostream>
using namespace std;

void autoSinifi()
{
    cout << "Auto Sınıfı kullanımı " << endl;
 
    auto sayi = 14;
    auto sayi2 = 67.9;
    auto yazi = "Thecodeprogram";
 
    cout << sayi  << " \n";
    cout << sayi2  << " \n";
    cout << yazi << " \n";

    sayi = 123.456;

    cout << sayi  << " \n";
}
 
int main()
{
    autoSinifi();
    return 0;
}
Program çıktısı aşağıdaki gibi olacaktır:

Auto Sınıfı kullanımı
14
67.9
Thecodeprogram  
123

EXTERN

extern sınıfı ile bir değişkenin başka biryerde tanımlandığını ve başka bir yerde kullanılabildiğini belirtmektedir. Bu sayede bir değişkenin sınıf yapısının kullanılmadığı yerlerde, global olarak kullanılmasına olanak tanımaktadır. Değişken bir yerde tanımlanır ve değişkenin başlatılma işlemi başka bir yerde yapılmaktadır. Çok geniş bir programda farklı header dosyaları ile çalışılırken extern ile değişkenlerin global olarak kullanılmalarına olanak tanınmaktadır. Özellikle prosedürel dillerde çok faydasını gördüğüm bir sınıftır.

Değişken normal tanımlandıktan sonrada exter ile tanımlanarak global hale getirilmiş olabilmektedir.

Aşağıdaki örnekte extern anahtar kelimesinin kullanımı görülmektedir :

// değişken tanımlanır
int i;

void externSinifi()
{
    cout << "extern sınıfı örneği" << endl;
 
    // değişken extern yapılıyor
    extern int i;
 
    cout << " Extern i : " << i << endl;

    // değer atanıyor
    i = 33;
 
    cout << "Değer atanmış i : "  << i << endl;
}
 
int main()
{
    externSinifi();
 
    return 0;
}
Program çıktısı aşağıdaki gibi olacaktır:

extern sınıfı örneği 
Extern i : 0  
Değer atanmış i : 33 

STATIC

static sınıfı c++ programlama dilinde kullanılan en popüler storage sınıfıdır diyebiliriz. Bir değişken veya fonksiyonun başka bir yapı tarafından direk olarak erişimine izin verildiği storage sınıfıdır. static kelimesi sayesinde erişilmek istenen yapıya programın heryerinden direk olarak erişilebilmektedir.

Yani static ifadeler, tanımlandığında başlatılır ve program kapanana kadar herhangi bir şekilde bellekten kaldırılmazlar ve sürekli bellekte tutulur. Herhangi bir şekilde yeniden tanımlanmalarına gerek yoktur. Başlatıldıkları bellek bilgisini program kapanana kadar saklarlar.

Tanımlandıklarında herhangi bir değer atanmazlarsa derleyici tarafından değeri 0 olarak belirlenir.

Aşağıdaki kod bloğunda static ifadesinin kullanımı görülmektedir:

static int degisken = 33;

static int staticMetod()
{
    cout << "Static metod : " << endl;
    
    static int deger = 0;
    return deger;
}
 
int main()
{
    cout << "Static degisken : " << staticMetod() << endl;
    cout << "Static degisken : " << degisken << endl;
    return 0;
}
Program çıktısı:

Static metod :                                                                                                                                                                     
Static degisken : 0                                                                                                                                                                
Static degisken : 33 

Önemli not:
Static metodlar içerisinde this kelimesi kullanılamaz. Direk olaak ilgili sınıfları ile beraber çağrılırlar. Bu yüzden kendi başlarına global değillerdir. Sınıfları ile birlikte global olarak çağrılırlar.


REGISTER

register sınıfı ile auto sınıfı benzer şekilde çalışmaktadır. Farkları ise register olarak belirtilen bir değişkeni, derleyici CPU üzerindeki registerlar üzerinde tutmaya çalışır. Eğer uygunluk yoksa yine bellekte tutulurlar. Bu sayede ilgili değişkene daha hızlı erişim sağlanır. Çok fazla kullanılan değişkenlerin register ile tanımlanmaları önerilmektedir. Bu sayede programın çalışması esnasında RAM bellekten daha hızlı bir erişim sağlanacağı için performans artacaktır. Bu durum değişken CPU da tutulduğunda geçerlidir.

Birkaç tane değişken için yer tutulabileceği için bütün değişkenlerin register olarak tanımlanması doğru olmayacaktır. Bütün değişkenler CPUda tutulamayacaktır. Sadece gerekli olanların register olarak tutulmaları gerekmektedir.


void registerSinifi()
{
    cout << "Register sınıfı örneği" << endl;
 
    register int sayi = 33;
 
    cout << "Tanımlanan değer : " << sayi << endl;
    cout << "Adresi : " << &sayi << endl;
}

int main()
{
    registerSinifi();
    return 0;
}
Program çıktısı

Register sınıfı örneği                                                                                                                                                             
Tanımlanan değer : 33                                                                                                                                                              
Adresi : 0x7ffc9519a0dc

MUTABLE

mutable storage sınıfı ile, const olarak tanımlanan bir sınıfın içerisindeki bir değişkene değer atama işlemine olanak tanınmaktadır. Bu sayede herhangi bir değerinin değiştirilmemesi gereken bir sınıfı const olarak tanımlarız ama içerisinde değişmesini istediğimiz bir değişken olursa mutable olarak tanımlarız ve değiştirilmesine olanak tanımış oluruz.

Aşağıda mutable sınıfının kullanımı görülmektedir.:

class TestSinifi {
public:
    int sayi;
    mutable int mutable_sayi;
 
    TestSinifi()
    {
        sayi = 123;
        mutable_sayi = 33;
    }
};
 
int main()
{
    const TestSinifi testSinifi;
 
    testSinifi.mutable_sayi = 41;
    cout << "Mutable sayi : " << testSinifi.mutable_sayi << endl;
 
    // aşağıdaki kod bloğu çalışmayacaktır.
    // t1.sayi = 63;
    
    cout << "Mutable olmayan sayi : " << testSinifi.sayi << endl;
    return 0;
}
Program çıktısı aşağıdaki gibi olacaktır

Mutable sayi : 41  
Mutable olmayan sayi : 123

Buraya kadar storage sınıflarından bahsetmiş olduk.

Aşağıdaki link üzerinden örnek kod bloğuna Github üzerinden ulaşabilirsiniz. https://github.com/thecodeprogram/TheSingleFiles/blob/master/StorageSinifOrnekleri.cpp

Burak Hamdi TUFAN


Tags


Share this Post

Send with Whatsapp

Post a Comment

Success! Your comment sent to post. It will be showed after confirmation.
Error! There was an error sending your comment.

Comments

  • There is no comment. Be the owner of first comment...