تبلیغات شما تبلیغات شما

آمار سایت

    آمار مطالب
    کل مطالب : 4090
    آمار کاربران
    افراد آنلاین : 6

    کاربران آنلاین

    آمار بازدید
    بازدید امروز : 1,373
    باردید دیروز : 2,578
    گوگل امروز : 5
    گوگل دیروز : 19
    بازدید هفته : 16,996
    بازدید ماه : 57,058
    بازدید سال : 174,079
    بازدید کلی : 6,621,107

آخرین فروش های موفق

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

راهنمای Online

مستندات

سرویس پشتیبانی شرکت بورلند

سایت شرکت بورلند

راهمنای Online

راهنمای Online حاوی اطلاعات جزئی درباره رابط کاربر ˛ زمان پیاده سازی ˛ وظایف برنامه نویسی و VCL (Visual Component library) می باشد.مستندات

این مستندات یک شروع سریع و مقدماتی بر دلفی است جهت سفارش مستندات به سایت ----------- مراجعه کنید.سرویس پشتیبانی شرکت بورلند

در سایت Http://www.borland.com/devsupport/delphi میتوانید اطلاعات مختلفی راجع به دلفی و نیز گروههای کاری زیادی را پیدا کنید

دلفی چیست ؟

دلفی یک محیط ویژوال و شئ گرا برای گسترش سریع برنامه ها میباشد. با استفاده از دلفی شما میتوانید برنامه های کاربردی مفیدی برای ویندوز با کمترین کد نویسی و سریع بنویسد. دلفی تمام ابزار های لازم برای گسترش ˛تست و اشکال زدایی برنامه ها را برای شما فراهم می کند.

نگارش های دلفی

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

نگارش های دلفی عبارتند از :

نگارش Professional Studio : که برای تولید کنندگان حرفه ای در نظر گرفته شده است و علاوه بر ویژگیهای پایه خاصیت پشتیبانی از برنامه سازی بانک های اطلاعاتی (از جمله ADO) و سرور وب و ابزار های خارجی همچون ModelMaker و Intra Web نیز در این نگارش گنجانده شده است.

نگارش Enterprise Studio : برای تولید کنندگانی که برنامه کاربردی بزرگ تولید می کنند در نظر گرفته شده است. فناوری های پیشرفته خدمات وب و XML و معماری سه لایه ای و ابزار های بیشمار دیگری در این نگارش گنجانده شده است.

نگارش Architect Studio : پشتیبانی از Bold نیز به تمامی امکانات و ویژگیهای نگارش Enterprise افزوده شده است. Bold محیطی برای آماده سازی برنامه های کاربردی است که در زمان اجرا توسط یک UML هدایت شده و قادر به ارتباط شی های خود به یک بانک اطلاعاتی و همچنین رابط کاربر است.

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

کتاب معادلات دیفرانسیل نیکوکار یکی از کاملترین کتابها برای یادگیری این درس می باشد این کتاب در 527 صفحه تنظیم شده است.

نام کتاب : معادلات دیفرانسیل 
نام نویسنده : دکتر مسعود نیکوکار
 زبان : پارسی 
تعداد صفحه : 527 
قالب : PDF 
حجم : 33.6 MB

سازنده ها و مخرب ها در وراثت

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

مثال. در برنامه زير کلاس Derived2 از کلاس Derived1 که خود از Base1 ارث بری دارد ارث می برد.

#include <iostream.h>
class Base1 {
   int x;
public:
   Base1 () {cout << "Base1 constructorn";}
   ~Base1() {cout << "Base1 destructorn";}
};
class Derived1 : public Base1 {
   int y;
public:
   Derived1() { cout << "Derived1 constructorn";}
   ~Derived1() { cout << "Derived1 destructorn";}
};
class Derived2 : public Derived1 {
   int z;
public:
   Derived2() { cout << "Derived2 constructorn";}
   ~Derived2() { cout << "Derived2 destructorn";}
};
int main() {
   Derived2 d2;
   return 0;
}

خروجی برنامه به صورت زير است:

Base1 constructor
Derived1 constructor
Derived2 constructor
Derived2 destructor
Derived1 destructor
Base1 destructor


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


ارسال پارامتر به سازنده کلاس پايه

زمانی که تنها سازنده کلاس مشتق شده دارای آرگومان است می توان به سادگی و به صورت متعارف آرگومان را به سازنده ارسال نمود. اما برای ارسال آرگومان به سازنده کلاس پايه دچار مشکل می شويد چون سازنده کلاس مشتق شده به داده خصوصی کلاس پايه دسترسی ندارد و نمی تواند آنها را مقداردهی کند. برای اين کار C++ گرامری را در اختيار می گذارد که ليست مقداردهی سازنده (constructor initializer list) نام دارد. ليست مقداردهی سازنده امکان فراخوانی صريح سازنده ها از اشيای عضو را می دهد. فرم کلی آن برای سازنده کلاس مشتق شده به صورت زير است:

Derived(arg_list) : Base1(arg_list), Base2(arg_list), ...
{ //body of derived constructor}

نام کلاس های پايه توسط کاما از هم جدا می شوند. Base1 و Base2 و ... نام کلاس های پايه هستند که توسط کلاس مشتق شده Derived به ارث برده می شوند. سازنده ها همگی قبل از اينکه وارد بدنه سازنده کلاس مشتق شده شويد فراخوانی می شوند.


مثال. کلاس Circle از کلاس Point مشتق شده است. در سازنده کلاس Circle سازنده Coint فراخوانی می شود.

#include <iostream.h>
class Point {
   int x,y;
public:
   Point(int atx,int aty ) {x = atx; y = aty;}
   ~Point(){ cout << "Point Destructor calledn";}
   virtual void Draw() { cout << "Draw point at " << x << " " << y << endl;}
};
class Circle : public Point {
   int radius;
public:
   Circle(int atx, int aty, int theRadius) ;
   ~Circle() ;
   virtual void Draw() ;
};
Circle::Circle(int atx,int aty,int theRadius) : Point(atx,aty) {
   radius = theRadius;
}
inline Circle::~Circle() {
   cout << "Circle Destructor called" << endl;
}
void Circle::Draw( void ) {
   Point::Draw();
   cout << "circle::Draw point " << " Radius " << radius << endl;
}
int main() {
   Circle ACircle(10,10,5) ;
   ACircle.Draw();
   return 0;
}


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

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

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

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

• 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;
}


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

تبلیغات شما تبلیغات شما

کدهای اختصاصی