C++ Dilinde Static Ömürlü Nesneler

C++ dilinde nesnelerin ömürlerinin farklı farklı olabildiğini ve farklı ihtiyaçları karşıladığını dinamik ömürlü nesnelerle değerlendirmeye başlamıştık. Bu kavramı anlayabilmek için lifetime, memory location, initialize, access control, instance gibi kavramları programlama dünyamızda iyice oturtmamız gerekmektedir.

Static ömürlü değişkenler program çalıştığı andan sona ermesine kadar hayatta kalır. Bu değişkenler genellikle data segment alanında saklanırlar. Fonksiyonun ilk çağrılışında tanımlanır ve bir kez initialize edilirler. Erişim(access) olarak tanımlandıkları blok içinde erişim sağlanabilir, globalde tanımlı ise program içinde erişim sağlanır. Bu kısa özet genel olarak statik ömürlü değişkenlerle ilgilidir. Bundan sonra C++ özelinde static kavramına biraz daha detaylı örneklerle değineceğiz.

class SmartCode {
private :
    int sc;
    static int s_sc;

public :
    static int check_static() 
    {
        sc = 23; 
        return sc;                             
    }
};

int SmartCode::s_sc;

int main()
{
}
*****************************
AÇIKLAMA: sınıfın static üye fonksiyonu non-static üye fonksiyonuna doğrudan erişim sağlayamaz. this pointer'ı yoktur.
*****************************
CEVAP:
*****************************

class SmartCode {
private :
    int sc;
    static int s_sc;

public :
    static int check_static() 
    {
        s_sc = 23; 
        return s_sc;                            
    }
};

int SmartCode::s_sc;

int main()
{
    SmartCode::check_static();
    
    return 0;
}
*****************************
AÇIKLAMA: sınıfın static üye fonksiyonu static üye fonksiyonuna doğrudan erişebilir. this pointer'ı vardır.
*****************************
CEVAP:
*****************************

"https://ysfhncr.wixsite.com/smartcoding/post/c-dilinde-this-pointer" this pointer konusuna burada değindik...

class SmartCode { 
public : 
    static int sc;           
};                                     
                                           
int SmartCode::sc;    
              
int main() 
{ 
    SmartCode val;
    SmartCode* ptr{ &val };

    val.sc = 20;         
    ptr->sc = 30;  
}
*****************************
AÇIKLAMA: erişim doğru şekilde yapılmıştır. sınıfın sc değişkeni static olmasaydı this pointer'ı ile erişim sağlanırdı.
*****************************
CEVAP:
*****************************

Sınıf içerisinde dizi tanımlarken boyut belirtmek istenmiyorsa static olarak tanımlanmalıdır. Aksi durumda sentaks hatası alınır.

class SmartCode { 
public : 
    static int s_arr[];  // legal 
    int arr[];           // error  
};                                     
               
int main() 
{ 
}
*****************************
AÇIKLAMA: c++ dilinde static boyutlu diziler boyuta sabit olmalıdır. Derleme zamanında bu boyut sabit olmalıdır. Dinamik boyutlu dizi tanımlanmak istenirse c++ dilinin containerlarından faydalanılabilir.(std::vector...)
*****************************
CEVAP:
*****************************

Sınıfın static veri elemanın const ve integer değil ise ilk değer vermek hatalıdır. c++17 ile static değişkenlerde inline tanımlanabildiği için static inline ve integer olarak da geçerli hale getirilebilir.

!! inline konusuna detaylı değineceğiz.->

class SmartCode { 
public : 
    static int sc1 = 21;          // ISO C++ yasaklamıştır.
    static double sc2 = 22;       // ISO C++ yasaklamıştır.
    static const double sc3 = 23; // ISO C++ yasaklamıştır.
    static const int sc4 = 24;    // legal
    static inline int sc5 = 25;   // legal
};                                     
               
int main() 
{ 
}
*****************************
AÇIKLAMA: 
*****************************
CEVAP:
*****************************

Sınıf içerisinde incomplete type türünden nesne oluşturamayız ancak static olarak bunu legal kılabiliriz.

class SmartCode;                 

class Myclass {
public:  
    SmartCode sc1;             //syntax error. 
    SmartCode* sc2;            //syntax error
    SmartCode& sc3;            //syntax error
    static SmartCode sc4;      //legal
};
*****************************
AÇIKLAMA: derleyici SmartCode sınıfının tanımını görene kadar incomplete type olarak değerlendirir.
*****************************
CEVAP:
*****************************

class SmartCode {
private :
    SmartCode() = default;

public :
    static SmartCode* get_instance() 
    {
        if (!ptr) 
        {
            ptr = new SmartCode;
        }

        return ptr;
    }

private :
    static SmartCode* ptr;
};

SmartCode* SmartCode::ptr{ nullptr };

void smart_func() 
{
    auto p = SmartCode::get_instance();
}

int main() 
{
    //SmartCode m;    //error

    auto p1 = SmartCode::get_instance();

    smart_func();
    smart_func();

    auto p2 = SmartCode::get_instance();

    return 0;
}
*****************************
AÇIKLAMA: get_instance fonksiyonuna çağrı yapıldığında ilk çağrıda hayata gelmediğinden oluşturulup return edilir ancak diğer çağrılarda aynı sınıf nesnesi oluşturulur. Programın akışının sonuna kadar hayatta kalır.
*****************************
CEVAP:
*****************************

const üye fonksiyonlar sınıfın static veri elemanlarını değiştirebilir ancak non-static veri elemanlarını değiştiremez. Bunun için mutable eklenmiştir. mutable "https://ysfhncr.wixsite.com/smartcoding/post/c-dilinde-mutable" linkinden bilgi edinebilirsiniz.

class SmartCode {
private :
    static int sc1;
    int sc2;

public :
    void smart_func() const
    {
        ++sc1;  // legal
        ++sc2;  // error
    }
};

int main() 
{
    return 0;
}
*****************************
AÇIKLAMA: bu fonksiyondaki const, this pointer'ındır.
*****************************
CEVAP:
*****************************