نوشتن کلاس با سازنده و مخرب و بارگذاری عملگرها

[hosienmax100]

بچه ها کمکم کنید برا یبار دوم خواهشآ - نوشتن کلاس با سازنده و مخرب و بارگذاری عملگرها

سلام

ببخشید بچه ها من هر وقت مشکلی دارم میام اینجا آخه برنامه نویسی اصلا بلد نیستم

من تا فردا فرصت دارم اینو تحویل بدم خیلی حیاتیه

دفعه قبل مدیر انجمن لطف کردن و پاسخ سوال منو که خیلی هم سخت بود برام نوشتن _تشکر

حالا بچه ها اگه میتونید کمکم کنید تا اینو تا فردا بدم استاد

اینو ازم خواسته :

کلاس به نام poly nomial (چند جمله ای ) طراحی کنید نمایش داخل یک چند جمله ای آرایه ای از جملات آن چند جمله ای هر شامل ضریب و توان است.جمله 4*2 دارای ضریب 2و توان 4 میباشد

کلاس کاملی طراحی کنید که حاوی توابع سازنده و نابود کننده و نیز توابع خواندن در نوشتن (set) مناسب باشد

عملگر ها زیر را برابر این کلاس بارگذاری کنید:

*عملگر های +_-_*= برای جمع تفریقو ضرب و جایگزینی دو جمله ای

*عملگرهای (*=) و(-=) , (+=)

تا فردا فرصت دارم اگه تونستید یه لینکی چیزی در این مورد برام بزارید ثواب داره

مرسی

 

[sahama]

شرمنده فرصت نوشتن ندارم ولی می تونی کمک های خوبی رو تو کتاب ساختمان داده های الیس هورویتز پیدا کنی

 

[hosienmax100]

ممنون از شما دوست عزیز

 

[saalek110]

کلاس در سی پلاس

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

 

[hosienmax100]

ممنونم اما این سایت که فیلتره نمیزاره ببینم

نمیشه خودت از اونجا جواب رو برام بیاری اینجا استاد عزیز خواهش میکنم

دوست دارم

 

[saalek110]

باشه دوست عزیز.

پستهای بعدی از تاپیک کلاس در سی پلاس
http://forum.persiantools.com/t35887.html
به علت فیلتر بودن آن فروم نقل می شود.

نویسنده تعدادی از پستها خودم بودم. نویسنده هر پست را در ابتدای پست ذکر می کنم.

 

[saalek110]

saalek:

بحث كلاس:
آدرس تاپيك اصلي:

آموزش C++ سي پلاس پلاس از پايه
​

.
.
.

 

[saalek110]

saalek:
من از ابتدا كه تاپيك اصلي را باز كردم ، هدفم بحث كلاس بود، به همين خاطر عنوان تاپيك را سي ++ گذاشتم نه سي.

در فاز يك ، هدف اين تاپيك اينه كه بتوانيم كلاس هاي ساده بسازيم و اگر سورسي حاوي كلاس بود ، درك كنيم كه چطور برنامه كار مي كند.

اما به نظر من كلاس يك تعريف ساده است و من بيشتر توجه خود را روي ريزه كاريهاي تاپيكهاي ديگر مي گذارم. مثل ارتباط با فايل ، مديريت حافظه، و جنبه هاي بيتي سي.
.
در مورد كلاس با كتاب sams شروع مي كنيم چون ساده گفته ولي ممكنه از يك كتاب ديگه از اول شروع كنيم بعدا. يعني عقب گرد در تاپيك ممكنه اتفاق بيافته. در تاپيك اصلي هم اين قضيه اتفاق افتاد كه بعدا بايد مرتب بشه و رديف بشه پستها..

 

[saalek110]

mohammad_110 :

اول یه تاریخچه ای از روشهای برنامه نویسی بگیم بد نیست : (از کتاب آموزش Turbo C++ ترجمه : کیوان فلاح مشفقی )

قدیمیترین الگوهای برنامه نویسی را به بهترین وجه ممکن می توان توسط صفت هرج و مرج توصیف کرد .

در این مدل تمام فکر و ذکر طراحان تنها به حل کردن مشکل مورد نظر معطوف است و توجه اندکی به چگونگی رسیدن به این راه حل دارند (و یا اینکه کلا به این موضوع توجهی ندارند). زبانهایی که در طبقه هرج و مرج می گنجند عبارتند از انواع اولیه Basic ( که حتی فاقد ساختار برنامه فرعی بودند).

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

در مورد برنامه هایی که ابعاد آنها از این حد بیشتر می شد تعداد مسیرهای این نوع برنامه ها ( که بدون شک بسیار زیاد خواهند بود ) عمل اشکال زداییو بررسی برنامه را به یک کابوس شبانه تبدیل خواهند کرد ( این همان مشکل کلاسیک شیوه کد اسپاگتی Spaghetti code است ).



اولين پيشرفت نسبت به شيوه هرج و مرج الگوي برنامه نويسي پروسه اي Procedural بود .

زبانهايي از قبيل فورترن و کوبول در اين دسته جاي مي گيرند.

در اين الگو برنامه نويس سعي مي کند مشکل خود را به چندين قسمت ( يا به عبارت منفرد رفتار کند. در اين حالت پيچيدگي هر تابع به جاي خود باقي مي ماند .

در واقع در اين حالت بين برنامه اصلي و داده ها يک ديوار بلند وجود دارد . در اين روش کليه توجه برنامه نويس به ايزوله کردن برنامه معطوف است و وي توجهي به داده ها ندارد.



تغيير بعدي در اين زمينه الگوي برنامه نويسي ساخت يافته Structured است که در آن تجريد برنامه به ماورا توابع نيز گسترش مي يابد . ( توجه کنيد که اينجا استراکت به دو معني اومده يکيش رو که مي دونيد يکيش هم منظور ساختار برنامه است )

در اين حالت به جاي آنکه بين توابع هرج و مرج برقرار باشد (چنانچه در روش پروسه اي چنين است ) ، برنامه نويس ساخت يافته قوانيني را ارائه مي کند که برنامه نويس را قادر مي سازد هر سازه( Struct ) ، نظير : بلوکهاي for ، while ، if را بعنوان يک زير تابع يا تابع فرعي ( Subfunction) کوچک در نظر بگيرد.

خود اين توابع فرعي را مي توان متعاقبا ايزوله کرد. به عنوان مثال در اين حالت استفاده کنندگان مي توانند يک حلقه for را به عنوان يک قسمت مستقل در نظر بگيرند ، زيرا آنها مي دانند که کليه مسيرهاي ورودي و خروجي به حلقه مشخص هستند و هيچگونه مسيري به اواسط حلقه وجود ندارد ( يعني نمي توان به يکباره به وسط حلقه دسترسي يافت و چند عمل را انجام داد و سپس از آن بيرون رفت ). به منظور پشتيباني از يک الگوي ساخت يافته ( Structured ) ، يک زبان بايد محتوي مجموعه اي کامل از سازه هاي کنترلي ( Control Structures ) باشد. يک نمونه مناسب از اينگونه زبانها پاسکال است.

در الگوي برنامه نويسي ساخت يافته ديگر داده ها ناديده گرفته نشده اند . در اين الگو قوانيني در مورد ارسال داده ها بين توابع وجود دارد . توابع ملزم هستند تنها به آن داده هايي دسترسي داشته باشند که آنها را به عنوان آرگومانهاي ( arguments ) ورودي قبول نموده اند و برقراري ارتباط از طريق متغير هاي عمومي ( global variable ) به هيچوجه توصيه نمي گردد.

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

اکثر زبانهاي برنامه نويسي ساخت يافته ( Structured ) برنامه نويسان خود را تشويق مي کنند که انواع داده اي (Data Type ) جديدي را تعريف نمايند که بتواند توصيفي دقيفتر از شي ( Object ) حقيقي ايجاد کند . در C انواع داده اي ساده را مي توان توسط عبارات enum يا typedef تعريف کرد .

انواع داده اي پيچيده اي بدون شک نياز به تعريف يک سازه ( Structre ) بخصوص دارند. تعاريف سازه اي جهت در کنار يکديگر قرار دادن داده هاي مشابه مورد استفاده قرار مي گيرند. در اين حالت داده ها در يک واحد منفرد که پس از مدل شدن تا حداکثر ممکن به ( Object ) واقع در دنياي واقعي شباهت دارد گردآوري مي شوند.






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

به هر يک از اين تکه برنامه ها يک مدول ( Module ) يا به عبارتي ماژول گفته مي شود . هر مدول داراي مجموعه اي از توابع و داده هاست که تنها خود وي به آنها دسترسي دارد و در ضمن يک مجموعه جداگانه از توابع و داده ها وجود دارند که در دسترس کليه مدولها مي باشند.

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

در اين الگو همچنين عمل پنهان کردن داده ها ( data hiding ) يا کپسوله کردن ( encapsulating ) آنها امکان پذير شده است. در اين حالت داده هايي که توسط توابع جداگانه اي مورد استفاده قرار مي گيرند از مدولهاي ديگر پنهان مي گردند . بنابراين برنامه نويس مي تواند يک سازه داده اي ( Data Structure ) جديد تعريف کرده و توسط آن مجموعه اي از توابعي که بايد با آنها به کار پرداخته شود شود را معرفي نمايد . در اين حالت ديگر مدولهايي که در خارج از مدول تعريف شده مي باشند مي توانند اين سازه را به عنوان يک نوع داده اي ( data type ) جديد که تنها از توابعي که جهت دسترسي عمومي به آن در نظر گرفته شده اند استفاده مي کند در نظر بگيرند.

داده هايي که در خارج از اين مدولها نيز شناخته شده هستند داده هاي عمومي ( public ) ناميده مي شوند و در مقابل ، از داده هاي ديگر ( که مدولها ممکن است از آنها جهت کار با يک نوع داده اي جديد استفاده کنند و يا آن آن داده هايي که در خارج از يک مدول قابل مشاهده نيستند ) بعنوان داده هاي خصوصي ( private ) ياد مي شود. در C از المانها ( elements ) يا عناصري که استاتيک يا اتوماتيک ( automatic ) مي باشند بعنوان خصوصي و از مابقي عناصر به عنوان عمومي ياد مي شود.

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

در اين حالت ديگر برنامه نويس مي تواند يک الگوريتم ( algorithm ) را با نگراني و ترديد کمتري جهت کار با سازه هاي داده اي مورد استفاده قرار دهد . جزئيات مربوط به نوع سازه ( Structre type ) در داخل مدول تعريف شده پنهان مي گردد. عمل اصلاح و تغيير دادن سازه هاي داده اي را نيز اغلب مي توان با تغيير دادن مدول تعريف شده به انجام رساند ، بدون آنکه به مدولهاي اصلي ديگر تغييري وارد گردد. در بهترين برنامه هاي به زبان C از اين الگوي برنامه نويسي استفاده مي شود.





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

ساختار هر نوع داده اي جديدا ايجاد شده نبايد با انواع داده اي از پيش ساخته موجود در زبان برنامه نويسي مورد نظر شباهت داشته باشد . داده هايي که از الگوي ايزوله کردن داده ها پشتيباني مي کنند برنامه نويس را قادر مي سازند تا عملگرهاي ( operators ) ويژه مورد نياز جهت انواع داده اي جديدا تعريف شده خود را نيز تعريف کند. به عنوان مثال با تعريف يک نوع داده اي جديد با نام Complex برنامه نويس مي تواند عملگرهاي رياضي ساده ( يعني : + ، - ، * ، / ) را در مورد اين نوع داده اي تعريف کند به عبارت ديگر برنامه نويس مي تواند تعريف نمايد که منظور وي از وارد کردن دستور زير چيست :

Complex A, B, C;

C = A + B;

توجه داشته باشيد که من اصطلاح تعريف مجدد ( redefine ) را به کار نبرده ام . عملگرهاي رياضي اوليه همچنان به قوت خود باقي مي مانند.

عمل ايزوله کردن ( abstraction ) داده ها برنامه نويس را قادر مي سازد که در آينده ، در حين به کارگيري يک الگوريتم ، جزئيات را در نظر نگيرد . علاوه بر C++ ، زبان Ada متداولترين زبان برنامه نويسي است که مي تواند از قابليت ايزوله کردن داده ها پشتيباني نمايد.

تعريف يک نوع داده اي جديد که شامل کليه عملگرهاي مورد نياز نيز مي باشد ، مي تواند يک پروسه دست و پا گير باشد ، بويژه براي شخصي که همواره بايد کار را از ابتدا آغاز نمايد .
تعريف يک نوع داده اي (data type ) با توجه به انواع عملگرهاي اوليه ، سبب نامفهوم شدن ارتباطات احتمالا موجود بين انواع عملگرهاي تعريف شده توسط استفاده کننده ( user defined type ) خواهد شد.

به عنوان مثال يک دانشجوي در حال تحصيل در يک کالج يک حالت بخصوص از يک دانشجو ( به مفهوم عمومي آن) است. اين دو نوع ( يعني دانشجوي کالج و يک دانشجو ، در حالت کلي ) در بسياري از صفات با يکديگر مشترکند. بنابراين اينکه ما يک نوع داده اي جديد با نام CollageStudent را با توجه به نوع داده اي اوليه Student ايجاد کرده و يه اين ترتيب رابطه بين اين دو را با يکديگر مشخص کنيم عملي مفيد خواهد بود. به اين موضوع ارث بردن ( inheritance ) گفته مي شود.

با ايجاد چنين تعريفي بايد بتوان بين اين دو تعريف به عقب و جلو حرکت کرد. (يعني بين اين دو تعريف ارتباط برقرار نمود ). يک داده نوع CollageStudent بايد بتواند به توابع تعريف شده جهت نوع Student دسترسي پيدا نمايد . از اينرو تابعي که انتظار دارد يک اشاره گر ( pointer ) به يک داده از Student را دريافت نمايد مي تواند مستفيما يک اشاره گر به يک داده از CollageStudent را دريافت کند زيرا يک دانشجوي کالج نيز در واعق يک دانشجو است. به قابليت تشخيص دادن انواع ميراثي ( inherited types ) از يکديگر پلي مورفيسم (Polymorphism ) گفته مي شود.

بنابراين ما مجددا به تعريف خود از زبانهاي شئ- شناس ( object-oriented ) باز مي گرديم. يک زبان نوع شئ-شناس مي تواند از قابليتهاي کپسوله کردن ، ايزوله کردن ، ارث بردن ، و پلي مورفيسم پشتيباني نمايد.
++C از اين خواص پشتيباني مي کند ، درست به همان ترتيب که پدر آن يعني زبان C از خواص برنامه نويسي ساخت يافته پشتيباني مي کند.

 

[saalek110]

saalek:

مطلب زير را از :
http://www.hamkalam.com/forum/lofiversion/index.php/t521.html
نقل مي كنم.
جناب GoodBoy اين آموزش ها را زحمتش را كشيده. خيلي تميز هم كار كرده.

مفاهيم برنامه نويسي شي گرا


يك شي ( object ) چيست؟

اشيا كليد فهم تكنولوژي شي گرايي است . شما مي توانيد با نگاه به محيط اطراف خود مثال هاي زيادي از اشياي دنياي واقعي را ببينيد
دستگاه تلويزيون - دوچرخه - گربه - درخت - . . .
اين اشياي واقعي داراي دو مشخصه هستند : ويژگي و رفتار
براي مثال يك گربه داراي ويژگي هاي : نام - رنگ - سن - ارتفاع - . . .
و داراي رفتار هايي مانند : صدا - پريدن - دويدن - راه رفتن - خوابيدن - . . .

يك دوچرخه داراي ويژگي هاي : رنگ - تعداد چرخ - نام - تعداد دنده - دنده جاري - تعداد ترمز - . . .
و رفتار هايي مانند : ترمز كردن - تعويض دنده - شتاب دادن - . . .

اشياي يك برنامه نرم افزاري هم همانند اشياي دنياي واقعي مدل مي شوند و داراي ويژگي ها و رفتار ها هستند
ويژگي يك شي برنامه نرم افزاري با يك يا چند متغير از نوع صحيح - اعشاري - كاراكتري يا انواع ديگر بيان ميشود .
رفتار هاي يك شي برنامه نرم افزاري با متد (method) بيان ميشود . متد يك تابع (function)يا زير روال(procedure)
مرتبط با شي مي باشد .
پس يك شي يك مجموعه از متغير ها و متد ها است .
ما مي توانيم اشياي دنياي واقعي را در برنامه خود مدل كنيم مثلا براي كنترل يك دوچرخه الكترونيكي توسط برنامه
مي توانيم يك شي از دوچرخه را در برنامه خود داشته باشيم . و اين شي داراي متغير هايي جهت نگهداري مثلا سرعت دو چرخه
و دنده جاري - وضعيت خاموش و روشن بودن چراغ ها
== == = = = = = = = == = == = = = == = = = == =

پيغام (Message ) چيست؟

يك شي ساده به تنهايي خيلي مفيد نيست . يك شي معمولا بعنوان يك مولفه اي (component) از يك برنامه بزرگ كه شامل اشيا ي ديگري است مي باشد .
برنامه نويس ها مي توانند با استفاده از برهم كنش و ارتباط بين اين اشيا به رفتار ها و اعمال پيچيده تري دست پيدا كنند .

اشياي يك برنامه با فرستادن پيغام ها با يك ديگر ارتباط برقرار مي كنند . وقتي كه شي A بخواهد كه شي B يكي از متد هاي خود را اجرا كند پيغامي به شي B مي فرستد .
== == = == = = = = = == = = =

كلاس ( class ) چيست؟

در دنياي واقعي اشياي زيادي وجود دارند كه از يك نوع هستند . براي مثال دوچرخه شما يكي از دوچرخه هاي زياد موجود در دنيا است . ما مي گوييم دوچرخه شما يك نمونه اي از
كلاس دوچرخه ها است . همه دوچرخه ها داراي ويزگي ها و رفتار هاي متشابهي هستند . و مي توان آنها را در يك كلاس طبقه بندي كرد .
پس كلاس يك مجموعه اي از متغير ها به عنوان ويژگي و متد ها به عنوان رفتار ها ي اشيايي از يك نوع
با ايجاد يك كلاس ما مي توانيم هر تعداد نمونه از آن كلاس تعريف كنيم .
== = = = == = == = = = == = = == = ==

وراثت(inheritence ) چيست؟

وراثت يك مكانيسمي است كه باعث ميشه يك كلاس مثل A ويژگي ها و رفتار هاي يك كلاس ديگري مانند B را به ارث ببرد .
كلاس A زير كلاسي از كلاس B ناميده مي شود (Subclass) يا كلاس A مشتق شده از كلاس B . كلاس A را فرزند و كلاسB را پدر مي نامند .
همچنين مي توانيم از يك كلاس فرزند يك كلاس ديگري را مشتق كنيم مثلا كلاس C فرزند كلاس A باشد .
و به همين ترتيب وراثت مي تونه ادامه داشته باشه .
كلاس C فرزند كلاس A و كلاس A فرزند كلاس B
كلاس B پدر كلاس A و كلاس A پدر كلاس C و الا آخر . . .
= == = = == = == = = = == =

تعريف كلاس در سي ++

يك كلاس با استفاده از كلمه كليدي class و به دنبال آن اسمي كه برنامه نويس براي كلاس خود انتخاب مي كند
و سپس دو علامت براكت { } كه ساختار كلاس درون آن قرار مي گيرد و يك سميكلن در آخر تعريف مي شود

class ClassName 
{
};

مثلا مي خوايم يك كلاسي از يك جعبه تعريف كنيم كه داراي طول و عرض و ارتفاع و رنگ باشد :

class Box
{
double Length, Width, Height;
int Color;
};

قبلا گفتيم كه يك كلاس مي تونه شامل متغير هايي بعنوان ويژگي و متد هايي به عنوان رفتار باشد
در اينجا همون طور كه در بالا ديديد در تعريف كلاس جعبه فقط از متغير استفاده كرديم تا ويژگي هاي
آن جعبه را مشخص كنيم .و اسمي از متد و تابع آورده نشد تا رفتار آن جعبه را مشخص كند .
حال يك كلاس ديگري تعريف مي كنيم :

class  Bicycle 
{
char  Name[10];
int     Color;
int    Wheel;
int    Gear;
int    CurrentGear;

void   ChangeGear();
};

كلاس دوچرخه داراي ويژگي هاي رنگ (Color) و تعداد چرخ (Wheel) و نام (Name) و تعداد دنده (Gear ) و دنده جاري (CurrentGear) .
و داراي متدي به نام ChangeGear براي تغيير دنده . همانطور كه ديده ميشه متد در اينجا يك تابع است .

Method=>Function
​

به هر يك از متغير ها و توابع موجود در يك كلاس عضو آن كلاس گفته مي شود .
حال يك كلاس تعريف مي كنيم :

class  Box 
{
double   Length ,Width,Height;
int   Color;
double  Volum();
};

با تعريف يك كلاس بايد از آن كلاس در برنامه خود استفاده كنيم و براي استفاده از يك كلاس بايد ابتدا يك شي (Object) از آن كلاس ايجاد كنيم .

Box  MyBox;

براي واضح شدن موضوع كد زير را نگاه كنيد :

include<iostream>
using  namespace  std;

[color=red]class  Box
{
double   Length,Width,Height;
int   Color;
Double   Volum();
};
[/color]
int main()
{
[color=red]
Box    MyBox;  // Declare Object MyBox [/color]
int     i;
float  Volum;

. . .


return 1;
}

جهت دسترسي به اعضاي يك شي ابتدا نام شي را نوشته و سپس يك نقطه (Point ) و سپس يك عضو شي
مثال :

MyBox.Color جهت دسترسي به رنگ جعبه
MyBox.Length دسترسي به طول جعبه 
MyBox.Volum () دسترسي به حجم جعبه

مطلب بسيار مهم در تعريف يك كلاس وجود دارد اين است كه دسترسي به اعضاي يك كلاس را مي توانيم به سه بخش
تقسيم كنيم . كه اين سه بخش با كلمات كليدي public و private و protected مشخص مي شوند .

public :

اعضايي از كلاس را در اين بخش قرار مي دهيم كه بخواهيم بيرون از كلاس به آنها دسترسي داشته باشيم . مثلا در بدنه تابع اصلي Main
اعضايي كه در اين بخش قرار دارند اعضايي عمومي هستند كه دسترس به آنها توسط تمام توابع و كلاس هاي ديگر امكان پذير است .

private :

در اين بخش اعضايي را كه بخواهيم دسترسي به آنها فقط از طريق توابع موجود درون كلاس امكانپذير باشد و از خارج كلاس قابل دسترس نباشند
تعريف مي شوند . اين اعضا خصوصي هستند و محدود به خود كلاس مي باشند .

protected :

اين بخش بخش محافظت شده نام دارد و در بخش مربوط به وراثت بيشتر مورد بحث قرار مي گيرد . پس تا بعد . . .

مثال :
مي خوايم در كلاس جعبه اعضاي طول و عرض و ارتفاع بصورت خصوصي و حجم بصورت عمومي تعريف كنيم :

class  Box
{
[color=red]public :[/color]
double  Volum();
[color=red]private :[/color]
double  Length,Width,Height;
};

حال اگه يك شي از كلاس تعريف كنيم اون وقت فقط مي تونيم تابع Volum در خارج از كلاس استفاده كنيم و بقيه اعضا قابل دسترس نيستند .

#include<iostream>
using  namespace  std;

[color=red]class  Box
{
public :
double  Volum();
private :
double  Length,Width,Height;
};
[/color]
int main()
{
[color=red]
Box    MyBox;  // Declare Object MyBox 
[/color][color=blue]
MyBox.Volum(); //  It   is   OK 

MyBox.Length=8; // It  is   wrong 
[/color]
. . . 

return 1;
}

 

[saalek110]

سالك: در سايت بالا ، 3 پست ديگه(با سايز پست بالا) بايد زده بشه تا تمام مطلب نقل بشه.
خودتان تا من نقل كنم مي توانيد از لينك بالا استفاده كنيد و بخوانيد.
هدف من اين بود كه در اين قسمت انرژي من نگذارم و از سايتهاي ديگر استفاده كنم و بقيه مطلب را از كتابهاي انگليسي كار كنيم.من زياد زبانم خوب نيست و نمي توانستم مفاهيم پايه را خوب بگم و اين دوست عزيز هم خيلي قشنگ مطالب را بيان كرده.

كمي كدها اشكال سينتكس داره كه خودتان رفع كنيد. چيزهاي مهمي نيست. مثل نگذاشتن ريترن و اينكلودها. مهم مفاهيم كلاس است.

 

[saalek110]

saalek:

با سلام.
در اينجا باز به ادامه نقل از فروم قبل مي پردازيم. از:
http://www.hamkalam.com/forum/lofiversion/index.php/t521.html

سالك: در نقل قبلي در پستهاي قبل اين تاپيك ،، ياد گرفتيم كه كلاس را چطور تعريف كنيم و اعضاي public و private (شامل متغير و متد(تابع) ) را شناختيم. حال به ادامه بحث توجه كنيد.

GoodBoy:

اگر اعضايي را در كلاس درون هيچ بخشي قرار نداديم آنها بطور پيش فرض اعضاي خصوصي در نظر گرفته خواهند شد .

يعني كلمه كليدي Private بطور پيش فرض تمام اعضاي يك كلاس را در بر دارد و اگر بخواهيم عضوي بصورت عمومي تعريف كنيم بايد آن را در بخش public قرار بديم :

class  Rectangle {
   int x, y;
[color=red] public:[/color]
   void set_values (int,int);
   int area (void);
 } rect;

در اين كلاس دو عضو x و y خصوصي هستند. private حالت پيش فرض ديگه نيازي نيست اونو بنويسيم. در بخش public هم كه دو متد از نوع عمومي تعريف كرديم .

set_value براي مقدار دهي به مقادير xو y
area هم براي بدست آوردن مساحت

همون طور كه ديده ميشه دو عضو كلاس دو تابع هستند يكي براي مقدار دهي به متغير ها و ديگري براي محاسبه مساحت

rect هم كه يك شي از اين كلاس .

= = = = = = == = == ==
براي تعريف اين توابع دو روش هست :
يكي اينه كه اين توابع رو درون كلاس تعريف كنيم كه به اين تعريف محلي يا inline گفته ميشه .
روش دوم اينه كه در خارج از كلاس و البته بعد از تعريف كلاس توابع رو تعريف كنيم به اين تعريف عمومي يا global گفته ميشه .

روش محلي :
​

class  Rectangle {
int x, y;
public:
void set_values (int  a , int b ) 
{
x=a; y=b; 
}
int area (void)
{
return (x*y);
}
};

حال يك مثال كامل كه قابل اجرا هست را مي نويسم :
​

#include <iostream.h>

[color=red]class  Rectangle {
int x, y;
public:
void set_values (int  a , int b ) 
            {
x=a; y=b; 
            }
int area (void)
      {
return (x*y);
      }
                         };[/color]

int main () {
 [color=red]Rectangle   rect ,  rectb;[/color]
[color=blue] rect.set_values (3,4);
 rectb.set_values (5,6);[/color]
 cout << "rect area: " <<  [color=blue]rect.area()[/color] << endl;
 cout << "rectb area: " << [color=blue] rectb.area()[/color] << endl;
}

===========روش دوم============​

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

مثال:
​

#include <iostream.h>

[color=red]class   Rectangle {
   int x, y;
 public:
   void set_values (int,int);
   int area (void) {return (x*y);}
};[/color]

[color=green]void  Rectangle[/color][color=red]::[/color][color=green]set_values (int a, int b) {
 x = a;
 y = b;
}[/color]

int main () {
 [color=red]Rectangle rect;[/color]
[color=blue] rect.set_values (3,4);[/color]
 cout << "area: " << [color=blue]rect.area()[/color];
}

متد area درون كلاس inline تعريف شده و متد set_value در خارج از كلاس Global تعريف شده است .

يك مثال ديگه:
​

#include <iostream>
#include <cstring>
using namespace std;

[color=red]class student {
char name[30];

public:
void putname(char *str);
void getname(char *str);

private:
 int grade;

public:
void putgrade(int g);
int getgrade();
};
[/color]
[color=green]void student[/color][color=red]:: [/color][color=green]putname(char *str) {
strcpy(name, str);
}

void student[/color][color=red]:: [/color][color=green]getname(char *str) {
strcpy(str, name);
}

void student[/color][color=red]:: [/color][color=green]putgrade(int g) {
grade = g;
}

int student[/color][color=red]:: [/color][color=green]getgrade() {
return grade;
}[/color]
int main() {
[color=red]student x;[/color]

char name[50];

[color=blue]x.putname("GoodBoy");
x.putgrade(5);

x.getname(name); [/color]
cout<<name<<" got "<<[color=blue]x.getgrade()[/color]<<" from OOP."<<endl;
return 0;
}

goodboy:
در پست بعدي اين كد رو تجزيه و تحليل مي كنم ! پس تا بعد . . .
.

 

[saalek110]

saalek:

شرح برنامه پست قبل:

#include <iostream>
#include <cstring>
using namespace std;

اين سه خط كه تعريف دو كتابخانه يكي ورودي خروجي و ديگري كار با رشته هاست .
سالك: كامپايلر ايشان(goodboy ) ويژوال سي است. اين قسمتها را خودتان تبديل كنيد.

class student {
char name[30];

public:
void putname(char *str);
void getname(char *str);

private:
 int grade;

public:
void putgrade(int g);
int getgrade();
};

اين هم تعريف يك كلاس بنام student داراي اعضاي زير است :
اول name اسم دانش آموز كه private است.
دوم(چند خط پايين تر) grade ، نمره دانش آموز كه باز private است.

متد putname عمومي public براي مقدار دهي به name در خارج كلاس.
متد getname عمومي public براي دسترسي به مقدارname خارج از كلاس.

متد putgrade عمومي public براي مقدار دهي به grade در خارج از كلاس.
متد getgrade عمومي public براي دسترسي به grade خارج كلاس.

همونطور كه مشاهده مي كنيد بخش هاي خصوصي و عمومي دو بار تعريف شدند يعني در دو جا از كلمه كليدي public استفاده كرديم
هيچ گونه محدوديتي در استفاده از تعداد بخش هاي عمومي و خصوصي نيست و ما مي توانيم بر اساس بزرگي كلاس اون رو به بخش هاي
كوچيك تر و قابل فهم تر تقسيم كنيم .

void student::putname(char *str) {
strcpy(name, str);
}

با استفاده از تابع داخلي strcpy موجود در كتابخانه cstring براي مقدار دهي متغير name استفاده كرديم.

void student::getname(char *str) {
strcpy(str, name);
}

اين برعكس متغير name درون str كپي مي شود و str هم كه درون برنامه قابل دسترس است.

void student::putgrade(int g) {
grade = g;
}

مقدار دهي به متغير grade.

int student::getgrade() {
return grade;
}

جهت دسترسي به متغير grade در خارج كلاس لازم است كه اين متد مقدار grade رو برگردونه.

student x;

در تابع اصلي x يك شي و نمونه اي از كلاس student تعريف مي شود .

x.putname("GoodBoy");
x.putgrade(5);

در اين قسمت با استفاده از دو متد عمومي مقدار دهي اوليه متغير هاي grade و name انجام ميشه.

x.getname(name);
cout<<name<<" got "<<x.getgrade()<<" from OOP."<<endl;

در پايان جهت دسترسي به دو متغير خصوصي از دو متد عمومي استفاده ميشه !

 

[saalek110]

saalek:

contrucrors and destrustors
سازنده ها و مخرب ها

اشيا Objects معمولا نيازمند به مقدار دهي اوليه متغير ها و تخصيص حافظه پويا در زمان شكل گيري هستند .
يك كلاس مي تواند شامل يك تابعي بنام سازنده cuonstructor كه مي تواند اين عمل مقدار دهي اوليه رو در زمان تشكيل شي انجام دهد .
اين تابع در واقع يك متد بسيار ويژه است چرا ؟ چون با ايجاد يك شي اين متد بطور خود كار فراخواني شده و اجرا مي شود . نكته جالب توجه اينجاست
كه اين سازنده هيچ مقداري رو برنمي گردونه و از كلمه كليدي void هم در تعريف آن استفاده نمي شه .
نكته ديگر كه اين تابع رو ويژه مي سازد اين است كه نام اين تابع با نام كلاس يكي است ! جالبه نيست ؟؟

class Rectangle {
   int width, height;
 public:
   Rectangle ();
   int area (void) {return (width*height);}
};

Rectangle::Rectangle () {
 width = 10;
 height = 20;
}

در بالا كلاسي بنام Rectangle تعريف كرديم كه يك سازنده بنام Rectangle داره . بعد از كلاس اين سازنده رو تعريف كرديم
كاري كه انجام مي ده اينه كه تمام اشياي ساخته شده از اين كلاس مستطيل هايي به ابعاد 10 در 20 هستند .
حال تابع اصلي رو مي نويسم :

int main () {
 Rectangle   rect;
 
 cout << "rect area: " << rect.area() << endl;
 return 1;
}

= = = = = = = = = = = = = =
سازنده يك تابع است و همانند ديگر توابع ميتونه آرگومانهايي به عنوان ورودي بگيره . در اين حالت موقع تعريف يك شي از كلاس بايد
به همراه مقادير ورودي صورت بگيره . مثال :

#include <iostream.h>

class  Vector {
 public:
   int x,y;
   Vector (int,int);
};

Vector::Vector (int a, int b) {
 x = a;
 y = b;
}

int main () {
[color=red] Vector   c (3,1);[/color]
 
 cout << c.x << "," << c.y;
 return 0;
}

يك كلاس بنام Vector كه داراي سازنده اي با دو ورودي از نوع عدد صحيح . در تابع اصلي وقتي كه مي خوايم يك شي از اين كلاس
ايجاد كنيم بايد به همراه نام شي درون پرانتز دو عدد صحيح به عنوان ورودي بياوريم .

= = = = = = = = =
يك مفهوم ديگري اين كه يك كلاس مي تونه داراي چند ين سازنده باشد . مثلا يكي بدون آرگومان و يكي ديگه داراي چند آرگومان باشد
به اين عمل Overload سازنده گفته ميشه ( دوباره تعريف كردن يا دوباره ساختن)

مثال فوق رو با دو سازنده در زير مي بينيم :

#include <iostream.h>

class  Vector {
 public:
   int x,y;
   Vector ();
   Vector (int,int);
   };

[color=blue]Vector::Vector (int a, int b) {
 x = a;
 y = b;
}[/color]

[color=red]Vector::Vector () {
 x = 10;
 y = 20;
}[/color]

int main () {
 Vector a (3,1);
 Vector c;
 
 cout << c.x << "," << c.y;
 cout << a.x << "," << a.y;
 return 0;
}

 

[saalek110]

saalek:

Destructor
مخرب

مخرب تابعي ديگر كه عمل مخالف سازنده انجام مي دهد . گفتيم كه سازنده زماني كه يك شي از كلاسي ايجاد شد بطور خودكار فراخواني و اجرا مي شود و برنامه نويس نيازي نيست كه آن را در بدنه تابع فراخواني كند .
مخرب نيز به همين صورت است . منتها قبل از اينكه شي از بين برود اين مخرب بطور خودكار فراخواني و اجرا مي شود . اين مخرب نيز يك تابعي است هم نام با كلاس ولي با يك علامت مد ~ در ابتداي آن قرارردارد . كه دليل بر مخرب بودن آن است .
پس تا اينجا متوجه شديم كه سازنده بطور خودكار زمان ايجاد يك شي از كلاس فراخواني و اجرا مي شود و كار اين سازنده مقدار دهي اوليه و تخصيص حافظه مي باشد،
برعكس مخرب قبل از نابودي شي فراخواني و اجرا شده و كارش هم آزاد سازي حافظه اي كه سازنده تخصيص داده بود .

به مثال زير دقت كنيد :

#include <iostream.h>

class Rectangle {
   int *width, *height;
 public:
   Rectangle (int,int);
   ~Rectangle ();
   int area (void) {return (*width * *height);}
};

Rectangle::Rectangle (int a, int b) {
 width = new int;
 height = new int;
 *width = a;
 *height = b;
}

[color=red]Rectangle::~Rectangle () {
 delete width;
 delete height;
}[/color]

int main () {
 Rectangle rect (3,4), rectb (5,6);
 cout << "rect area: " << rect.area() << endl;
 cout << "rectb area: " << rectb.area() << endl;
 return 0;
}

براي تخصيص حافظه به يك اشاره گر در سي ++ از عملگر new و براي آزاد سازي حافظه اختصاص داده شده از عملگر delete استفاده ميشود .
در ضمن مخرب نه مقداري ميگيره و نه مقداري رو برمي گردونه .

 

[saalek110]

saalek:

اشاره گر به كلاس

اشاره گر به يك كلاس همانند ديگر اشاره گرها بايد بعد از تعريف با استفاده از عملگر new تخصيص حافظه به آن صورت گيرد و در اين حالت دسترسي به اعضاي آن بجاي عملگر نقطه Point از عملگر اشاره گر a -> b استفاده ميشود :

class CRectangle {
   int width, height;
 public:
   void set_values (int, int);
   int area (void) {return (width * height);}
};

void CRectangle::set_values (int a, int b) {
 width = a;
 height = b;
}

int main () {
 CRectangle [color=blue]a[/color],[color=red] *b, *c;[/color]
 CRectangle [color=DarkOrange]* d = new CRectangle[2];[/color]
 [color=red]b= new CRectangle;
 c= &a;[/color]
 [color=blue]a.set_values (1,2);[/color]
 [color=red]b->set_values (3,4);
 d->set_values (5,6);[/color]
[color=DarkOrange] d[1].set_values (7,8);[/color]
 cout << "a area: " <<[color=blue] a.area()[/color] << endl;
 cout << "*b area: " << [color=red]b->area()[/color] << endl;
 cout << "*c area: " << [color=red]c->area()[/color] << endl;
 cout << "d[0] area: " << [color=DarkOrange]d[0].area()[/color] << endl;
 cout << "d[1] area: " << [color=DarkOrange]d[1].area()[/color] << endl;
 return 0;
}

.

 

[saalek110]

saalek:

كلمه كليدي this

اين كلمه كليدي درون يك كلاس مورد استفاده قرار گرفته و شيي از كلاس را كه در حال اجراست را نشان مي دهد اين يك اشاره گر است كه داراي آدرس يك شي از كلاس است همون شي كه در آن لحظه در حال اجراست .

#include <iostream.h>

class CDummy {
 public:
   int isitme (CDummy& param);
};

int CDummy::isitme (CDummy& param)
{
 if (&param == [color=red]this[/color]) return 1;
 else return 0;
}

int main () {
 CDummy a;
 CDummy* b = &a;
 if ( b->isitme(a) )
   cout << "yes, &a is b";
 return 0;
}

يا يك مثال ديگه وقتي كه مقدار برگشتي يك متد كلاس باشد.

CVector& CVector::Copy ( CVector&  param)
{
 x=param.x;
 y=param.y;
 return *[color=red]this[/color];
}

 

[saalek110]

saalek:

كلمه كليدي friend

همونطور كه قبلا ديديم سه بخش دسترسي به اعضاي يك كلاس وجود دارد . public و private و protected
و دو بخش private و protected از خارج كلاس قابل دسترسي نبودند ما مي توانيم با استفاده از كلمه كليدي friend اين دو بخش رو قابل دسترسي كنيم . در مثال زير دقت كنيد كه تابع Duplicate بصورت friend تعريف شده است توجه كنيد كه تابعDuplicate به عنوان يك تابع external تعريف شده و نه يك متدي از كلاس در واقع كلمه كليدي friend ما را قادر مي سازد كه يك تابع خارجي رو درون كلاس طوري تعريف كنيم كه قادر به استفاده از اعضاي خصوصي كلاس باشيم . و همچنين در تابع اصلي به طرز فراخواني اين تابع دقت كنيد . مي دانيم كه يك تابع وقتي كه عضو يك كلاس باشد در زمان فراخواني بايد به همراه نام شي ايجاد شده از كلاس بيايد ولي اين تابع ما عضو كلاس نيست .

#include <iostream.h>

class CRectangle {
   int width, height;
  [color=red] friend CRectangle duplicate (CRectangle);[/color]
 public:
   void set_values (int, int);
   int area (void) {return (width * height);}
};

void CRectangle::set_values (int a, int b) {
 width = a;
 height = b;
}

[color=red]CRectangle duplicate (CRectangle rectparam)
{
 CRectangle rectres;
 rectres.width = rectparam.width*2;
 rectres.height = rectparam.height*2;
 return (rectres);
}[/color]

int main () {
 CRectangle rect, rectb;
 rect.set_values (2,3);
 cout << rect.area()<<endl;
 [color=red]rectb = duplicate (rect);[/color]
 cout << rectb.area()<<endl;
}

به همين صورت كه يك تابع از نوع friend تعريف كرديم مي تونيم يك كلاسي رو درون يك كلاس ديگر از نوع friend تعريف كنيم تا بتواند از اعضاي خصوصي آن كلاس استفاده كند :

#include <iostream.h>

[color=green]class CSquare;[/color]

class CRectangle {
   int width, height;
 public:
   int area (void)
     {return (width * height);}
   void convert ([color=blue]CSquare a[/color]);
};

[color=green]class Csquare[/color] {
 private:
   int side;
 public:
   void set_side (int a)
     {side=a;}
  [color=red] friend class CRectangle;[/color]
};

void CRectangle::convert (CSquare a) {
 [color=red]width = a.side;
 height = a.side;[/color]
}
 
int main () {
 CSquare sqr;
 CRectangle rect;
 sqr.set_side(4);
 rect.convert(sqr);
 cout << rect.area();
 return 0;
}

در اينجا دو كلاس تعريف كرديم يكي CRectangle و ديگري CSquare كه درون كلاس CSquare كلاس CRectangle رو صورت friend تعريف كرديم . اين تعريف باعث ميشه كه كلاس CRectangle بتواند از اعضاي كلاس CSquare استفاده نمايد . به مثال بالا دقت كنيد در حالت عادي كلاس CRectangle نمي تواند از اعضاي خصوصي كلاس CSquare مثل Side استفاده كند اما با كلمه كليدي friend همان طور كه در تعريف تابع convert ديده ميشه از اعضاي خصوصي كلاس CSquare استفاده شده است .

 

[saalek110]

saalek:


Overloading operators

سي ++ تنظيماتي رو براي استفاده از عملگرهاي استاندارد بين كلاس ها علاوه بر نوع داده هاي پايه جا سازي كرده است .
براي مثال :

int a,b,c;
a=b+c;

كاملا معتبر است . و همه متغير ها از نوع داده پايه هستند . Fundamental Type
اما واسه داده هاي از نوع مثلا ساختار اين گونه عمل جمع نامعتبر است :

struct { char product [50]; float price; } a, b, c;
a = b + c;

البته عمل انتساب = يك كلاس يا ساختار به كلاس يا ساختار ديگر از همان نوع معتبر است و تنها چيزي كه باعث خطا مي شود اعمالي مانند جمع است كه اين عمل بين نوع هاي داده اي غير پايه نامعتبر است .

اما با تشكر از سي ++ كه با اوود لود كردن عملگرها اين امكان و اجازه رو به ما داده است . در اينجا ليستي از عملگرهايي رو كه اجازه اوود لود كردن آنها داريم مي بينيم :

+    -    *    /    =    <    >    +=   -=   *=   /=   <<   >>
<<=  >>=  ==   !=   <=   >=   ++   --   %    &    ^    !    |
~    &=   ^=   |=   &&   ||   %=   []   ()   new  delete

واسه اوور لود كردن يك عملگر تنها كاري كه بايد انجام دهيم تعريف يك تابع درون كلاس بعنوان عضوي از كلاس است.
نام اين تابع بايد از كلمه كليدي operator و به دنبال آن علامت عملگر كه مي خواهيم اوور لود كنيم تشكيل شود همانند زير :

type  operator sign (parameters);

در اينجا يك مثالي واسه استفاده از عملگر جمع بين كلاس ها ميارم . اين كلاس يك بردار رو تعريف مي كنه و جمع بين بردار ها كه همه مي دونن چطوريه ! مولفه هاي اول با هم جمع ميشن و مولفه هاي دوم با هم !

#include <iostream.h>

class CVector {
 public:
   int x,y;
   CVector () {};
   CVector (int,int);
   CVector operator + (CVector);
};

CVector::CVector (int a, int b) {
 x = a;
 y = b;
}

CVector CVector::operator+ (CVector param) {
 CVector temp;
 temp.x = x + param.x;
 temp.y = y + param.y;
 return (temp);
}

int main () {
 CVector a (3,1);
 CVector b (1,2);
 CVector c;
 c = a + b;
 cout << c.x << "," << c.y;
 return 0;
}

همون طور كه مشاهده كرديد اوور لود كردن يك تابعي است و عضوي از كلاس كه مقداري رو مي گيره و مقداري رو برمي گردونه . ما مي تونيم به دو روش زير عمل جمع بين داده هاي كلاس انجام بديم :

c = a + b;
c = a.operator+ (b);

آموزشهاي زيباي جناب GOODBOY تمام شد.
درود.

 

[saalek110]

saalek:

براي راحتي بيشتر ميشه ((تعريف كلاس)) را در يك فايل header قرار داد.

#ifndef CAR_H
#define CAR_H

class Car {
public:

protected:

};
#endif

به آن class header file مي گوييم.
و بعد مثلا در برنامه(فايل) اصلي داريم:

// اينكلود كردن كلاس هيدر فايل مربوطه
[color=red]#include "Car.h"[/color]

void f()
{
  Car a;                                            
  Car b(100, 73);                                   

  // ...
}

int main()
{

  f();
}

يا :

#include "Car.h"                                  

void f()
{
  Car a;                                            
  a.startEngine();                                  
  a.tuneRadioTo("AM", 770);                         
[color=red]}[/color]                                                   

int main()
{
  f();
}

در برنامه بالا در تابع f() يك شي car خلق شده و دو member آن مورد استفاده قرار گرفته اند. و در محل كروشه قرمز اين شي destroy يعني نابود مي شود.

همچنين مرگ اشيا را در كروشه هاي قرمز برنامه زير داريم:

#include "Car.h"

void f()
{
  Car a;

  for (int i = 0; i < 10; ++i) {
    Car b;                                          
    // ...
  [color=red]}[/color]      // Each iteration's [color=red]b[/color] dies here                                           

  // ...
[color=red]}[/color] //    Object [color=red]a[/color] dies here                                               

int main()
{
  f();
}

از كتاب C++ FAQs, Second Edition .