کنترل دسترسی به اعضای کلاس پايه

کلاس مشتق شده کليه اعضای کلاس پايه را به ارث می برند اما اجازه دسترسی مستقيم به اعضای خصوصی کلاس پايه را ندارند و تنها از طريق توابع عمومی و سازنده به آنها دسترسی دارند.

نحوه دسترسی به اعضای عمومی کلاس پايه در کلاس مشتق شده توسط يکی مجوزهای دسترسی زير که قبل از نام کلاس پايه ذکر می شود مشخص می شود:

• public
• private
• protected

توارث عمومی

با ذکر کلمه public قبل از نام کلاس پايه اعضای عمومی کلاس پايه به عنوان اعضای عمومی کلاس مشتق شده تلقی می شوند و در اختيار کاربر کلاس مشتق شده قرار می گيرد.

مثال. در مثال قبل تابع value از کلاس Base به اعضای عمومی Derived اضافه می شود بنابراين در برنامه قابل دسترسی است.

توارث خصوصی

با حذف کلمه public يا صريحا با ذکر کلمه private يک کلاس پايه می تواند به صورت خصوصی ارث گرفته شود. در توارث خصوصی کلاس مشتق شده کليه اعضای کلاس پايه را دارا خواهد بود اما به صورت مخفی و اعضای عمومی کلاس پايه اعضای خصوصی کلاس مشتق شده خواهند شد. بنابراين يک شی به عنوان يک نمونه از کلاس نمی تواند به اعضای کلاس پايه دسترسی پيدا کند.

نکته. توارث خصوصی برای پنهان کردن لايه زيرين پياده سازی کلاس پايه مفيد است.
نکته. در توارث خصوصی کليه اعضای عمومی کلاس پايه خصوصی می شوند. اگر می خواهيد عضوی قابل رويت شود کافی است نام آن را (بدون آرگومان و مقدار برگشتی) در بخش public کلاس مشتق شده ذکر کنيد.

مثال. چون وراثت خصوصی است تابع speak از کلاس پايه Pet در برنامه قابل دسترس نيست درحاليکه توابع eat و sleep از کلاس پايه به صورت قابل دسترس درآمده اند.

class Pet {
public:
   char eat() { return 'a'; }
   int speak() { return 2; }
   float sleep() { return 3.0; }
   float sleep(int) { return 4.0; }
};
class Goldfish : Pet {      // Private inheritance
public:
   Pet::eat;      // Name publicizes member
   Pet::sleep;      // Both overloaded members exposed
};
int main() {
   Goldfish bob;
   bob.eat();
   bob.sleep();
   bob.sleep(1);
//! bob.speak();      // Error: private member function
}

توارث محافظت شده

اعضای خصوصی هميشه خصوصی هستند اما گاهی می خواهيد اعضائی را از خارج مخفی کنيد ولی در کلاس مشتق شده قابل رويت باشند. کلمه protected می گويد که اعضای محافظت شده برای هر کسی که از اين کلاس ارث می برد قابل دسترس است و برای بقيه خصوصی است.

مثال. توابع set و read از کلاس Base درمثال قبل در کلاس مشتق شده Derived قابل رويت هستند ولی در برنامه مخفی هستند.

با قرار دادن کلمه protected قبل از نام کلاس مشتق شده اعضای محافظت شده و عمومی کلاس پايه به اعضای محافظت شده کلاس مشتق شده اضافه خواهند شد. بنابراين برای وارثين کلاس مشتق شده در دسترس است و برای بقيه پنهان باقی می ماند

نکته. در کليه حالات اعضای خصوصی کلاس پايه در وراثت شرکت نمی کنند و خصوصی باقی می مانند.
نکته. معمولا توارث عمومی است تا رابط کلاس پايه همچنان رابط کلاس مشتق شده باشد.
نکته. توارث محافظت شده خيلی استفاده نمی شود و فقط برای تکميل زبان برنامه نويسی است.
نکته. مناسب ترين روش اين است که اعضای داده ای کلاس را صورت خصوصی تعريف کنيد تا امکان تغيير پياده سازی زيرين حفظ شود. و به وارثين کلاس مجوز دسترسی کنترل شده ای به توابع عضو محافظت شده بدهيد.

تعريف کلاس مشتق شده

فرم کلی تعريف يک کلاس مشتق شده به صورت زير است:

class derived : access base
{
   //members of new class;
}

derived نام کلاس جديد است که از کلاس پايه base مشتق شده است. قسمت access اختياری است ولی می تواند public، private يا protected باشد و برای تعيين مجوز دسترسی اعضای کلاس پايه در کلاس جديد بکار می رود. اگر مجوز دسترسی ذکر نشود به اين معنی است که کليه اعضای عمومی کلاس پايه در کلاس مشتق شده به صورت خصوصی خواهند بود.

مثال. کلاس جديد Derived از کلاس Base مشتق شده است. در برنامه اصلی تابع change از کلاس Derived فراخوانی شده که خود دو تابع set و read از کلاس Base را صدا می زند.

#include <iostream.h>
class Base {
   int i;
protected:
   int read() { return i; }
   void set(int ii) { i = ii; }
public:
   Base() { i=0; }
   int value(int m) { return m*i; }
};
class Derived : public Base {
   int j;
public:
   Derived() { j=0; }
   void change(int x) { set(x); cout << read(); }
};
int main() {
   Derived d;
   d.change(10);
   return 0;
}

کلاس های پايه و مشتق شده

چند کلاس ممکن است خصوصيات و رفتارهای مشترکی داشته باشند اما هريک شامل خواص و توابع ديگری هم باشد. وراثت اجازه می دهد يک کلاس عمومی تعريف شود که اشيا درخصوصيات آن مشترک هستند و اين کلاس می تواند توسط ساير کلاس ها ارث برده شود و خواص جديدی به آن اضافه شود بدون اينکه تاثيری روی کلاس عمومی داشته باشد.

توارث شباهت بين دو کلاس را با استفاده از مفاهيم کلاس پايه (base) و کلاس مشتق شده (derived) بيان می کند. کلاسی که از آن ارث بری می شود کلاس پايه يا مبنا و کلاس وارث که خصوصيات کلاس پايه را به ارث می برد را کلاس مشتق شده می نامند. کلاس پايه شامل کليه خواص و رفتارهائی است که بين کلاس های مشتق شده مشترک است.

مثال. کلاس پايه shape را درنظر بگيريد که دارای خاصيت های اندازه، رنگ و موقعيت است. هر شکل می تواند رسم شود، پاک شود، حرکت کند و رنگ شود. هر کدام از اشکال دارای خواص و رفتارهای اضافه تری هستند. برای يک شکل معين بعضی رفتارها ممکن است متفاوت باشد مثلا محاسبه مساحت.

نکته. يک کلاس متشق شده به نوبه خود می تواند کلاس پايه برای ساير کلاس ها باشد.
نکته. اگر کلاس پايه تغيير کند کلاس مشتق شده نيز تحت تاثير اين تغييرات قرار می گيرد.

آرايه ای از اشيا

می توان به همان طريقی که آرايه ای از ساير انواع داده ايجاد می شود آرايه ای از اشيا تعريف کرد. اگر کلاس دارای تابع سازنده همراه با پارامتر باشد آرايه ای از اشيا را می توان مقداردهی کرد.

مثال. myarray آرايه ای از اشيا است که در برنامه اصلی با چهار عدد مقداردهی شده و نمايش داده می شود.

#include <iostream.h>
class display {
   int number;
public:
   display(int n) {this->number=n;}
   int show() { cout << this->number << endl; }
};
int main() {
   display myarray[4] = {1,2,3,4,};
   for (int i = 0; i < 4 ;i++ )
      myarray[i].show();
   return 0;
}

هر بار که تابع عضوی فراخوانی می شود به طور خودکار اشاره گری به نام this را به شیئی که آن را فراخوانی کرده است ارسال می کند. اشاره گر this يک پارامتر ضمنی برای تمام توابع عضو است و داخل تابع برای رجوع به شیء فراخواننده می تواند مورد استفاده قرار گيرد.

سازنده ها

معمولا بعضی از اعضای کلاس قبل از استفاده نیاز به مقداردهی دارند. اين عمل توسط سازنده (constractor) انجام می گیرد که به شیء اين امکان را می دهد که هنگام ايجاد مقداردهی شود. سازنده تابعی است هم اسم کلاس که وقتی یک نمونه از کلاس گرفته می شود اتوماتیک فراخوانی می شود.

تابع سازنده می تواند دارای پارامتر باشد بنابراين زمان ايجاد شیء می توان به متغيرهای عضو مقادير اوليه داد. برای ارسال آرگومان به تابع سازنده بايد هنگام تعريف شیء مقدار آرگومان بعد از نام شیء درون پرانتز قرار گيرد.

یک کلاس می تواند دارای چند سازنده با پارامترهای مختلف باشد. بهتر است همیشه حداقل یک سازنده حتی اگر خالی باشد ساخته شود.

برای تابع سازنده مقدار برگشتی ذکر نمی شود (حتی viod).

تابع مخرب کلاس (destructor) کم و بیش عکس سازنده عمل می کند. یک مخرب وقتی فراخوانی می شود که یک شی از بین می رود. یک مخرب مشابه سازنده ساخته می شود فقط قبل از اسم آن علامت مد (~)قرار می گیرد. تابع مخرب اتوماتیک وقتی متغیر شیء از حوزه دسترسی خارج می شود (برای متغیرهای سراسری وقتی از تابع اصلی خارج می شود و برای متغیر محلی هنگام خروج از بلاک تابع) فراخوانی می شود.

مشابه سازنده ها تابع مخرب نيز نوع برگشتی ندارد.

مثال. توابع myclass در کلاس زير سازنده هستند. تابع ~myclass يک مخرب است که در انتهای تابع اصلی فراخوانی می شود و فايل متن را می بندد.

#include <fstream.h>
#include <iostream.h>
#include <string.h>
class myclass {
private:
   char msg[20];
   int loopcounter;
   fstream myfile;
public:
   void greeting();
   myclass();      // Constructor
   myclass(char greeting[20]); // Constructor
   ~myclass()    // Destructor
};
myclass::myclass(){
   myfile.open("input.txt",ios::in);
   myfile.getline(msg,20);
}
myclass::myclass(char greeting[20]) {
   strcpy(msg,greeting);
}
myclass::~myclass(){
   myfile.close();
}
void myclass::greeting(){
   cout << msg << "n";
}
int main (){
   myclass myobject;
   myobject.greeting();
   return 0;
}

در برنامه فوق هنگام ايجاد شیء myobject تابع سازنده فراخوانی شده خطی را از فايل متن خوانده و به متغير عضو تابع اختصاص می دهد. اگر در برنامه اصلی شیء به صورت زير ايجاد شود سازنده دوم فراخوانی می شود و مقدار آرگومان را به متغير msg اختصاص می دهد.

myclass myobject("Howdy from Texas!");

اغلب کلاس ها را در فایل های هدر تعریف می کنند. ترکیب کلاس و فایل هدر سطح بالاتری از قابلیت استفاده مجدد کد را فراهم می کند و می توان آن را در هر فایلی که به کلاس نیاز دارید ضمیمه کنید.

کلاس

همانطور که قبلا دیدید ساختمان ها نوع داده جدیدی را ایجاد می کنند. کلاس ها به طور مشابه روش قدرتمند تری برای ایجاد يک نوع داده جدید هستند. وقتی یک کلاس تعریف می شود در اصل نوع داده جدیدی ساخته می شود که فيلدها و توابع خود را دارد. کلاس به عنوان قالبی برای تولید شی بکار می رود بنابراين از خود کلاس در برنامه استفاده نمی شود بلکه یک نمونه از آن که شیء ناميده می شود اعلان می شود. فرآیند تولید یک نمونه از کلاس یا ایجاد یک شی از کلاس به این معنا است که یک متغیر از نوع کلاس اعلان شود.

کلاس مشابه ساختمان تعریف می شود فقط کافی است ابتدای آن کلمه کلیدی class ذکر شود. دقت کنید در انتهای بلاک علامت سمیکولن را فراموش نکنید.

class classname
{
// members
};

وقتی یک کلاس ایجاد می کنید مانند هر متغیر دیگر می توانید یک نمونه از آن را بگیرید:

classname object_variable;

مثال.

class myclass {
   int number;
   void greeting();
};

حوزه اعضای کلاس

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

حوزه های دسترسی (access modifiers) توسط کلمات زیر مشخص می شوند:

• private. اعضايی که به صورت خصوصی مشخص می شوند تنها درون کلاس توسط توابع عضو و توابع دوست قابل دسترسی هستند و نمی توانند خارج از کلاس دسترسی شود.
• public. اعضای عمومی از هر تابعی حتی خارج از کلاس قابل دستیابی هستند.
• protected. اعضای محافظت شده نمی توانند بیرون از کلاس دسترسی شوند اما توسط توابع عضو خودش و توابع دوست و از کلاسی که از آن مشتق شده قابل دسترسی هستند.

نکته. در یک ساختمان همه اعضا عمومی هستند مگر اینکه آنرا به عنوان خصوصی یا محافظت شده تعریف کنید.

مثال. متغير number عضو خصوصی و تابع greeting خضو عمومی کلاس زير هستند.

class myclass {
   int number;
public:    void greeting();
};

نکته. در یک ساختمان همه اعضا عمومی هستند مگر اینکه آنرا به عنوان خصوصی یا محافظت شده تعریف کنید.

مثال. در ساختمان A توابع عضو به صورت عمومی تعريف شده اند و فيلدها به صورت خصوصی هستند.

struct A {
private:
   int i, j, k;
public:
   int f() {return i + j + k;}
   void g() {i = j = k = 0;}
};

توابع عضو

توابع عضو (member functions) توابعی هستند که درون کلاس تعريف می شوند و متعلق به کلاس هستند. توابع عضو می توانند به کلیه اعضای کلاس (اعم از عمومی، خصوصی و محافظت شده) بدون هیچ محودیتی دسترسی پیدا کنند.

مثال. تابع greeting تابع عضو کلاس است که به متغير خصوصی عضو number دسترسی دارد.

class myclass {
   int number;
public:
   void greeting() {
      for(int i = 0; i<= number;i++) cout << "Hello World n";
   }
};

در مثال فوق کد تابع عضو به صورت درونی (inline) در کلاس قرار داده شده است. توابع درونی درنقطه فراخوانی به صورت خطی گسترش پيدا می کند به جای اينکه واقعا فراخوانی شود. توابع درونی درصورتی که بدنه تابع کوچک باشد روش کارآمدتری هستند. راه ديگر تعريف تابع عضو اين است که بدنه تابع بعد از بلاک کلاس قرار گيرد. سپس برای ارتباط تابع عضو با کلاس قبل از نام تابع نام کلاس بدنبال علامت (::) بايد ذکر شود. :: عملگر حوزه (scope operation) نام دارد و بيان کننده اين است که تابع متعلق به کلاس است.

مثال. کلاس فوق را به صورت زير نيز می توان نوشت.

class myclass {
   int number;
public:
   void greeting();
};
void myclass::greeting(){
   for(int i = 0; i<= number;i++)
      cout << "Hello World n";
}

توابع دوست

توابع دوست (friend function) توابعی هستند که عضو کلاس نيستند اما به اعضای خصوصی کلاس دسترسی دارند. برای ايجاد يک تابع دوست در کلاس پروتوتايپ تابع را در بخش عمومی کلاس قرار داده و قبل از آن کلمه friend استفاده کنيد.

مثال. دربرنامه زير پيغام سه بار نمايش داده می شود. تابع set يک تابع دوست است که برای مقداردهی متغير خصوصی عضو کلاس استفاده شده است.

#include <iostream>
class myclass {
   int number;
public:
   void greeting();
   friend void set(myclass, int);
};
void myclass::greeting(){
      for(int i = 0; i<= number;i++)
         cout << "Hello World n";
}
void set(myclass n, int value){
   n.number=value;
}
int main () {
   myclass myobject;
   set(myobject, 3);
   myobject.greeting();
   return 0;
}

نکته. يک تابع ممکن است دوست بيش از يک کلاس باشد.

مفاهيم شی گرائی

برنامه نویسی شیءگرائی (object oreinted programming) وسیله ای برای مدل کردن صحیح دنیای واقعی با استفاده از اشیا (objects) در برنامه و استفاده مجدد از کد است. یک شی در برنامه دقیقا همان طور تعريف می شود که در دنيای واقعی است؛ خواص معینی دارد که آن را توصیف می کند و متدهایی که می توانید برای انجام کار معینی روی شیء استفاده کنید.

هدف کلی C++ اضافه کردن شیءگرائی به زبان برنامه نویسی C است. یک شیء برای نگهداری داده استفاده می شود. داده و توابعی که روی داده کار می کنند به هم مربوط هستند بنابراين داده و توابع هردو با هم دریک بسته قرار می گیرند. شیءگرائی بيشتر روی داده تاکيد دارد تا عمليات و توابعی که روی داده کار می کنند.

مثال. ماشین یک شی است دارای خواصی مثل رنگ، تعداد درها و غیره است متدهای معینی دارد مانند سرعت گرفتن، ترمز کردن و غیره. می توان این شی را با استفاده از متدهایش استفاده کرد.

شرحی از داده ها و توابعی که می توانند روی داده کار کنند را کلاس (class) می نامند. کلاس را به عنوان الگوئی برای توليد شیء می توان تصور کرد. کلاس در واقع يک نوع داده user-defined است . اشياء نمونه هائی از کلاس ها هستند که در زمان اجرا ايجاد می شوند.

چهار مفهوم اصلی وجود دارند که اساس برنامه نویسی شیءگرائی را می سازند و توسط کلاس ها ارائه می شوند. این مفاهیم انتزاع (abstraction)، کپسوله کردن (encapsulation)، توارث (inheritance) و چندریختی (polymorphism) هستند.

انتزاع

شیء گرائی ابزاری را برای برنامه نویس فراهم می کند که اجزای فضای مسئله را توسط اشيا نمایش دهد. مسئله به بخش های تشکيل دهنده تجزيه می شود. هر مولفه يک شیء می شود که شامل داده های مرتبط و دستورالعمل های خود است. به اين ترتيب مسئله به همان صورتی که در دنيای واقعی هست توصیف می شود نه به روشی کامپیوتری که مسئله را حل می کند. یعنی می توانید با همه چيز در یک ترتیب کلی سروکار داشته باشید. پيچيدگی عمليات کاهش يافته و جزييات پياده سازی مخفی می ماند.

مثال. درباره خصوصیات کلی وسيله نقليه بدون سروکارداشتن با یک وسيله و مدل خاص می توان بحث کرد. يک نمونه شیء MyVehicle از کلاس Vehicle که خواص کلی و توابع وسايل نقليه را در بر دارد می توان ايجاد کرد. تابع Print مشخصات کلی وسيله نقليه را نمايش می دهد.

Vehicle MyVehicle;
MyVehicle.Print();

کپسوله کردن

قرار دادن داده و توابعی که روی داده کار می کنند را در یک بسته کپسوله کردن می گویند. در برنامه نویسی رویه گرا (مشابه آنچه تا کنون انجام می داديد) معلوم نیست چه تابعی روی چه متغیری کار می کند. در برنامه های پیچیده تر این روابط تیره تر می شوند. در برنامه نویسی شیءگرائی داده و توابع مربوط به آن- که اغلب متد (method) ناميده می شوند- با در يک بسته به نام کلاس قرار می گیرند بنابراین کاملا مشخص است چه تابعی روی چه داده ای کار می کند.

کپسول کردن امکان پنهان کردن اطلاعات را نيز فراهم می کند. هر عضو کلاس را می توان به صورت عمومی، خصوصی یا محافظت شده مشخص کرد. شی ايجاد شده از کلاس به داده از طريق يک سری توابع عمومی دسترسی دارد و اجازه دسترسی مستقيم به اعضای خصوصی کلاس و خراب کردن آنها داده نمی شود. به اين صورت جزئيات پياده سازی هم مخفی می ماند و به طراح اجازه می دهد پياده سازی را اساسی بدون تغيير در واسطه ها عوض کند.

وراثت

یکی ديگر از جنبه های مفید برنامه نویسی شیءگرائی قابلیت استفاده مجدد از کد است. یک کلاس می تواند اعضای عمومی را از کلاس دیگر را به ارث ببرد. توارث اجازه می دهد کلاس جديدی شامل کليه داده ها و توابع کلاس (های) پياده سازی شود. کلاس موجود را کلاس پايه (base) و کلاس جديد که اعضای کلاس پايه را به ارث می گيرد را کلاس مشتق شده (derived) می نامند.

مثال. فرض کنيد يک کلاس پايه به نام Vehicle برای وسايل نقليه داريم. وسيله نقليه می تواند ماشين، تراکتور، قايق و هواپيما را شامل شود که ممکن است هر يک از آنها احتياج به اطلاعات يا توابع اضافی داشته باشند. بنابراين می توان برای هر کدام کلاس های فرعی را تعريف کرد که خواص کلاس Vehicle را به ارث می برند علاوه براين که دارای فيلدهای جديد ديگری هم هستند.

اگر کلاس ويژگی های تنها يک کلاس را به ارث ببرد وارثت منفرد(single inheritance) و اگر از چند کلاس به ارث گرفته شود وارثت چندگانه (multiple inheritance) ناميده می شود.

ارث از کلاس پایه ممکن است به صورت عمومی، خصوصی یا محافظت شده باشد. این مشخصه های دسترسی تعیین می کنند کلاس های مشتق شده می توانند به اعضای عمومی و محافظت شده کلاس پایه دسترسی پیدا کنند یا خیر. تنها وراثت عمومی است که با مفهوم توارث تطبیق دارد. دو فرم دیگر کمتر استفاده می شوند.

چندریختی

يک تابع در سلسله مراتب کلاس ها و زير کلاس ها می تواند به طرق مختلف پياده سازی شود و شکل های متعددی بگیرد. چندریختی یک رابط مشترک را برای پیاده سازی های مختلف از يک تابع در اختيار می گذارد که برای اشیا تحت شرایط مختلف متفاوت عمل کند. به عبارت ديگر فراخوانی تابعی که متعلق به کلاس است هميشه به شکل زير خواهد بود.

object.function(parameter-list)

مثال. در مثال قبل تابع نمايش برای قايق ممکن است متفاوت از نمايش يک وسيله نقليه باشد. دو تابع می توانند هم نام باشند ولی با کدهای متفاوت بسته به کلاس شیئی که تابع را فراخوانی می کند.

Vehicle MyVehicle;
Boat YourBoat;
MyVehicle.Print();
YourBoat.Print();

در مثال قبل کامپايلر نوع تابع print را برای دو نوع فراخوانی شده بر اساس نوع شیء می تواند پيدا کند. اما گاهی پيدا کردن آن تا زمان اجرای واقعی برنامه ممکن نيست. مشکل زمانی بروز می کند که به شیء از طريق اشاره گر دسترسی می شود و چون اشاره گرها می توانند بطور پويا به انواع مختلفی از اشيا اشاره کنند کلاس شیء تا زمان اجرا مشخص نمی شود. برای حل اين موضوع توابع عضو مجازی بکار می روند. توابع مجازی عضو (Virtual member functions) اجازه پياده سازی خاص تری از تابعی که فراخوانی می شود را مطابق با نوع شیء زمان اجرا می دهند.

دسترسی تصادفی فايل

هر فايل بازی يک انديکاتور موقعيت دارد که تعيين می کند عمل خواندن/نوشتن در کدام محل فايل انجام می شود. موقعيت هميشه برمبنای تعداد بايت ها از ابتدای فايل داده می شود. اگر فايل موجودی در مد اضافه کردن باز شود انديکاتور در انتهای فايل است در بقيه مدها انديکاتور در ابتدای فايل است و برابر صفر است.

توابع خواندن/نوشتن روی فايل که در محل انديکاتور انجام می شود باعث تغيير موقعيت آن می شود. مثلا اگر فايلی باز شود و 10 بايت از آن خوانده شود انديکاتور روی موقعيت 10 فايل قرار می گيرد. عمل بعدی روی موقعيت 10 انجام می گيرد.

C++ توابعی را در اختيار می گذارد (seekp و seekg) که امکان کنترل انديکاتور و دسترسی تصادفی به فايل را می دهند. يعنی می توانيد به هر نقطه ای درون فايل مراجعه کنيد بدون اينکه مجبور باشيد فايل را از ابتدا بخوانيد يا بنويسيد.

مثال. نمايش اندازه يک فايل.

#include <fstream.h>
#include <iostream.h>
int main () {
   long start,end;
   ifstream myfile (“test.txt”, ios::in|ios::binary);
   start = myfile.tellg();
   myfile.seekg (0, ios::end);
   end = myfile.tellg();
   myfile.close();
   cout << "size of " << “test.txt”;
   cout << " is " << (end-start) << " bytes.n";
   return 0;
}

فایل های متنی

فايل های متنی مورد استفاده بسياری دارند. يک فايل متنی (text file) جريانی از کاراکترهاست که دارای کاراکتر(های) خاصی برای نشانه گذاری انتهای هر خط است. فايل های متنی را با هر اديتورمتنی می توان توليد کرد يا محتويات آن را مشاهده کرد.

مثال. ايجاد يک فايل متنی با نام test.txt.

#include <fstream.h>
int main() {
   ofstream myfile ("test.txt");
   if (myfile.is_open()){
      myfile << "This outputting a line.n";
      myfile << "Guess what, this is another line.n";
      myfile.close();
      }
   return 0;
}

مثال. خواندن فايل متنی test.txt و نمايش آن روی صفحه.

#include <fstream.h>
#include <iostream.h>
int main (){
   char buffer[256];
   ifstream myfile ("test.txt");
   while (! myfile.eof() ) {
      myfile.getline (buffer,100);
      cout << buffer << endl;
   }
   return 0;
}

در فايل های متنی می توانيم اعداد را هم ذخيره کنيم. اعداد به صورت متن ذخيره می شوند. برای مثال عدد 236 به صورت کاراکتر'2' ، کاراکتر '3' و کاراکتر '6' ذخيره می شود. اين تبديل زمان اضافه می برد اما فايل حاصل قابل خواندن است.

فایل های باینری هم نوعی فايل مسطح هستند که در حالت دودوئی ذخیره می شوند. در حالت باینری هر فایل یک فرمت بایت به بایت دارد که باعث می شود فايل در ادیتور اسکی خوانا نباشد و کاراکترهای عجیبی نشان داده شود.

تابع write برای نوشتن داده در فايل باينری استفاده می شود. تابع دارای دو پارامتر است. اولی آدرس جائی که داده بايد نوشته شود و دومی تعداد بايت های داده است که نوشته می شود. تابع read برای خواندن از فايل باينری است.

اشيای ifstream و ofstream

در ++C برای کار کردن با فايل از کلاس های ifstream، ofstream و fstream استفاده می شود که در کتابخانه fstream.h تعريف شده اند. اشيای ifstream و ofstream مشابه cin و cout هستند. این اشیا می تواند در برنامه برای نمایش فایل های مسطح و دستکاری آنها بکار رود.

کلاس ifstream برای فايل های ورودی استفاده می شود. اگر می خواهيد فايلی را به منظور خواندن از آن باز کنيد یک نمونه از این کلاس را مانند زرر ایجاد کنید.

ifstream fin();

برای باز کردن فايلی به منظور نوشتن در آن بايد يک شیء ofstream ايجاد کرد.

ofstream fout();

کلاس ifstream شامل گروهی از توابع مورد استفاده روی فايل های ورودی است و کلاس ofstream توابع خروجی در فایل را دارد. عملکرد هردو در fsream ترکیب می شود. متدهای اصلی در جدول زیر نشان داده شده اند.

نام فايل

هر فايل روی ديسک دارای نامی است که هنگام کار کردن با آن مورد استفاده قرار می گيرد. نام فايل به صورت يک رشته کاراکتری است. قواعد نامگذاری فايل بسته به سيستم عامل دارد. در C++ نام فايل می تواند شامل اطلاعات مسير هم باشد. منظور از مسير دراويو و فولدری است که فايل در آنجا قرار دارد. اگر نام فايل بدون مسير مشخص شود محل فايل در موقعيت جاری درنظر گرفته می شود.

مثال. فايل test.txt از مسير جاری را به منظور خواندن باز می کند.

ifstream myfile("test.txt");

مثال. اگر فايل در فهرست دیگری باشد باید مسیر فایل کامل ذکر شود.

ifstream myfile ("c:\myfolder\test.txt");

در رشته ها کاراکتر بیان کننده کاراکتر escape است و دارای معنی خاص است به همين دليل برای جداکردن فولدر ها به جای باید از \ استفاده شود. اگر نام فايل از ورودی دريافت می شود يک علامت کافی است.

بازکردن فايل

فرآيند ارتباط بين جريان با فايل را باز کردن فايل می نامند. هنگامی که فايلی باز می شود برای خواندن و نوشتن آماده است. متد open يک فايل متن يا باينری را باز می کند. بايد یک متغیر از نوع ofstream/ifstream بسته به احتیاج تعریف شود.

ifstream infile;
ofstream outfile;
fstream myfile;

سپس فایل را با استفاده از open باز شود. اسم/مسير فایل و مد مورد نظر را تعيين کنید. مد مشخص می کند فايل ورودی، خروجی یا هردو است.فرم کلی متد به صورت زير است:

myfile.open(filename, mode)

filename رشته ای است که نام خارجی فايل، يعنی نامی که توسط ديسک شناخته شده است، را مشخص می کند. mode مقداری است که توسط ios تعريف می شود و مشخص می کند فايل با چه مدی (متن/باينری) و به چه منظوری (خواندن/نوشتن/ايجاد) باز شود. با استفاده از عملگر | می توان چند مقدار را با هم تلفيق کرد. پيش فرض فايل در مد متن باز می شود.

مثال. فايل متن myfile.txt را به منظور خواندن باز می کند.

infile.open("myfile.txt",ios::in);

مثال. فايل باينری myfile.txt را به منظور خواندن باز می کند.

infile.open("myfile.txt",ios::in|ios::binary);

مثال. فايل متن myfile.txt را به منظور نوشتن باز می کند.

outfile.open("myfile.txt",ios::out);

مثال. فايل متن myfile.txt را به منظور خواندن باز می کند.

myfile.open("myfile.txt",ios::in|ios::out);

مثال. فايل متن myfile.txt را به منظور اضافه کردن به انتهای آن خواندن باز می کند.

outfile.open("myfile.txt",ios::app);

مثال. فايل متن myfile.txt را پاک می کند و برای نوشتن باز می کند.

outfile.open("myfile.txt",ios::trunc);

تحت شرايطی ممکن است باز کردن فايل با عدم موفقيت روبرو شود نظير: استفاده از نام فايل غير مجاز، موجود نبودن فايل روی ديسک يا مسير ذکر شده، نداشتن اجازه دسترسی و .... اگر بازکردن فايل موفق نباشد تابع مقدار NULL را برمی گرداند که توسط متدهای is_open يا fail بررسی می شود و برنامه بايد پيغام خطای مناسب را با cerr نمايش دهد.

مثال.

if (!outfile.is_open()) {
   cerr << "Could not create file." << endl;
   exit(1);
   }

خواندن و نوشتن فايل

بعد از بازکردن فايل برنامه می تواند داده را از فايل بخواند يا مقداری را در فايل بنويسد. برای فايل های متن عملگرهای << و >> مشابه cin و cout‌ عمل می کنند و می توانند برای خواندن و نوشتن استفاده شوند.

تابع getline تابع خوبی است که اجازه می دهد يک خط از فايل متن (که به کاراکتر انتهای خط ختم شده است) را بخوانيد و در يک متغير رشته ای ذخيره کنيد. getline از فايل متن کاراکترها را تا رسيدن به کاراکتر انتهای خط می خواند. اما خود کاراکتر انتهای خط را در رشته ذخيره نمی کند.

در فايل های باينری متدهای read و write برای خواندن و نوشتن بکار می روند.

مثال. کپی کردن يک فايل در ديگری.

#include <string.h>
#include <fstream.h>
int main() {
   ifstream in("Scopy.cpp"); // Open for reading
   ofstream out("Scopy2.cpp"); // Open for writing
   string s;
   while(getline(in, s)) // Discards newline char
      out << s << "n"; // ... must add it back
}

تشخيص انتهای فايل

گاهی دقيقا می دانيد طول فايل چند بايت است بنابراين نيازی به تشخيص انتهای فايل نيست. ولی در اکثر مواقع از طول فايل اطلاعاتی نداريد. متد eof() زمانی که به انتهای فايل برسيد مقدار true را بر می گرداند.

بستن فايل

با ايجاد پيوند بين يک جريان و فايل ديسک اتوماتيک يک بافر ايجاد و به جريان مرتبط می شود. بافر بلاکی از حافظه است که به عنوان واسطه ای بين جريان و سخت افزار ديسک عمل می کند و برای ذخيره موقت داده هائی که از فايل خوانده يا نوشته می شوند بکار می رود. چون ديسک درايو به صورت بلاکی کار می کند، داده ابتدا در بافر ذخيره می شود تا بافر پر شود سپس کل بافر به صورت يک بلاک روی ديسک ذخيره می شود. همين فرآيند زمان خواندن داده از ديسک هم اتفاق می افتد.

در طی اجرای برنامه داده هائی که برنامه روی فايل می نويسد ممکن است در بافر باقی بماند. اگر برنامه بدون بستن فايل خاتمه پيدا کند داده از بافر به درون فايل منتقل نمی شود و اطلاعات از دست می رود. بنابراين بعد از اينکه کارتان با فايل تمام شد بايد آنرا ببنديد. درصورت نياز مجددا فايل را باز کنيد.

متد close() فايل را می بندد. اين متد کل جريان های بافر شده را به فايل منتقل می کند.

myfile.close();

اگر برنامه دچار شکست شود داده ممکن است داده موجود در بافر از دست برود. برای جلوگيری از اين کار در صورت نياز با استفاده از متد flush() می توانيد محتويات بافر را بدون بستن فايل به فايل منتقل کنيد.

مثال. يک فايل ممکن است در برنامه به منظور خواندن و نوشتن چندبار باز و بسته شود.

#include <fstream.h>
#include <iostream.h>
int main () {
   char buffer[256];
   fstream myfile; // open it for output then write to it
   myfile.open("test2.txt",ios::out | ios::trunc);
   if (myfile.is_open()) {
      myfile << "This outputting a line.n";
      myfile.close();
      }
   myfile.open("test.txt",ios::in); // open it for input and read in
   myfile.getline(buffer,100);
   cout << "The file contains " << buffer << "n";
   myfile.close();
   myfile.open("test.txt",ios::app); //open for appending and append
   myfile << " Hey this is another line n";
   myfile.close();
   myfile.open("test.txt",ios::in); // open it for input and read in
   myfile.getline(buffer,200);
   cout << "The file contains " << buffer << "n";
   myfile.close();
   return 0;
}

نکته. مديريت بافر با سيستم عامل است.
نکته. قبل از خواندن يا نوشتن فايل آن را باز کنيد.
نکته. هميشه بعد از بازکردن فايل چک کنيد فايل بطور موفق باز شده است يا خير.
نکته. موقعيت خود را درون فايل چک کنيد تا از انتهای فايل عبور نکنيد.
نکته. در انتها حتما فايل را ببنديد.