Bir Sınıfın/Yapının statik üyeleri

Statik üyeler

Sınıf üyeleri, static bellek sınıfı şekillendiricisi kullanılarak bildirilebilir. Bu veri üyeleri sınıfın tüm örnekleri tarafından paylaşılır ve bir yerde depolanırlar. Statik olmayan veri üyeleri her bir sınıf nesnesi değişkeni için oluşturulurlar.

Statik üyelerin bildirilememesi, ilgili değişkenlerin global kapsamda bildirilmesini gerektirebilir. Bu, veri ile sınıf arasındaki ilişkiyi koparır ve NYP'nin temel paradigmasıyla (değişkenleri ve yöntemleri bir sınıfta bir araya getirme) uyumlu değildir. Statik üye, belirli bir örneğe özgü olmayan sınıf verisinin, sınıf çerçevesinde var olmasına izin verir.

Statik üye belirli örneğe bağlı olmadığından referansı şu şekilde olur:

sınıf_ismi::değişkenler

Burada sınıf_ismi sınıfın, değişken ise sınıf üyesinin ismidir.

Gördüğünüz gibi, sınıfların statik üyelerine erişmek için kavram çözümleme operatörü :: kullanılır. Sınıf yöntemleri içinde bir statik üyeye erişim gerçekleştirdiğinizde, kavram operatörünün kullanımı isteğe bağlıdır.

Statik sınıf üyesinin istenen değerler ile açık şekilde başlatılması gerekir. Yani, üyenin bildirimi ve başlatımı global kapsamda yapılmalıdır. Statik üyelerin başlatma sırası, global kapsamdaki bildirimlerinin sırasına karşılık gelir.

Metin ayrıştırma için kullanılacak bir sınıfımız (CParser) olduğunu düşünelim ve işlenen kelime ve karakter sayısını hesaplamamız gereksin. Tek yapmamız gereken sınıf üyelerini statik olarak tanımlamak ve bunları global düzeyde başlatmaktır. Sonrasında sınıfın tüm örnekleri, kelime ve karakterlerin ortak sayaçlarını kullanacaktır.

//+------------------------------------------------------------------+
//| Sınıf "Metin Analizci"                                           |
//+------------------------------------------------------------------+
class CParser
  {
public:
   static int        s_words;
   static int        s_symbols;
   //--- Yapıcı ve yıkıcı
                     CParser(void);
                    ~CParser(void){};
  };
...
//--- Parser (ayrıştırıcı) sınıfının statik üyelerinin global seviyede başlatılması
int CParser::s_words=0;
int CParser::s_symbols=0;

Bir statik sınıf üyesi const anahtar kelimesi ile bildirilebilir. Bunun gibi statik sabitler, global düzeyde ve 'const' anahtar kelimesiyle başlatılır:

//+------------------------------------------------------------------+
//| İşlenmiş veriyi depolamak için "Yığın" sınıfı                    |
//+------------------------------------------------------------------+
class CStack
  {
public:
                     CStack(void);
                    ~CStack(void){};
...
private:
   static const int  s_max_length; // Maksimum yığın kapasitesi
  };

//--- CStack sınıfının statik sabitinin başlatılması
const int CStack::s_max_length=1000;

this İşaretçişi #

Anahtar sözcük this üstü kapalı şekilde bildirilmiş, kendisine (yöntemin uygulandığı bağlamda belirli bir sınıf örneğine) yönelik bir işaretçiyi belirtir. Sınıfın sadece statik olmayan yöntemlerinde kullanılabilir. 'this' işaretçisi gizli ve statik olmayan bir sınıf üyesidir.

Statik fonksiyonlarda sınıfın sadece statik üyelerine/yöntemlerine erişebilirsiniz.

Statik yöntemler

MQL5 dilinde static tipli üye fonksiyonları kullanılabilir. 'static' şekillendiricisi fonksiyonun sınıf içindeki bildiriminde dönüş tipinden önce yer almalıdır.

class CStack
  {
public:
   //--- Yapıcı ve yıkıcı
                     CStack(void){};
                    ~CStack(void){};
   //--- Maksimum yığın kapasitesi
   static int        Capacity();
private:
   int               m_length;     // Yığındaki elemanların sayısı
   static const int  s_max_length; // Maksimum yığın kapasitesi
  };
//+------------------------------------------------------------------+
//| Yığında depolanan elemanların sayısına dцnьş yapar               |
//+------------------------------------------------------------------+
int CStack::Capacity(void)
  {
   return(s_max_length);
  }
//--- CStack sınıfının statik sabitinin başlatılması
const int CStack::s_max_length=1000;
//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- CStack tipli değişkenin bildirimini yap
   CStack stack;
//--- nesnenin statik yöntemini çağır
   Print("CStack.s_max_length=",stack.Capacity());
//--- yöntem statik olduğu ve nesnenin varlığına ihtiyaç duymadığı için şu şekilde de çağrılabilir
   Print("CStack.s_max_length=",CStack::Capacity());
  }

const şekillendiricisi ile bildirilen yöntemler, sabit olarak isimlendirilir ve sınıftaki gizli üyeleri şekillendiremezler. Sınıfın sabit fonksiyonları ve sabit parametrelerinin bildirimi const-correctness (sabit doğruluk) kontrolü olarak adlandırılır. Bu kontrol sayesinde derleyicinin nesne değerlerinin kararlılığını temin edeceğine ve yanlış bir şey varsa, derleme sırasında bir hata dönüşü yapacağına emin olabilirsiniz.

const şekillendiricisi, sınıf bildirimlerinde argüman listesinden sonra gelir. Sınıf dışındaki tanımlar da, aynı şekilde const şekillendiricisini içermelidir:

//+------------------------------------------------------------------+
//| Sınıf "Dikdörtgen"                                               |
//+------------------------------------------------------------------+
class CRectangle
  {
private:
   double            m_height;     // Yükseklik
   double            m_height;     // Yükseklik
public:
   //--- Yapıcılar ve yıkıcı
                     CRectangle(void):m_width(0),m_height(0){};
                     CRectangle(const double w,const double h):m_width(w),m_height(h){};
                    ~CRectangle(void){};
   //--- Alanın hesaplanması
   double            Square(void) const;
   static double     Square(const double w,const double h);// { return(w*h); }
  };
//+------------------------------------------------------------------+
//| "Dikdörtgen" nesnesinin alanına dönüş yapar                      |
//+------------------------------------------------------------------+
double CRectangle::Square(void) const
  {
   return(Square(m_width,m_height));
  }
//+------------------------------------------------------------------+
//| İki değişkenin çarpımına dönüş yapar                             |
//+------------------------------------------------------------------+
static double CRectangle::Square(const double w,const double h)
  {
   return(w*h);
  }
//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- Kenarları 5 ve 6'ya eşit bir rect dikdörtgen oluştur
   CRectangle rect(5,6);
//--- bir sabit yöntem kullanarak dikdörtgen alanını bul
   PrintFormat("rect.Square()=%.2f",rect.Square());
//--- CRectangle sınıfının statik yöntemini kullanarak sayıların çarpımlarını bul
   PrintFormat("CRectangle::Square(2.0,1.5)=%f",CRectangle::Square(2.0,1.5));
  }

Sabitlik kontrolü kullanmanın bir diğer faydası da, derleyicinin bu durumda özel bir optimizasyon oluşturmasıdır. Örneğin, sabit nesneyi salt okunabilir hafızaya yerleştirir.

Statik fonksiyonlar const şekillendiricisi ile belirlenemez; çünkü bu şekillendirici, fonksiyon çağrıldığı zaman örnek üyelerinin sabitliğini garanti eder. Ama yukarıda da belirtildiği gibi statik fonksiyon statik olmayan sınıf üyelerine erişemez.

Ayrıca Bakınız

Statik Değişkenler, Değişkenler, Referanslar: Şekillendirici & ve Anahtar Sözcük this

Sanal Fonksiyonlar

Fonksiyon Şablonları