اعضای ایستای کلاس

   همان طور که می دانید متغیری که در یک تابع از نوع static تعریف می شد، هنگام خروج از تابع از بین نمی رفت و مقدار خود را خفظ می کرد و با فراخوانی مجدد تابع قابل دسترسی بود. در کلاسها نیز می توان اعضا را به صورت ایستا (static) تعریف کرد. چنین عضوی که به صورت ایستا تعریف می شود، برای همه اشیایی که از نوع آن کلاس تعریف می شوند، به صورت مشترک قابل دسترسی است و هنگامی که مقدار این عضو در یکی از این اشیا تغییر می کند مقدار جدید در سایر اشیا از نوع آن کلاس نیز قابل استفاده می باشد. چنین عضوی ممکن است مانند متغیر عمومی به نظر آید، اما این عضو دارای حوزه کلاس می باشد و مانند متغیر عمومی دارای حوزه فایل نیست. اعضای ایستای یک کلاس می توانند از نوع public ویا private باشند. همچنین اعضای ایستا از طریق توابع عضو کلاس و یا توابع دوست یک کلاس قابل دسترسی می باشند. ضمنا به اعضای ایستایی که به صورت عمومی تعریف شده اند، می توان مستقیما از طریق عملگر (::) دسترسی یافت.

   برای آشنایی با نحوه به کار گیری اعضای ایستای کلاس و نیز مدیریت حافظه پویا به برنامه زیر توجه کنید:

#include <iostream.h>
#include <new.h>
#include <string.h>
 
class Employee {
  public:
    Employee( const char *, const char * );
    ~Employee();
    const char *getFirstName() const;
    const char *getLastName() const;
 
    // static member function
    static int getCount();
 
  private:
    char *firstName;
    char *lastName;
 
    // static data member
    static int count;
};
 
int Employee::count = 0;
 
int Employee::getCount()
{
  return count;
}
 
// constructor dynamically allocates space for
// first and last name and uses strcpy to copy
// first and last names into the object
Employee::Employee(const char *first,const char *last)
{
  firstName = new char[ strlen( first ) + 1 ];
  strcpy( firstName, first );
 
  lastName = new char[ strlen( last ) + 1 ];
  strcpy( lastName, last );
 
  ++count; // increment static count of employees
 
  cout << "Employee constructor for " << firstName
       << ' ' << lastName << " called." << endl;
}
 
// destructor deallocates dynamically allocated memory
Employee::~Employee()
{
  cout << "~Employee() called for " << firstName
       << ' ' << lastName << endl;
 
  delete [] firstName; // recapture memory
  delete [] lastName; // recapture memory
 
  --count; // decrement static count of employees
}
 
const char *Employee::getFirstName() const
{
  return firstName;
}
 
const char *Employee::getLastName() const
{
  return lastName;
}
 
int main()
{
  cout <<"Number of employees before instantiation is "
       <<Employee::getCount() << endl;
 
  Employee *e1Ptr = new Employee( "Susan", "Baker" );
  Employee *e2Ptr = new Employee( "Robert", "Jones" );
 
  cout << "Number of employees after instantiation is "
       << e1Ptr->getCount();
 
  cout << "\n\nEmployee 1: "
       << e1Ptr->getFirstName()
       << " " << e1Ptr->getLastName()
       << "\nEmployee 2: "
       << e2Ptr->getFirstName()
       << " " << e2Ptr->getLastName() << "\n\n";
 
  delete e1Ptr; //recapture memory
  e1Ptr = 0; //disconnect pointer from free-store space
  delete e2Ptr; //recapture memory
  e2Ptr = 0; //disconnect pointer from free-store space
 
  cout << "Number of employees after deletion is "
       << Employee::getCount() << endl;
 
  return 0;
}

خروجی برنامه فوق به صورت زير می باشد:

Number of employees before instantiation is 0
Employee constructor for Susan Baker called.
Employee constructor for Robert Jones called.
Number of employees after instantiation is 2
 
Employee 1: Susan Baker
Employee 2: Robert Jones
 
~Employee() called for Susan Baker
~Employee() called for Robert Jones
Number of employees after deletion is 0

   در برنامه بالا عضو داده خصوصی count و تابع عضو عمومی getCount به صورت ایستا (static) در کلاس Employee تعریف شدند، و توسط دستور زیر:

int Employee::count = 0;

   عضو داده خصوصی count از کلاس Employee مقداردهی اولیه شد. count تعداد اشیای ایجاد شده از کلاس Employee را می شمارد و در خود نگهداری می کند. هر بار که یک شی جدید از نوع کلاس Employee ایجاد می شود توسط ستور count++ در سازنده کلاس count ، Employee مقدارش یک واحد افزایش می یابد و هر بار که یک شی از نوع کلاس Employee نابود می شود، توسط دستور count-- در نابود کننده کلاس count ، Employee مقدارش یک واحد کاهش می یابد.

   دستورات زیر دو شی از نوع  Employee را توسط عملگر new ایجاد می کنند و اشاره گر به حافظه تخصیص یافتهبه این دو شی به ترتیب در e1Ptr و e2Ptr قرار می گیرد:

  Employee *e1Ptr = new Employee( "Susan", "Baker" );
  Employee *e2Ptr = new Employee( "Robert", "Jones" );

همچین دستورات زیر حافظه تخصیص یافته به دو شی از نوع  کلاس Employee را آزاد می سازند:

  delete e1Ptr; //recapture memory
  e1Ptr = 0; //disconnect pointer from free-store space
  delete e2Ptr; //recapture memory
  e2Ptr = 0; //disconnect pointer from free-store space

   توجه داشته باشید، هنگامی که هنوز شیئی از نوع  کلاس Employee ساخته نشده است ولی اعضای getCount و count از این کلاس موجود می باشد و می توان به مقدار count از طریق تابع عضو getCount دسترسی پیدا کرد در برنامه فوق دستور زیر این کار را انجام می دهد:

Employee::getCount()

 

 

 

 

   معرفی کامپيوتروبرنامه نويسی

   ساختارهای کنترلی

   توابع

   آرايه ها

   اشاره گر ها و رشته ها

   کلاسها

   گرانبار کردن عملگر ها

 
 
 
   
 
 
 

حق کپی رایت محفوظ می باشد