توجه ! این یک نسخه آرشیو شده می باشد و در این حالت شما عکسی را مشاهده نمی کنید برای مشاهده کامل متن و عکسها بر روی لینک مقابل کلیک کنید : آموزش جامع و مرحله به مرحله زبان برنامه نويسي ++c (سي پلاس پلاس)
با سلام خدمت دوستان و كاربران عزيز باشگاه
در اين تاپيك به
آموزش جامع و مرحله به مرحله زبان برنامه نويسي ++C
پرداخته مي شود.
http://pnu-club.com/imported/mising.jpg
اميدوارم مورد قبول شما عزيزان قرار بگيرد
باتشكر: طه-TAHA
زبان C(سی)
C یک زبان برنامه نویسی (http://pnu-club.com/redirector.php?url=http%3A%2F%2Fen.wikipedia.org%2 Fwiki%2FProgramming_language) کامپیوتری هست که در سال 1972 توسط Dennis Ritchie (http://pnu-club.com/redirector.php?url=http%3A%2F%2Fen.wikipedia.org%2 Fwiki%2FDennis_Ritchie) برای سیستم عامل (http://pnu-club.com/redirector.php?url=http%3A%2F%2Fen.wikipedia.org%2 Fwiki%2FOperating_system) Unix (http://pnu-club.com/redirector.php?url=http%3A%2F%2Fen.wikipedia.org%2 Fwiki%2FUnix) نوشته شد.
C تکامل یافته زبان برنامه نویسی B (http://pnu-club.com/redirector.php?url=http%3A%2F%2Fen.wikipedia.org%2 Fwiki%2FB_%2528programming_language%2529) می باشد و نامگذاری C که بعد از B بوجود آمد همین است.
C یک زبان برنامه نویسی سطح میانی و ساخت یافته می باشد. در علوم کامپوتری، سطوح زبانهای برنامه نویسی را به سه دسته اصلی تقسیم می کنند:
1- سطح بالا.
2- سطح میانیC و ++C
3- سطح پایین.
زبان C جزو دسته دوم می باشد. به این دلیل که قادر است مانند زبان اسمبلی (http://pnu-club.com/redirector.php?url=http%3A%2F%2Fen.wikipedia.org%2 Fwiki%2FAssembly_language) مستقیماً با حافظه(بیت، بایت، آدرس و...) کار کند و از طرف دیگر نوشتن و خواندنش راحت می باشد(مانند زبان Pascal (http://pnu-club.com/redirector.php?url=http%3A%2F%2Fen.wikipedia.org%2 Fwiki%2FPascal_%2528programming_language%2529)).
از جمله ویژگی های زبان C می توان به:
قابلیت انعطاف، زبان سیستمی، سطح میانی، قابل حمل، کامل و کوچک، سبک، سریع و قدرتمند بودنش اشاره کرد.
زبان ++C(سی پلاس پلاس)
در سالهای بین 1979 و 1983، زبان C توسط Stroustrup تکامل یافت. توانایی و قدرت این زبان چند برابر شد و زبان C جدید و بعد C کلاسدار و بعد ++C بوجود آمد. که اولین نگارش ++C در سال 1985 روانه بازار شد. C++ - Wikipedia, the free encyclopedia (http://pnu-club.com/redirector.php?url=http%3A%2F%2Fen.wikipedia.org%2 Fwiki%2FC%252B%252B)
زبان ++C یک زبان برنامه‌نویسی کامپیوتری همه منظوره، شی گرا، سطح بالا و چندرگه، عمومی و با قابلیت‌های سطح بالا و سطح پایین می‌باشد.
ساختار این زبان شامل: دستورات پیش پردازنده(Preprocessor)، اعلانات سراسری(توابع، ماکروها، متغیر ها، ثوابت و...)(Global declaration)، تابع main و توابع تعریفی کاربر(user-defined function) می باشد.
الگوريتم ها
برای حل مسائل مختلف توسط کامپيوتر بايد اين مسائل را به صورت مراحل عملياتی و تصميم گيری ساده ای که کامپيوتر قادر به اجرای آن باشد تبديل کرد. بدين ترتيب ليست مرتبی از مراحل عملياتی بدست می آيد که اجرای مرتب آنها منجر به حل مسئله توسط کامپيوتر می شود. اين ليست مرتب از مراحل عملياتی و تصميم گيری ، الگوريتم ناميده می شود.
در حالت کلی الگوريتم ها بايد ويژگی های زير را داشته باشند:
الف) الگوريتم بايد ما را به نتيجه مورد نظر برساند.
ب) در زمان محدود پايان يابد.
ج) دستورالعملها بايد به ترتيب منطقی پشت سرهم قرار گيرند.
د) جملات الگوريتم ها بايد به صورت امری ، سؤالی باشند.
ه) هر الگوريتم بايد نقطه آغاز و پايان داشته باشد.
يکی از توانايی هايی که در کامپيوتر وجود دارد استفاده از خانه های حافظه است که می توان در آن اطلاعات را قرار داد و در هر لحظه از اجرای الگوريتم می توان محتويات آن را تغيير داده و مقدار جديدی را در آن قرار دهيم اين ويژگی کارايی ما را برای حل مسائل پيچيده تر افزايش می دهد
مثال : الگوريتم تعويض چرخ پنچر شده يک اتومبيل.
0- شروع.
1- جک را زير اتومبيل بگذاريد.
2- پيچهای چرخ پنچر شده را باز کنيد.
3- چرخ را خارج کنيد.
4- چرخ يدک را به جای چرخ پنچر شده بگذاريد.
5- پيچها را ببنديد.
6- اگر پيچها سفت نشده اند به مرحله 5 برو.
7- جک را پايين بياوريد.
8- چرخ پنچر شده را در صندوق عقب اتومبيل بگذاريد.
9- پايان.
مثال : الگوريتمی بنويسيد که دو عدد از ورودی دريافت شود و سپس تعيين شود که مجموع دو عدد بزرگتر از 20 است يا نه.
0- شروع .
1- دو عدد a و b را از ورودی در يافت کن.
2- a+b را محاسبه کن.
3- آيا a+b>20 است؟ اگر بلی به مرحله 6 برو.
4- بنويس خير.
5- به مرحله 7 برو.
6- بنويس بلی.
7- پايان.
با برنامه ريزی و ساماندهی دقيق می توان به راه حلی مناسب جهت حل يک مسئله به کمک کامپيوتر رسيد. هرگونه کم توجهی و بی دقتی در نوشتن الگوريتم ضمن بروز مشکلات بسيار، برنامه نويس را نيز از هدف خود دور خواهد کرد؛ لذا برای به هدف رسيدن بايد درک صحيح و کاملی از صورت مسئله داشت و سپس راه حل مورد نظر را به صورت الگوريتم بنويسيم. و در نهايت الگوريتم مورد نظر را به زبان برنامه نويسی مورد نظر تبديل کنيم. برای درک بهتر شيوه حل مسائل و نوشتن الگوريتم به مثالهای زير توجه کنيد:
مثال : الگوريتمی بنويسيد که مجموع اعداد طبيعی مضرب 7 و کوچکتر از 50 را حساب کند.
برای نوشتن اين الگوريتم به دو خانه حافظه نياز داريم.
0- شروع.
1- در خانه حافظه sum عدد صفر را قرار بده.
2- در خانه حافظه index عدد 7 را قرار بده.
3- مقدار index را با مقدارsum جمع کن
و حاصل را در sum قرار بده.
4- مقدار 7 را با مقدار index جمع کن
و حاصل را در index قرار بده.
5- آياindex بزگتراز 50 است،اگر خير به مرحله 3 برو.
6- محتوای sum را چاپ کن.
7- پايان.
در الگوريتم فوق مقادير حافظه sum و index تغيير می کند، تا اينکه سرانجام شرط " آيا index بزرگتر از 50 است " بلی می شود لذا محتوای sum در خروجی چاپ خواهد شد و الگوريتم به پايان می رسد. اما در مراحل قبلی شرط فوق خير می باشد، لذا الگوريتم ادامه پيدا می کند.
مثال : الگوريتمی بنويسيد که 1000 عدد را از ورودی دريافت کرده و کوچکترين را چاپ کند.
فرض کنيد که به شما ليستی از اعداد را می دهند، برای پيدا کردن کوچکترين عدد در ليست اولين عدد را به عنوان کوچکترين در نظر می گيريد سپس عدد بعدی را با آن مقايسه می کنيد، اگر عدد جديد از عدد قبلی کوچکتر بود عدد جديد را به عنوان کوچکترين در نظر می گيريد و گر نه همان عدد قبلی کوچکترين خواهد بود. اين روند را تا انتهای ليست ادامه می دهيد؛ در پايان عددی که در هر بررسی به عنوان کوچکترين عدد بود، جواب مورد نظر ما خواهد بود. توجه کنيد که در اين روال شما همواره يک عدد را در ذهن خود در نظر گرفته بوديد، برای نوشتن الگوريتم مورد نظر ما يک خانه حافظه را به کوچکترين عدد درهر مرحله اختصاص می دهيم.
0- شروع.
1- min را دريافت کن.
2- i =1 .
3- a را دريافت کن.
4- اگر a<min آنگاه min = a .
5- i = i + 1 .
6- اگر i>=1000 به مرحله 8 برو.
7- به مرحله 3 برو.
8- min را چاپ کن.
9- پايان.
الگوريتم های قبلی به صورت جملات فارسی بودند که سبب طولانی و حجيم شدن الگوريتم می شدند. ولی الگوريتم اخير بيشتر به صورت جملات رياضی بود. اين شيوه سبب راحتی درک الگوريتم و ساده شدن نگارش آن می شود. از اين به بعد نيز الگوريتم ها را به شيوه جديد نگارش خواهيم کرد. شما نيز سعی کنيد از اين شيوه استفاده کنيد.
مثال : الگوريتمی بنويسيد که سه عدد از ورودی دريافت شود و تعيين شود که اين اعداد می توانند اضلاع مثلث باشند يا خير.
0- شروع.
1- a وb وc را از ورودی بگير.
2- اگر a>b+c به 7 برو.
3- اگر b>a+c به 7 برو.
4- اگرc>a+b به 7 برو.
5- بنويس " بلی ".
6- به 8 برو.
7- بنويس " خير ".
8- پايان.
فلوچارت
در عمل برای نمايش الگوريتم از يک فلوچارت ( شمای جريان عمليات ) استفاده می شود. در حقيقت فلوچارت روش تصويری و استاندارد نمايش الگوريتم است.
در رسم فلوچارت علائم و نمادهای استانداردی به کار می رود که هر کدام دارای معانی ويژه ای هستند.
از شکل بيضی افقی برای شروع و پايان عمليات استفاده می شود.
از شکل مستطيل برای نمايش مراحل پردازشی استفاده می شود و در داخل آن عمل مورد نظر نوشته می شود. اين نماد ممکن است چندين ورودی داشته باشد ولی تنها يک خروجی دارد.
از نماد لوزی برای نشان دادن مراحل تصميم گيری استفاده می گردد و شرط يا سؤال مورد نظر در داخل لوزی نوشته می شود.
از متوازی الاضلاع برای نشان دادن ورودی يا خروجی استفاده می شود.
ساختار و معماری زبان ++C
اولین باری که به یک برنامه ++C نگاه می کنید، بنظر پیچیده می آید. شکل گرامری زبان ++C مختصر می باشد و همین مختصر بودن دلیل قدرت و انعطاف این زبان می باشد.
شکل گرامری مختصر در واقع وقت بیشتری برای طراحی منطق های برنامه به ما می دهد و باعث می شود زمان کمتری برای تایپ دستورات و خواندن آنها صرف کنیم.
تمام برنامه های ++C از ساختار کلی/اساسی یکسانی پیروی می کنند. یعنی ساختار یک نرم افزار بزرگ و پیچیده برابر ساختار یک برنامه کوچک و ساده می باشد. که این اصل رو خودتون هم متوجه خواهید شد.
یک برنامه C/C++:
1- دستورات پیش پردازنده: شرطها، ضمیمه ها(include)، ماکروها...
2- اعلانات سراسری: متغیر ها، توابع، ثوابت...
3- main()
4- توابع تعریفی کاربر/برنامه نویس
برای درک بهتر این مسله به مثال زیر توجه کنید(تمامی دستورات بعداً مفصل شرح داده می شود):
Test comment. Hello.
#ifndef _XXXXX_H
#define _XXXXX_H
#else
#define _ZZZZZ_H
#endif
#if !defined _YYYYY_H
#define _YYYYY_H
#endif
#include <MyLibrary.h>
#include <MyClass.h>
#define false -1
#define number1 5
#define number2 10
#define MyDefine "test"
#define sum number1 + number2
#define MyMacroFunction(xxx) xxx * 22
//////////////////////////////////////////////////
int i= 0, j= 1000;
char c;
float f= 1;
void MyFunction(void);
int MyFunction2(int zzzzz);
//////////////////////////////////////////////////
main()
{
//...
MyFunction();
#undef MyDefine
//...
}
//////////////////////////////////////////////////
void MyFunction(void)
{
//...
}
int MyFunction2(int zzzzz)
{
//...
return(zzzzz);
{
خط 1 توضیحات/نظرات می باشد. که در مورد برنامه/خط بعدی مطالبی رو مطرح می کند. توضیحات اجباری نمی باشد و هیچگونه کار و عملیات برنامه نویسی انجام نمی دهد. فقط برای فهم و یادآوری استفاده می شود.
در هر برنامه C/C++ اولین قسمتی که کار/عملیات انجام می دهد، دستورات پیش پردازنده می باشد. که با علامت # شروع می شوند.
1- دستورات پیش پردازنده
از خط 2 تا 10 دستورات ضمیمه شرطی(منطقی)(Conditional inclusion directive) قرار دارند(پیش پردازنده هستند). عبارت ndef و عبارت !defined هر دو یکی هستند. این دستورات قبل از انجام کامپایل، بررسی و اعمال می شوند. وظیفشون این هست که موضوعاتی رو چندین بار اعلام می کنند و یا از اعلام مجدد موضوعات جلوگیری می کنند. علامت ! به معنای Not منطقی می باشد و می تواند بطور دلخواه در عبارات استفاده شود.
خط 12 و 13 شامل فایل های Header(منبع) ضمیمه شده می باشد که به کامپایلر(Compiler) می گوید قبل از شروع کامپایل آنرا در برنامه ضمیمه کن. فایل های Header معمولاً شامل توابع تعریفی کاربر، تعاریف ماکروها و API ها می باشد. هر دستور include باعث یک توقف/Pause برای کامپایلر می شود تا زمانی که محتوای فایل ضمیمه شده بدقت خوانده و پردازش شود.
خط 15 تا 18 شامل تعاریف ماکرو های ثابت و خط 19 و 20 شامل تعاریف ماکروهای تابع می باشند. هر کجا که فراخوانی شوند، محتوای ماکرو جایگزین نام ماکرو در محل فراخوانی می شود.
2- اعلانات سراسری
خط 22 تا 27 شامل اعلانات سراسری می باشد. خط 22 تا 24 اعلانات متغیر های سراسری(Global) می باشد که در سرتاسر برنامه قابل دسترسی هستند(استفاده از متغیر های سراسری پیشنهاد نمی شود).
خط 26 و 27 هم شامل اعلانات توابع سراسری می باشد که در سرتاسر برنامه قابل دسترسی هستند. تابع اولی هیچ(void) مقداری را نمی گرداند و هیچ آرماگونی را هم نمی گیرد. ولی تابع دومی(MyFunction2) مقدار عددی صحیح برمیگرداند و آرماگون عددی بلند هم می گیرد.
کامپایلر ار اطلاعاتی در اعلان تابع استفاده می کند تا درستی فراخوانی(اعلان)های تابع را کنترل نماید. بعد از اینکه آنها را Pass کرد، آنهارا فراخوانی می کند تا صحت نوع داده ها را مشخص کند. در ضمن آرماگونها و مقدار اولیه و خروجی رو هم بررسی می کند.
3- ()main
سومین قسمت اصلی هر برنامه، تابع main() است(همه برنامه ها این تابع رو دارن). اجرای برنامه از این تابع شروع می شود و معمولاً در همین تابع هم پایان می یابد(خط 29).
برخی برنامه ها ممکن است فقط یک تابع main() داشته باشند و این چیز طبیعیست. این تابع می تواند شامل فراخوانی ها، دستورات، شرط ها، حلقه ها، API ها و هر چیز ممکن در ++C باشد. در خط 33 همین تابع، یک دستور #undef قرار دارد. این دستور می تواند ماکروی تعریف شده را خنثی/نابود سازد.
4- توابع تعریفی کاربر
چهارمین قسمت اصلی هر برنامه، توابع تعریفی کاربر(user-defined function) می باشد. این توابع می توانند شامل هر دستوری باشد(مانند تابع main) و هر کاری انجام دهد.
در این مثال از خط 36 به بعد شامل این توابع می باشد. ابتدا نوع برگشتی(Return) تابع مشخص می شود. بعد نام تابع مشخص می شود. و بدنبالش آرماگون ها و آخر بدنه تابع مشخص می شود(میان دو آکولاد {}).
روند ورود متن و خروج(کامپایل) برنامه
وقتی برنامه ای را تایپ می کنید، یک فایل منبع(Source) ایجاد می کنید. یعنی صفحه ای با متونی شبیه به زبان لاتین که فقط برنامه نویس متوجه آن خواهد شد. این صفحه کاری نمی کند و کامپیوتر هم متوجه آن زبان نمی شود. باید پردازش و عملیاتی(ترجمه) انجام گیرد تا این صفحه تبدیل به زبانی شود که کامپیوتر بتواند آنرا درک کند و برنامه قابل اجرایی را تولید کند(مانند فایلهای سیستم تون).
اولین مرحله در پردازش(ایجاد برنامه)، استفاده از ویرایشگر متنی برای نوشتن کدهای ++C می باشد. شما فایل منبع(Source) را به زبان ++C که شبیه به معماری کامپیوتر هست را می نویسید(به لاتین). بعد باید آنرا به زبان و دستورالعمل های ماشینی(Machine language) تبدیل کنید. این کار بعهده کامپایلر می باشد. کامپایلر برای اینکار عملیات زیر را انجام می دهد:
(برای درک بهتر این موضوع، بر روی یک کامپایلر Open source(منبع باز/متن باز) کار کنید)
ابتدا فایل منبع(Source) خوانده می شود و به تعدادی علایم پیش پرازش(Preprocessor token)(عناصری که کامپایر می تواند با آنها کار کند. مثل عمگر ها، ثابتها، کلمات کلیدی و...) و کاراکتر های سفید(Blank)(شامل فضاهای خالی، Tab ها و Comment ها) تبدیل می شود. در این مرحله کاراکتر های ویژه(Special) تبدیل می شوند و دستورات جدا که دو یا چند خط اشغال نمودند به یکدیگر پیوند می خورند.
سپس دستورات پیش پردازنده(# دار ها) اجرا می گردند. این دستورات شامل include, define if و... می باشند. در این مرحله تمامی دستوات و ماکروها Expand می شوند و عملیات و ضمیمه های لازم انجام می گیرد.
بعد پردازش کاراکترها و رشته ها انجام می گیرد. در این مرحله برنامه برای صحت شکل گرامری(Syntax) و لغات، تجریه و تحلیل می شود(خطاها و هشدارهای Syntax در این مرحله نمایان می شود). اگر اشتباهات جدی(Fatal) پیدا نشود، یک فایل تجزیه/تحلیل شده(معمولاً با پسوند obj) تولید می گردد(تا با بقیه فایل ها ترکیب شود).
دستور پیش پردازنده include# در هر لحظه می تواند چندین فایل را داخل برنامه ادغام(Merge) کند. و هر بار که کامپایلر به این دستور برخورد می کند، به اندازه محتوایش موقتاً پردازش را متوقف(Halt) می کند(همینکار رو زبان های دیگه مثل PHP, ASP Net , Python, PERL و... انجام می دهند!).
در آخرین مرحله(ایجاد برنامه فابل اجرا)، پردازش فایل تولید شده(obj) توسط یک پیوند دهنده(Linker یا Link) انجام می شود. اکثر برنامه ها دارای رجوعاتی به روال(Routine) می باشند که در خارج از برنامه جاری وجود دارند. این روال ها باید آدرس یابی و به برنامه شما اتصال داده شوند تا بتوان با آنها کار کرد.
پیوند دهنده(Linker) تمامی فایلها را با هم ترکیب می کند و در نتیجه یک برنامه قابل اجرا تولید می شود.
تمامی این مراحل توسط کامپایلر انجام می شود. و شما فقط کد می نویسید و بعد با یک کلیک بر روی Build/Make برنامه تان را تولید می کنید(در کامپایلرهای GUI).
متغيير
ما در برنامه نويسی نياز به خانه های حافظه داريم. كه به ان هر يك از خانه هاي حافظه هاي متغيير گفته مي شود در تعريف خانه حافظه يا متغير بايد نام و نوع اطلاعاتی که در آن قرار می گيرد معين شود.
http://pnu-club.com/imported/mising.jpg
دستور فوق سه خانه حافظه با نامهای i1 وi2 وindex از نوع اعداد صحيح تعيين می کند، يعنی در هر کدام از خانه های حافظه فوق می توان يک عدد صحيح در بازه 32767 تا 32768- قرار داد. نوع داده int به دو بايت حافظه نياز دارد.
نکته :
·هر خط دستور زبان ++C به ; ختم می شود.
·برای نام گذاری خانه های حافظه فقط می توان از حروف، اعداد و ... استفاده کرد و نيز حرف اول نام يک متغير بايد يک حرف باشد. به عنوان مثال نامهای 1test و test!num و mark.1 اسامی غير مجاز می باشند.
·بين حروف نام متغير نمی توان از کاراکتر فاصله استفاده کرد.
·زبان ++C دارای تعدادی کلمات کليدی است که نمی توان از اين کلمات به عنوان نام متغير استفاده کرد. کلمات کليدی زبان ++C عبارتند از:
http://pnu-club.com/imported/mising.jpg
·زبان ++C نسبت به حروف حساس است يعنی بين حروف کوچک و بزرگ تفاوت قائل می شود. در اين زبان تمام کلمات کليدی با حروف کوچک نوشته می شوند، به عنوان مثال short يک کلمه کليدی می باشد ولی SHORT يا shoRT کلمات کليدی نيستند. توصيه می شود که تمام برنامه های اين زبان با حروف کوچک نوشته شوند.
در زبان ++C چهار نوع داده اصلی وجود دارد که عبارتند از :
1- char : اين نوع داده برای ذخيره داده های کاراکتری مانند 'a' ، '1' ، '.' به کار می رود و بازه قابل قبول آن از 128- تا 127 می باشد. در حقيقت خانه های char نيز از نوع اعداد صحيح می باشند که يک بايت طول دارند و کد اسکی کاراکتر مورد نظر را در خود حفظ می کنند. به عنوان مثال کد اسکی کاراکتر A عدد 65 می باشد.
2- int : اين نوع داده برای ذخيره اعداد صحيح مانند 1300، 32000 ، 850- به کار می رود و بازه قابل قبول آن 32768- تا 32767 می باشد.
3- float : اين نوع داده برای ذخيره اعداد اعشاری مانند 12.5241 ، 1501.3- ، 1415.1234 به کار می رود و دقت آن تا 7 رقم اعشاری می باشد.
4- double : اين نوع داده برای ذخيره سازی اعداد اعشاری بزرگ به کار می رود و دقت آن از float بيشتر می باشد.
باکلماتی مانند signed ( علامت دار) ، unsigned ( بدون علامت)، short (کوتاه) و long ( بلند) انواع داده های جديدی می توان ايجاد کرد. نوع int با هر چهار کلمه فوق می تواند مورد استفاده قرار گيرد. نوع char می تواند با signed و unsigned به کار رود و نوع double می تواند با long به کار رود. به جدول زير توجه کنيد:
http://pnu-club.com/imported/mising.jpg
گردآورنده :طه - TAHA
انواع داده ها/Data types
داده هایی(اطلاعاتی) که توسط یک برنامه استفاده می شود، توسط نوع آنها طبقه بندی می شوند. نوع یک داده بیانگر مقادیر و دامنه آن داده می باشد. داده ها اندازه و انواع مختلفی دارند و هر نوع داده برای ذخیره شدن نیاز به مقدار حافظه متفاوتی دارد.
کلیه برنامه هایی که نوشته می شوند بر روی برخی از انواع داده ها عملیاتی انجام می دهند. پس برنامه برای پردازش داده باید نوع آنها را شناسایی کند.
در زبان C سه نوع داده اصلی(اساسی) وجود دارد: Integer, Float, Character(معادل فارسی: عدد صحیح، شناور/ممیزی/اعشاری، کاراکتری). هز کدام از این نوعها شامل گونه های زیادی(ریز تری) هستند که دامنه وسعی از مقادیر را در بر می گیرند.
داده اعداد صحیح/Integer:
بیشترین نوع داده ها، عدد صحیح یا Integer می باشند. این نوع شامل داده های 9, 8, 7 ,6 ,5 ,4 ,3 ,2 ,1 ,0 , -1, -2 ,-3 ,-4 ,-5 ,-6 ,-7 ,-8 ,-9 می باشد و با کلمات کلیدی(رزرو شده) int, unsigned int, short int, long, unsigned long مشخص می شوند. تفاوت اینها در دامنه مقداری و حافظه اِشغالی می باشند:
int دامنه مقدارش از -32768 تا 32767 بوده و به 2 بایت حافظه نیاز دارد. صحیح.
unsigned int دامنه مقدارش از 0 تا 65535 بوده و به 2 بایت حافظه نیاز دارد. صحیح بدون علامت.
short int دامنه مقدارش از -32768 تا 32767 بوده و به 2 بایت حافظه نیاز دارد. صحیح کوتاه.
long دامنه مقدارش از -2147483648 تا 2144483647 بوده و به 4 بایت حافظه نیاز دارد. بلند.
unsigned long دامنه مقدارش از 0 تا 4294967295 بوده و به 4 بایت حافظه نیاز دارد. بلند بدون علامت.
توجه داشته باشید که اعداد صحیح، قسمت شناور/ممیزی/اعشاری ندارند.
داده اعداد شناور/ممیزی/اعشاری/Float:
دومین نوع داده ها، شناور/ممیزی/اعشاری یا Float می باشند. این نوع شامل داده های 9, 8, 7 ,6 ,5 ,4 ,3 ,2 ,1 ,0 , -1, -2 ,-3 ,-4 ,-5 ,-6 ,-7 ,-8 ,-9 بهمراه نقطه، ممیز، کسر، توان و... می باشد و با کلمات کلیدی(رزرو شده) float, double, long double مشخص می شوند.
تفاوت اینها هم در دامنه مقداری و حافظه اِشغالی می باشند:
float دامنه مقدارش از 3.4x10 بتوان -38 تا 3.4x10 بتوان 38 بوده و به 4 بایت حافظه نیاز دارد. شناور/ممیزی/اعشاری. تا 7 رقم دقت.
double دامنه مقدارش از 1.7x10 بتوان -308 تا 1.7x10 بتوان 308 بوده و به 8 بایت حافظه نیاز دارد. مضاعف. تا 15 رقم دقت.
long double دامنه مقدارش از 3.4x10 بتوان -4932 تا 3.4x10 بتوان 4932 بوده و به 10 بایت حافظه نیاز دارد. مضاعف بلند. تا 19 رقم دقت.
قسمت شناور/ممیزی/اعشاری و قدرمطلق دارند و به اعداد حقیقی معروفند(Real numbers).
داده کاراکتری/Char:
سومین نوع داده ها، کاراکتری یا Char می باشد. این نوع داده بیشتر از یک کاراکتر نمی تواند درخود نگه دارد(در حالت عادی). این نوع می تواند شامل همه داده ها(اعداد، حروف، علائم، Symbols و..) باشد و با کلمه کلیدی(رزرو شده) char مشخص می شود. و 1 بایت حافظه اشغال می کند.
کامپیوتر(PC) داده ها و اطلاعات رو بصورت باینری(0 و 1) در خودش ذخیره می کند. پس ذخیره سازی مستقیم یک حروف، کلمه یا علامت غیر ممکن می باشد. برای حل این مسله از یک مقدار عددی برای ذخیره داده ها استفاده می کند. یعنی نوع داده کاراکتری، باطناً یک مقدار عددی برابر با همان کاراکتر می باشد(مثل دکمه های صفحه کلید که هر کدام برای کامپیوتر یک عدد هستند).
کامپیوتر(PC) ها از کد ASCII برای نمایش داده های کاراکتری استفاده می کنند. ASCII یک کد استاندارد جهانی شناخته شده است که 128 مقدار متفاوت را در بر دارد(و نمایش می دهد). در نوع داده کاراکتری از همین ASCII ها برای تبادل اطلاعات استفاده می شود.
وقتی داده ای رو در نوع کاراکتری ذخیره می کنید همیشه 1 بیت(با بایت اشتباه نگیرید) بصورت خودکار و مخفی خالی می ماند. و این 1 بیت خالی، + یا - بودن عدد(که برابر با همان کاراکتر هست) را نشان می دهد.
متغیر ها و ثوابت(کار با داده ها)
متغیر ها:
در زبان های برنامه نویسی، برای استفاده از داده ها باید اسمی برای داده مشخص کرد. این اسم کلمه ای برای حافظه است. اسم می تواند ترکیبی از حروف(کوچک و بزرگ)، اعداد و _(یا همون خط ربط)، بطول 255 کاراکتر(در حالت معمول) باشد(اولین کاراکتر اسم نباید عدد باشد).
داده می تواند حاوی عدد، حروف، علامت، رشته، فایل و هر چیز دیگری باشد.
متغیر ها محلی برای ذخیره داده ها هستند و چون داده ها دارای نوع می باشند، متغیر ها هم باید دارای نوع باشند. و ممکن است نوع و محتوای متغیر ها در طول اجرا(یا نوشتن) برنامه توسط کاربر(یا برنامه نویس) تغییر کنند.
قبل از استفاده از متغیر ها، ابتدا باید نوع و بدنبالش اسم آنها را تعریف کرد. نوع متغیر ها مقادیری که می تواند بپذیرد و اعمالی که می تواند انجام دهد را مشخص می کند. به اصطلاح، تعیین نوع متغیر را تعریف(اعلان) متغیر می گویند.
متغیر را به دو روش تعریف می کنند:
Type Name;یا
Type Name= Value;Type نوع داده/متغیر می باشد. که با حروف کوچک نوشته می شود. و به برنامه می گوید n مقدار حافظه را برای نوع فلان مشخص کن. این نوع می تواند کلمه کلیدی(رزرو شده) int, long, float, double, unsigned int, short int, unsigned long, long double, char و... باشد.
Name اسم متغیر می باشد. این اسم میتواند ترکیبی از حروف(بزرگ و کوچک)، اعداد و _(یا همون خط ربط)، بطول 255 کاراکتر(در حالت معمول) باشد(اولین کاراکتر اسم نباید عدد باشد). مثل: test22, abc_22, a_Z, X_X_23434_XX, fff555_oiuuy و...
Value مقدار اولیه متغیر می باشد. این گزینه اختیاری می باشد. یعنی می توان مقدار اولیه ای برای متغیر مشخص نکرد. این مقدار می تواند عدد، حروف، علامت، رشته، فایل و هر نوع داده ای باشد.
در آخر تعریف متغیر یک علامت ; قرار می گیرد که به کامپایلر(Compiler) می گوید تعریف متغیر به پایان رسیده است. در صورت قرار ندادن این علامت، برنامه کامپایل نمی شود و خطا می دهد.
مثال هایی از تعریف(اعلان) متغیر:
یک متغیر از نوع عددی صحیح(int):
int x;یک متغیر از نوع عددی صحیح(int) با مقدار اولیه:
int y= 165;سه متغیر از نوع عددی صحیح(int):
کد:
int x, YYYYY, z;
یک متغیر از نوع کاراکتری(char):
char MyCharacter;دو متغیر ار نوع مضاعف(double):
double count;
double numbers= 99999;و...
وقتی برنامه با اسم متغیر برخورد می کند، ابتدا نوعش و سپس مقدارش را بررسی می کند. در آخر مقدار متغیر را جایگزین اسم متغیر می کند(در محل فراخوانی/استفاده شده) .
مقدار متغیرها را می توان مقایسه، ترکیب، جمع، تفریق، ضرب، تقسیم، کم و زیاد و... کرد که بعداً مفصل شرح داده خواهد شد.
ثابت ها:
ثوابت هم خصوصات متغیر ها رو دارند، با این تفاوت که مقادیرشون تغییر نمی کند. یعنی در تمام برنامه یک مقدار را دارند. مزایای ثوابت این است که: می توانند داده های(عدد، حروف، علامت، متن و...) کوتاه یا طولانی را در خود نگه دارند، که این در نوشتن مقادیر تکراری صرفه جویی می کند. مقادیر طولانی یا پیچیده را در سراسر برنامه در دسترس قرار می دهند(یعنی یک اسم بجای چندین مقدار در چندین محل). خطاهای گرامری/Syntax را کاهش می دهد(بدلیل نوشتن/تایپ کمتر). خواندن و درک برنامه را توسط برنامه نویس ساده تر می کند. سرعت پردازش اشکال زدایی(Debugging) را بالا می برند(چون پیش پردازنده مستقیماً مقدارش را جای بررسی مقدارش جایگزین می کند) و...
برای تعریف ثابت دو روش وجود دارد: دستور define# و دستور const.
دستور define# یک دستور پیش پردازنده و در همه جا قابل تعریف می باشد. بدان معنی که قبل از کامپایل(Compile/تولید) برنامه، خوانده و اعمال می شود. نام دیگر این نوع ثابت ماکرو می باشد. و بشکل زیر تعریف می شود:
#define Name Valuedefine# به پیش پردازنده می گوید که تعریف ماکرو آغاز می شود(با حروف کوچک نوشته می شود).
Name اسم ماکرو می باشد. این اسم می تواند ترکیبی از حروف(بزرگ و کوچک)، اعداد و _(یا همون خط ربط)، بطول 255 کاراکتر(در حالت معمول) باشد(اولین کاراکتر اسم نباید عدد باشد). معمولاً اسم ثابت ها را با حروف بزرگ مشخص می کنند.
Value مقدار ماکرو می باشد. این مقدار می تواند مانند متغیر ها حاوی هر نوع داده ای باشد.
برای تعریف مقدار ماکرو در چندین خط، می توان از علامت \ یا همون ممیز استفاده کرد.
تعریف ماکرو با علامت ; پایان نمی گیرد. اگر در تعریف ماکرو از این علامت استفاده کنید، پیش پردازنده آنرا به مقدار(Value) ماکرو اضافه می کند.
مثال هایی از تعریف ماکرو/ثابت:
#define x 25
#define IP 127.0.0.1
#define LEADER AlexAsghari
#define X_Z_H_H_Y_T_W_W 555.222.111
#define TAX 0.055
#define NoghteVirgools ;;;;;;;;;;;
#define MYNAME JohnAkabriوقتی پیش پردازنده با اسم ماکرو در هر جایی از برنامه برخورد می کند، مقدار(Value) ماکرو را جایگزین اسم ماکرو می کند.
برای نابود سازی(از بین بردن) ماکرو می توان از دستور پیش پردازنده undef# استفاده کرد. یا به اصطلاح ماکرو را به حالت تعریف نشده(Undefine) در آورد. این عمل را وقتی کارتان کلاً با ماکرو به اتمام رسید انجام دهید.
شکل کلی این دستور بصورت زیر می باشد:
#undef MacroNameundef# دستوری پیش پردازنده برای نابود سازی ماکرو می باشد.
MacroName اسم ماکروی موردنظر می باشد. این اسم باید در برنامه موجود باشد.
دستور نابود سازی ماکرو با علامت ; پایان نمی گیرد.
گردآورنده: طه - TAHA
اعمال رياضی و محاسباتی
در مبحث حافظه با انواع داده و شيوه اختصاص دادن حافظه به متغيرها آشنا شديم حال می توانيم متغيرها را در محاسبات به کار ببريم. برای نيل به اين هدف ++C عملگرهايی را در اختيار ما قرار داده است.
عملگر انتساب (=)
این عملگر به معنای تساوی نیست بلکه برای قرار دادن متغیر سمت راست تساوی در متغیر سمت چپی است یعنی عملگر تساوی جهت اختصاص دادن يک مقدار به يک متغير به کار می رود ، مانند a = 5 که عدد 5 را به متغير a تخصيص می دهد. جزئی که در سمت چپ تساوی قرار دارد همواره بايد نام يک متغير باشد، وجزء سمت راست تساوی می تواند يک عدد، يک متغير و يا ترکيبی از هر دو باشد. مانند: a=b+5 ، که در ايجا حاصل b + 5 در متغير a قرار می گيرد. توجه داشته باشيد که همواره مقدار سمت راست تساوی در مقدار سمت چپ قرار می گيرد. به دستورات زير توجه کنيد.
int a,b;
a = 10;
b = 4;
a = b;
b = 7;
اگر از دستورات فوق استفاده کنيم در نهايت مقدار a برابر 4 و مقدار b برابر 7 خواهد بود. ++C قابليتهای زيادی دارد يکی از اين قابليتها اينست که می توانيم چند دستور را در يک دستور خلاصه کنيم ، به عنوان مثال دستور :
a = 2 + (b = 5);
برابر است با:
b = 5;
a = 2 + b;
که هر دو عبارت در نهايت عدد 7 را در متغير a قرار می دهند.
ضمناً استفاده از عبارت زير نيز در ++C مجاز می باشد:
a = b = c = 5
عبارت فوق عدد 5 را به سه متغير a و b و c اختصاص می دهد.
عملگر های محاسباتی
پنج عملگر محاسباتی که قابل استفاده در زبان ++C هستند عبارتند از:
+ جمع
- تفريق
* ضرب
/ تقسيم
% باقيمانده تقسيم
تنها عملگری که ممکن است برای شما ناشناس باشد عملگر % است. اين عملگر باقيمانده تقسيم دو عدد صحيح را به ما می دهد، به عنوان مثال اگر از دستور زير استفاده کنيم:
a = 11 % 3;
متغير a حاوی عدد 2 خواهد شد. چون عدد 2 باقيمانده تقسيم 11 بر 3 می باشد.
عملگر های انتساب مرکب
عملگرهای انتسال مرکب عبارتند از =+ ، =- ، =* ، =/ ، =% .اين عملگرها دو کار را با هم انجام می دهند و در کم شدن کد نويسی به ما کمک می کنند، به جای توضيح اضافی به مثال های زير که فهم مطلب را ساده تر می کند توجه کنيد:
http://pnu-club.com/imported/mising.jpg
عملگرهای افزايش و کاهش
گونه ای ديگر از عملگرها که در کم شدن کد نويسی به ما کمک می کنند عملگر افزايش(++) و عملگر کاهش(--) می باشند. عملگر افزايش(++) يک واحد به مقدار قبلی که در متغير بود اضافه می کند و عملگر کاهش(--) يک واحد از مقدار قبلی که در متغير بود کم می کند.
++a; a++; a += 1; a = a + 1;
هر چهار دستور فوق يک واحد به مقدار قبلی متغير اضافه می کنند.
--a; a--; a -= 1; a = a - 1;
هر چهار دستور فوق يک واحد از مقدار قبلی متغير کم می کنند.
اگر از دستورات ++a و a++ به تنهايی استفاده کنيم فرقی ندارد که ++ قبل از متغير قرار گيرد يا بعد از متغير. اما اگر از ++ در کنار عملگرهای ديگر استفاده شود، اگر ++ قبل از متغير قرار گيرد ابتدا يک واحد به متغير اضافه شده سپس در محاسبه استفاده می شود، ولی اگر ++ بعد از متغير قرار گيرد ابتدا متغير در محاسبه استفاده می شود سپس يک واحد به آن اضافه می شود. همين روال برای عملگر -- نيز برقرار است. به مثال های زير توجه کنيد:
http://pnu-club.com/imported/mising.jpg
در مثال سمت چپ ابتدا يک واحد به b اضافه می شود، يعنی b مقدار 4 را می گيرد سپس عدد 4 در a قرار می گيرد؛ اما در مثال سمت راست ابتدا مقدار b يعنی عدد 3 در a قرار می گيرد سپس يک واحد به b اضافه می شود و مقدار 4 را می گيرد.
در اين مثال عدد 6 در m قرار می گيرد:
a = 2;
b = 3;
m = ++a + b--;
b مقدار 2 و a مقدار 3 را می گيرد.
حال که با انواع عملگرهای محاسباتی آشنا شديد عبارت زير را در نظر بگيريد.
QUOTE]y = 5 * 3 + 2 - 1 * 3 / 2;] مقداری که در y قرار می گيرد چه عددی می تواند باشد؟ 30 يا 24 يا 15.5 يا 17.5 . نظر شما چيست؟ شما مقدار y را چگونه حساب می کنيد؟
کامپيوتر برای بررسی و محاسبه چنين عبارتی برای اينکه با چندين جواب مواجه نشود قواعدی را در نظر می گيرد و طبق قوانين تقدم عملگرها عمل می کند. اين قوانين که مشابه قوانين جبر می باشند به ترتيب عبارتند از:
1- عملگرهايی که درون پرانتز قرار دارند اول محاسبه می شوند. در صورتی که پرانتزها تودرتو باشند ابتدا داخلی ترين پرانتز مورد بررسی و محاسبه قرار می گيرد.
2- اگر عبارتی حاوی * ، / و % باشد پس از پرانتز اين عملگرها در اولويت قرار دارند. اگر عبارتی حاوی ترکيبی از اين عملگرها باشد چون اين عملگرها در تقدم يکسانی نسبت به يکديگر قرار دارند، محاسبه به ترتيب از چپ به راست انجام می شود.
3- اعمال + و - در انتها انجام می شوند. اگر عبارتی شامل ترکيبی از اين دو عملگر باشد چون اين دو عملگر در تقدم يکسانی نسبت به هم هستند، محاسبه به ترتيب از چپ به راست انجام می شود.
با توجه به قواعد گفته شده حاصل عبارت فوق عدد 15.5 خواهد بود.
http://pnu-club.com/imported/mising.jpg
به مثال های زير توجه کنيد:
http://pnu-club.com/imported/mising.jpg
عبارات منطقی يک عبارت منطقی، عبارتی است با مقدار درست يا نادرست. به عنوان مثال 5 بزرگتر از 3 است، يک عبارت منطقی است با مقدار درست و 5 کوچکتر از 3 است، نيز يک عبارت منطقی است اما با مقدار نادرست. در کامپيوتر نتيجه عبارات منطقی درست عدد يک و نتيجه عبارات منطقی نادرست عدد صفر خواهد بود.
ضمناً کامپيوتر هر عدد مخالف صفر را به عنوان يک عبارت منطقی درست در نظر می گيرد.
عملگرهای رابطه ای
برای مقايسه دو متغير يا دو عبارت از عملگرهای رابطه ای استفاده می کنيم که همانطور که گفته شد دارای نتيجه درست يا نادرست می باشد. عملگرهای رابطه ای عبارتند از ==( مساوی )، =!( مخالف )، <(بزرگتر از )، >( کوچکتر از )، =<( بزرگتر مساوی از )، =>( کوچکتر مساوی از ). به مثال های زير توجه کنيد.
ضمناً به جای اينکه فقط از اعداد در عبارتهای رابطه ای استفاده کنيم می توانيم از عبارتهايی شامل متغيرها و يا ترکيبی از متغيرها و اعداد استفاده کنيم به عنوان مثال فرض کنيد a = 2 و b=3 و c=6 خواهيم داشت:
http://pnu-club.com/imported/mising.jpg
توجه کنيد که عملگر = همانند عملگر == نمی باشد. اولی عملگر انتساب است که مقدار سمت راست را در متغير سمت چپ قرار می دهد و ديگری عملگر رابطه ای است که برابر بودن يا نبودن دو مقدار را با هم مقايسه می کند. بنابراين در عبارت ((b=2)==a)) ما ابتدا مقدار 2 را در متغير b قرار داديم سپس آن را با a مقايسه کرديم، لذا نتيجه اين مقايسه درست بود.
عملگرهای منطقی
عملگرهای منطقی عبارتند از ! ، || و && . نتيجه عملگر ! (NOT) وقتی درست است که عبارتی که اين عملگر بر روی آن عمل می کند نادرست باشد و نتيجه هنگامی نادرست است که عملوند آن درست باشد. ضمناً اين عملگر تنها يک عملوند دارد. در حقيقت اين عملگر نقيض عملوند خود را به عنوان نتيجه می دهد.
شما برای اینکه به دستگاه بگوئید a از 5 کوچکتر و از ۱/۰ بزرگتر است نمی توانید بنویسید 5>a>ا/۰ زیرا کامپایلر متوجه نشده و پیغام خطا خواهد داد . حال شما برای فهماندن این موضوع به دستگاه باید اینگونه بنویسید: a>0.1 && a<5
که در انجا && همان معنی (و) در جمله(( a از 5 کوچکتر و از ۱/۰ بزرگتر است)) را داراست.
علامت || نیز معنی (یا) را دارد a==1 || a==2 یعنی مقدار a برابر 2 یا برابر 1 باشد.
به مثال های زير توجه کنيد:
http://pnu-club.com/imported/mising.jpg
عملگرهای &&(AND) و ||(OR) هنگامی مورد استفاده قرار می گيرند که بخواهيم از دو عبارت يک نتيجه را بدست آوريم. نتيجه اين عملگرها بستگی به ارتباط بين دو عملوندشان طبق جدول زير دارد:
http://pnu-club.com/imported/mising.jpg
به مثال های زير توجه نمائيد:
http://pnu-club.com/imported/mising.jpg
در مثال های زير به جای اعداد از متغير نيز استفاده شده است ( فرض کنيد a=1 و b=2 وc=3)
http://pnu-club.com/imported/mising.jpg
عملگر شرطی
اين عملگر يک عبارت را مورد ارزيابی قرار می دهد و براساس عبارت ارزيابی شده مقادير متفاوتی را به عنوان نتيجه بر می گرداند. ساختار اين عملگر به صورت زير می باشد:
http://pnu-club.com/imported/mising.jpg
اگر شرط برقرار باشد نتيجه 1 به عنوان خروجی خواهد بود در غير اين صورت نتيجه 2 به عنوان خروجی در نظر گرفته می شود. به مثال های زير توجه نماييد:
http://pnu-club.com/imported/mising.jpg
همانطور که در عملگرهای محاسباتی ديديم درک تقدم عملگرها، اهميت ويژه ای داشت در اينجا نيز دانستن اين تقدم از اهميت خاصی برخوردار می باشد، تقدم عملگرهای رابطه ای ، منطقی و شرطی به ترتيب عبارتند از:
1- !
2- => > =< <
3- =! ==
4- &&
5- ||
6- :?
به عنوان مثال مراحل بررسی عبارت مقابل به صورت زير می باشد:
http://pnu-club.com/imported/mising.jpg
پيشنهاد می شود برای جلوگيری از پيچيدگی فهم عبارتهای منطقی و يا محاسباتی تقدم های مورد نظر را با به کار بردن پرانتز کاملاً مشخص کنيم ، به عنوان مثال عبارت فوق را به صورت زير مورد استفاده قرار دهيم:
(((2 >= 3) && (2 == 2)) || (2 != 3))
گردآورنده :طه - TAHA
عملگرها
به علائمی که عملیاتی را بر روی داده ها انجام می دهند عملگر(Operator) می گویند. و داده هایی که بر رویشان عملیات انجام می شود را عملوند(Operand) می گویند.
مثال: X + 10
در این مثال X و 10 عملوند، و + عملگر می باشد.
عملگرها در C/C++ به چهار دسته اصلی تقسیم می شوند که عبارتند از:
1- عملگرهای محاسباتی
2- عملگرهای مقایسه
3- عملگرهای منطقی
4- عملگرهای بیتی
و عملگرهای جایگزینی/ترکیبی، جداسازی، آدرس و...
عملگرهای محاسباتی
این دسته از عملگرها، عملیات محاسباتی(ریاضیات) بر روی یک یا چند عملوند(یا داده) انجام می دهند. که عبارتند از: + - * / % ++ --
مثال جمع: X + Y یا Y+ یا X + Y + Z و...
مثال تفریق: X - Y یا X- یا X - Y - Z و...
مثال ضرب: X * Y یا X * Y * Z و...
مثال تقسیم: X / Y یا X / Y / Z و...
مثال باقیمانده(قدرمطلق): X % Y یا X % Y % Z و...
مثال افزایشی: X++ یا ++X
مثال کاهشی: X-- یا --X
ممکن است در بعضی از عملیات(عبارات) از چندین عملگر و عملوند استفاده شود، اینجاست که تقدم عملگرها برای انجام عملیات به میان می آید(از بالاترین تقدم تا پایین ترین تقدم):
++ و --
* و / و %
+ و -
عملگرهای مقایسه
همانطور که از نامش پیداست جهت مقایسه یک یا چند عملوند(داده) مورد استفاده قرار می گیرد. که عبارتند از: > < >= => == =!
مثال بزرگتر: X > Y
مثال کوچکتر: X < Y
مثال بزرگتر یا مساوی: X >= Y
مثال کوچکتر یا مساوی: X <= Y
مثال متساوی: X == Y توجه: متساوی با مساوی متفاوت می باشد.
تقدم عملگرهای مقایسه به این ترتیب می باشند(از بالاترین تقدم تا پایین ترین تقدم):
> و < و >= و =>
== و =!
عملگرهای منطقی
این عملگرها بر روی یک یا دو عبارت منطقی(بله یا خیر/درست یا نادرست...) کار می کنند. هر عبارت منطقی دارای 2 بعد می باشد. بعد نادرست که با مقدار 0 و بعد درست که با مقدار غیر 0 مشخص می شود. و عبارتند از: || && ! که به لاتین می شوند OR منطقی، AND منطقی، NOT منطقی.
مثال یا: X || Y یا X || Y || Z و...
مثال و: X && Y یا X && Y && Z و...
مثال نقیض: X!
تقدم عملگرهای منطقی به این ترتیب می باشند(از بالاترین تقدم تا پایین ترین تقدم):
!
&&
||
عملگرهای بیتی(Bitwise)
حوزه عملیات این عملگرها بر روی بیت ها می باشد(بیشترین کاربرد را در کار با سخت افزار دارد). این عملگرها با انواع داده ها(Data types) کاری ندارند و فقط برای مقدار دهی، تست، جایگزینی/انتقال(Shift) بیت ها استفاده می شوند. که عبارتند از: & | ^ ~ >> << که به لاتین می شوند AND بیتی، OR بیتی، XOR بیتی، NOT بیتی، شیفت به چپ، شیفت به راست.
تقدم عملگرهای بیتی به این ترتیب می باشند(از بالاترین تقدم تا پایین ترین تقدم):
~
>> و <<
&
^
|
دیگر عملگرها
عملگرهای جایگزینی/ترکیبی/انتساب: از ترکیب عملگرهای محاسباتی و علامت = تشکیل می شوند و پایین ترین تقدم را دارند. که عبارتند از: =+ =- =* =/ =%
مثال انتساب جمع: X+= Y که معادل X= X + Y می باشد.
مثال انتساب تفریق: X-= Y که معادل X= X - Y می باشد.
مثال انتساب ضرب: X*= Y که معادل X= X * Y می باشد.
مثال انتساب تقسیم: X/= Y که معادل X= X / Y می باشد.
مثال انتساب باقیمانده(قدرمطلق): X%= Y که معادل X= X % Y می باشد.
عملگرهای آدرس: برای دسترسی به آدرس داده ها در حافظه استفاده می شود. که عبارتند از: & *
مثال &: ;X= &Y که آدرس Y در متغیر X قرار می گیرد.
مثال *: ;X= 10* که 10 در آدرس X قرار می گیرد.
مثال *: ;Z= *X که داده های آدرس X در متغیر Z قرار می گیرد.
عملگر جداسازی: از این نوع عملگرها برای جداسازی/تقدم دهی به عبارات استفاده می شود. که عبارتند از: ( ) , معادل لاتین پرانتز و کاما.
توجه: همیشه در عبارات مرکب(چند عملگر و عملوند) ابتدا عبارات داخل پرانتز بررسی و اعمال می شوند و بعد بقیه عبارات.
مثال ) و (: X = 5 + 10 / (30 + 15) % (10 + (5 + 40)) + 85
مثال ,: X= (Y + 5, Y % 25) + 50
تقدم کلی عملگرها:
( )
~ ! ++ --
* % /
<< >>
< > =< =>
== !=
&
^
|
&&
||
= =+ =- =* =/ =%
گردآورنده :طه - TAHA
تبدیل نوع
هر داده ای که نرم افزارها استفاده می کنند دارای نوع هستند. نوع تعیین می کند داده چه محتوایی دارد و چه محتوایی می تواند بپذیرد.
مثلاً داده های نوع int حاوی عددهای صحیح و داده های نوع char حاوی کاراکتر می باشد.
وقتی داده ای از یک نوع به نوع متفاوت دیگری تغییر می کند، تبدیل نوع اتفاق می افتد. این تبدیلات به دو روش خودکار یا دستی(توسط دستورات برنامه نویسی) انجام می گیرد. تبدیلاتی که خودکار صورت می گیرند را تبدیل نوع Implicit و تبدیلاتی که دستی صورت می گیرند را تبدیل توع Explicit می نامند.
تبدیل نوع Implicit
این نوع تبدیلات معمولاً توسط کامپایلر و بیشتر در عملیات ریاضی و محاسبات انجام می گیرند. چنین تبدیلاتی باعث می شوند داده های نوع پایین تر(کم ارزش) به نوع بالاتر(پر ارزش) تبدیل گردند. فایده دیگر این نوع تبدیلات، سازگاری در بررسی عبارات ریاضی می باشد.
تبدیلات خودکار بصورت های زیر انجام می گیرند:
نوع char به نوع int: با توجه به نوع char پیشفرض، بایت آخر صفر و یا علامتش گسترده می شود.
نوع unsigned char به نوع int: بایت آخری از صفر پر می شود.
نوع signed char به نوع int: علامتش گسترده می شود.
نوع short int به نوع int: همان مقدار.
نوع unsigned short به نوع unsigned int: همان مقدار.
نوع enum به نوع int: همان مقدار.
نوع long int به نوع int: همان مقدار.
نوع float به نوع int: مقدارش کسری یا همان می شود.
نوع double به نوع float: علائم کم می شوند و مقدارش دقیق(گرد) می شود.
نوع char به نوع signed char: اگر مقدارش بیش از 127 باشد، خروجی منفی می دهد.
نوع int به نوع char: 8/24 بیت بالا(پر ارزش) از بین می رود.
نوع int به نوع short int: همان مقدار.
(در اولین مرحله تبدیل نوع، داده های نوع short, char, enum و... به اعداد صحیح تبدیل می شوند.)
داده نوع char شامل یک بایت می باشد. اما وقتی که به داده نوع int تبدیل می شود، دو بایت استفاده می گردد. یعنی مقدار بایت پایین(کم ارزش) int جدید، همان مقدار بایت اصلی char می شود و مقدار بالایی(پر ارزش) بستگی به این دارد که نوع داده char علامتدار(signed) باشد یا بدون علامت(unsigned).
اگر بدون علامت باشد، بایت بالایی(پر ارزش) داده int صفر و اگر علامتدار باشد، بایت بالایی(پر ارزش) داده int -1 می شود.
(اگر در کامپایلر، داده اصلی نوع char باشد، پردازش تبدیل به شیوه Setup کردن کامپایلر بستگی دارد.)
تبدیل نوع Explicit
این نوع تبدیل توسط دستور مبدل نوع صریح(Typecasing) صورت می گیرد. از چنین تبدیلی می توان در تبدیل انواع داده ها با انعطاف پذیری بالایی استفاده نمود:
کد:
(TypeName)Expression
(TypeName) اسم یک نوع از داده ها می باشد که داخل پرانتز نوشته می شود. این اسم می تواند int, long, float, double و... باشد.
Expression می تواند دستور، متغیر و... باشد که بعد از بسته شدن پرانتز ها قرار می گیرد.
مثال:
کد:
int i;
float f= 36.125;
i= (int)f;
// 36
float f= 32336.12454545;
printf("%i", (int)f);
// 32336
long l;
float f= 5554545.33565656565653;
l= (long)f;
printf("%d", l);
// 5554545
Type MyFunction(int i)
{
int j;
j= (int)i;
}
float z= 22323.22322;
MyFunction((int)
گردآورنده :طه - TAHA
دستورات ورودی و خروجی
واحد ورودی که ما در اينجا استفاده می کنيم صفحه کليد می باشد و واحد خروجی مورد استفاده نيز صفحه نمايش خواهد بود.
برای دريافت اطلاعات از صفحه کليد ، زبان ++C دستوری به نام cin را در اختيار ما قرار داده است، و برای ارسال اطلاعات به صفحه نمايش دستور cout موجود می باشد. توسط اين دو دستور شما می توانيد با نمايش اطلاعات بر روی صفحه نمايش و دريافت اطلاعات از صفحه کليد با کاربری که از برنامه شما استفاده می کند، در ارتباط باشيد.
دستور خروجی cout
دستور cout همراه علامت >> به کار می رود.
cout << "This is a test";
دستور فوق عبارت This is a test را بر روی صفحه نمايش چاپ می کند.
cout << 5120;
دستور فوق عدد 5120 را بر روی صفحه نمايش ظاهر می سازد.
cout << x;
دستور فوق محتويات متغير x را به صفحه نمايش می فرستد.
علامت >> با نام عملگر درج شناخته می شود و اطلاعاتی که بعد از اين علامت قرار می گيرند به واحد خروجی منتقل می شوند. در مثال های فوق يک عبارت رشته ای (This is a test) يک عدد (5120) و يک متغير (x) به واحد خروجی ارسال شدند. توجه داشته باشيد که در اولين مثال عبارت This is a test بين دو علامت (") قرار گرفت ، چون اين عبارت حاوی رشته ای از حروف می باشد؛ هرگاه که بخواهيم رشته ای از حروف را به کار ببريم بايد آنها را بين دو علامت (") قرار دهيم تا با نام متغيرها به اشتباه گرفته نشوند.
به عنوان مثال، دستور زير:
cout << " Hello";
عبارت Hello را بر روی صفحه نمايش ظاهر می سازد ولی دستور زير:
cout << Hello;
محتويات متغيری با نام Hello را بر روی صفحه نمايش چاپ می کند.
عملگر درج ممکن است بيش از يک بار در يک جمله به کار رود،
به عنوان مثال دستور زير:
cout << "Hello," << "I am" << "new in C++";
پيغام ++Hello, I am new in C را بر روی صفحه نمايش نشان می دهد.
تکرار استفاده از عملگر درج در يک دستور به ما اين امکان را می دهد که ترکيبی از متغير و رشته حروف را در کنار هم استفاده کنيم.
cout << "Hello, my code is" << code
<< "and I am" << age << "years old.";
به عنوان مثال دستور فوق با فرض اينکه متغير code حاوی عدد 116223 و متغير age حاوی عدد 16 باشد عبارت زير را در صفحه نمايش ظاهر می سازد:
Hello, my code is 116223 and I am 16 years old.
توجه داشته باشيد که دستور cout عبارات را به صورت خودکار به خط بعد منتقل نمی کند، به عنوان مثال دستورهای زير:
cout << "This is a text.";
cout << "This is another text.";
علارقم اينکه از دستور cout در دو خط استفاده شده است، به صورت زير در صفحه نمايش نشان داده خواهد شد:
This is a text. This is another text.
برای اينکه عبارتی را در چند خط نمايش دهيم، برای انتقال به هر خط جديد از علامت n\ استفاده می کنيم. به عنوان مثال دستورات زير:
cout << "First sentence.\n";
cout << "Second sentence.\n Third sentence.";
به شکل زير در صفحه نمايش ديده خواهد شد:
First sentence.
Second sentence.
Third sentence.
علاوه بر علامت n\ می توان از دستور endl برای انتقال به خط جديد استفاده کرد به عنوان مثال دستورات :
c
out << "First sentence." << endl;
cout << "Second sentence." << endl;
در صفحه نمايش به صورت زير ديده می شوند:
First sentence.
Second sentence.
دستور ورودی cin
دستور cin همراه علامت << به کار می رود.
int age;
cin >> age;
دستورات فوق ابتدا فضايی در حافظه برای متغير age در نظر می گيرند، سپس برنامه منتظر وارد کردن عددی از صفحه کليد می ماند تا عدد وارد شده را در متغير age قرار دهد. cin هنگامی قادر به دريافت اطلاعت از صفحه کليد خواهد بود که، کليد Enter بر روی صفحه کليد فشرده شود. به عنوان مثال اگر بخواهيم عدد 16 در متغير age قرار گيرد ابتدا عدد 16 را تايپ کرده سپس دکمه Enter را فشار می دهيم.
علامت >> با نام عملگر استخراج شناخته می شود، و اطلاعاتی که از واحد ورودی دريافت می شود در متغيری که بعد از اين علامت می باشد، قرار می گيرند. ضمناً شما می توانيد توسط يک دستور cin بيش از يک متغير را مقدار دهی کنيد.
به عنوان مثال دستورات زير معادل يکديگر می باشند:
cin >> a >> b;
cin >> a;
cin >> b;
گردآورنده :طه - TAHA
برنامه چاپ يک متن
در مباحث قبلی با مفاهيم حافظه و انواع داده، اعمال محاسباتی، عبارات منطقی ودستورات ورودی وخروجی آشنا شديم. با اين مقدمات می توان نوشتن اولين برنامه را آغاز کرد و با اين برنامه نحوه اجرا و ساير جزئيات را مورد بررسی قرار خواهيم داد.
//first program in C++
#include
int main ()
{
cout << "Hello, This is a C++ program.";
return 0;
}
قبل از هر گونه توضيح اضافی به شيوه نوشتن اين برنامه در ويرايشگر زبان ++C و نحوه اجرای آن می پردازيم.
برای اجرای اين برنامه شما به کامپايلر زبان ++C نياز داريد ، کامپايلر زبان ++C را که در اين دوره آموزشی مورد استفاده قرار گرفته است را می توانيد از آدرس "http://www.elearning.tehranedu.ir/c/tcp/tcp.exe (http://pnu-club.com/redirector.php?url=http%3A%2F%2Fwww.elearning.tehr anedu.ir%2Fc%2Ftcp%2Ftcp.exe)" دريافت نماييد.
پس از دانلود،نصب و اجرای کامپایلر شما محیطی برای نوشتن برنامه های خود در اختیار دارید .حال در اين محيط می توانيد برنامه ذکر شده در ابتدای اين مبحث را بنويسيد. در نوشتن برنامه دقت لازم را به کار ببريد ، چون در صورت وجود اشتباهات تايپی ممکن است اجرای برنامه با مشکل مواجه شود.
پس از اين که برنامه را نوشتيد يک بار ديگر آن را بررسی کنيد تا مطمئن شويد اشتباهی ندارد، سپس دکمه Ctrl را از صفحه کليد فشار داده و آن را نگه داريد ، سپس همزمان دکمه F9 از صفحه کليد را فشار دهيد( Ctrl + F9). با اين کار برنامه اجرا خواهد شد.
همانطور که ديديد صفحه نمايش به سرعت دوباره به صفحه ويرايشگر زبان ++C بر می گردد. برای اينکه خروجی برنامه خود را ببينيد دکمه Alt را همراه با F5 را فشار دهيد (Alt + F5) . با اين کار به محيط خروجی برنامه خواهيد رفت و پيغام:
Hello, This is a C++ program.
را در يک صفحه سياه خواهيد ديد. تبريک می گوئيم ، شما اولين برنامه خود با زبان ++C را با موفقيت به مرحله اجرا گذاشتيد؛ به همين سادگی.
اگر به ياد داشته باشيد در مبحث معرفی ساختاری زبان ++C روال رسيدن به مرحله اجرا را شش مرحله ذکر کرديم، در اينجا مرحله اول را که نوشتن برنامه در ويرايشگر بود، شما به اجرا گذاشتيد و با فشار کليد (Ctrl + F9) مراحل دوم تا ششم به صورت خودکار انجام گرفت، پس شش مرحله ذکر شده همچنان برقرار است و ما نيز نيازی نداريم خود را با جزئيات مراحل دوم تا ششم درگير کنيم.
پس برای اجرای هر برنامه کافی است برنامه را در محيط ويرايشگر زبان C++ بنويسيم سپس دکمه (Ctrl + F9) را فشار دهيم.
برنامه ای که ما در اينجا نوشتيم يکی از ساده ترين برنامه هايی است که می توانيم به زبان ++C بنويسيم ، ضمن اينکه شامل دستوراتی است که تقريباً هر برنامه ++Cبه آنها نياز دارد. در اينجا به بررسی تک به تک دستورات برنامه فوق می پردازيم.
//first program in C++
دستور فوق شامل توضيحات می باشد و تأثيری بر نحوه اجرای برنامه نخواهد داشت. هر نوشته ای که بعد از علامت // در زبان ++C قرار گيرد به عنوان توضيحات در نظر گرفته می شود. توضيحی که در اينجا مورد استفاده قرار گرفته به ما می گويد که اين اولين برنامه ما به زبان ++C می باشد. علاوه بر علامت // ، توضيحات را می توان بين */ و /* قرار داد. از شيوه جديد هنگامی استفاده می کنيم که توضيحات ما بيش از يک خط باشد.
/* This is a comment line.
This is another comment line.
*/
قرار دادن دستورات فوق در برنامه تأثيری بر خروجی ندارد و تنها توضيحاتی برای فهم بهتر برنامه می باشد.
#include
خطوطی که با علامت پوند # شروع می شوند دستوراتی برای پيش پردازنده می باشند. اين دستورات جزء خطوط اجرايی برنامه نمی باشند و نشانه هايی برای کامپايلر می باشند. در اينجا دستور فوق به پيش پردازنده می گويد که تعدادی از دستورات مورد استفاده در اين برنامه در فايل کتابخانه ای iostream.h قرار دارند. در اين مورد خاص فايل iostream.h شامل دستورات ورودی و خروجی ( مانند cin و cout) می باشد.
int main( )
اين دستور شروع بدنه اصلی برنامه را مشخص می کند. تابع main اولين جايی از برنامه است که زبان ++C شروع به اجرای آن می کند. فرقی ندارد که تابع main را در کجا مورد استفاده قرار دهيم. ابتدا وسط يا انتهای کدهای برنامه نويسی، در هر کجا که تابع main را قرار دهيم ، زبان ++C ابتدا به اين تابع مراجعه می کند. بعد از کلمه main يک جفت پرانتز ( ) قرار می دهيم، چون main يک تابع است. در زبان ++C تمام توابع دارای يک جفت پرانتز می باشند( در مبحث توابع به طور مفصل در باره نحوه ايجاد تابع و آرگومانها و ... صحبت خواهيم کرد). محتويات تابع main همانطور که در برنامه ديديد بين دو علامت { } قرار می گيرند.
cout << "Hello, This is a C++ program.";
اين دستور کار اصلی مورد نظر در اين برنامه را که چاپ عبارت داخل کوتيشن " " بر روی صفحه نمايش است را انجام می دهد. همانطور که گفته شد هنگامی که می خواهيم از دستورات ورودی و خروجی استفاده کنيم بايد در ابتدای برنامه از دستور #include استفاده کنيم. توجه داشته باشيد که بعد از هر دستور زبان ++C ملزم به استفاده از علامت ( ; ) می باشيم.
return 0;
اين دستور باعث می شود که تابع main به پايان برسد و عدد صفر را به عنوان خروجی تابع بر می گرداند. اين مرسوم ترين روش برای پايان دادن به برنامه بدون دريافت هيچگونه پيغام خطا می باشد. همانطور که در برنامه های بعدی خواهيد ديد، تقريباً همه برنامه های زبان ++C با دستوری مشابه دستور فوق به پايان می رسند.
نکته: بهتر است هر دستور زبان ++c را در يک خط جداگانه بنويسيم. البته در انجام اينکار الزامی نداريم ولی برای خوانايی بيشتر برنامه توصيه می شود از اين شيوه استفاده کنيد.
طه - TAHA: گردآورنده
برنامه جمع دو عدد
در مبحث قبلی برنامه ای را نوشتيم که در آن تنها از دستور cout استفاده شده بود و رشته ای را بر روی صفحه نمايش چاپ می کرد. برای اينکه با نحوه کاربرد متغيرها و شيوه مقدار دهی به آنها و نيز دستور cin آشنا شويد، در اينجا برنامه جديدی را می نويسيم که دو عدد را از ورودی دريافت کرده و سپس آنها را جمع نموده و حاصل را در خروجی نمايش می دهد.
// Addition program.
#include
// function main begins program execution
int main()
{
int integer1; // first number to be input by user
int integer2; // second number to be input by user
int sum; // variable in which sum will be stored
cout << "Enter first integer\n"; // prompt
cin >> integer1; // read an integer
cout << "Enter second integer\n"; // prompt
cin >> integer2; // read an integer
sum = integer1 + integer2; //assignment result to sum
cout << "Sum is " << sum << endl; // print sum
return 0; // indicate that program ended successfully
} // end function main
همانطور که در اين برنامه نيز می بينيد، تعدادی از دستورات برنامه قبلی تکرار شده اند. در اينجا به بررسی و توضيح دستورات جديد می پردازيم:
int integer1; // first number to be input by user
int integer2; // second number to be input by user
int sum; // variable in which sum will be stored
سه دستور فوق وظيفه تخصيص حافظه به سه متغير integer1 و integer2 و sum از نوع عدد صحيح را دارند. در ضمن به جای استفاده از سه دستور فوق می توانستيم از دستور زير نيز استفاده کنيم:
int integer1, integer2, sum;
نکته :
·بعضی از برنامه نويسان ترجيح می دهند که هر متغير را در يک خط تعريف کنند و توضيحات لازم را در جلوی آن بنويسند.
·متغير را می توان در هر جايی از برنامه تعريف کرد، ولی حتماً اين کار بايد قبل از اولين استفاده از متغير صورت گيرد، به عنوان مثال برنامه فوق را می توان به صورت زير نوشت:
·#include
·
·int main()
·{
· cout << "Enter first integer\n";
·
· int integer1;
· cin >> integer1;
·
· cout << "Enter second integer\n";
·
· int integer2;
· cin >> integer2;
·
· int sum;
· sum = integer1 + integer2;
·
· cout << "Sum is " << sum << endl;
·
· return 0;
·}
·اگر تعريف متغير را در بين دستورات اجرايی برنامه انجام می دهيد، يک خط خالی قبل از آن بگذاريد تا تعريف متغير مشخص باشد. اينکار به وضوح برنامه کمک می کند.
·اگر تعريف متغيرها را در ابتدای برنامه انجام می دهد، يک خط خالی بعد از آنها بگذاريد تا از دستورات اجرايی جدا شوند. اينکار نيز به وضوح برنامه و سهولت اشکال زدايی کمک می کند.
cout << "Enter first integer \n";
دستور فوق رشته Enter first integer را بر روی صفحه نمايش نشان می دهد و به ابتدای سطر جديد می رود.
cin >> integer1;
دستور فوق با وارد کردن هر عدد و فشردن کليد Enter عدد وارد شده را در متغير integer1 قرار می دهد.
cout << "Enter second integer \n";
cin >> integer2;
دو دستور فوق نيز ابتدا عبارت Enter secondinteger را بر روی صفحه نمايش چاپ کرده و سپس در خط بعد عدد وارد شده از صفحه کليد را پس از فشردن کليد Enter در متغير integer2 قرار می دهد.
sum = integer1 + integer2;
دستور فوق حاصل جمع متغيرهای integer1 و integer2 را محاسبه و نتيجه را توسط عملگر انتساب (=) در متغير sum قرار می دهد.
cout << "Sum is " << sum << endl;
و در نهايت دستور فوق باعث نمايش حاصل جمع بر وی صفحه نمايش می شود.
گردآورنده :طه - TAHA
ساختار انتخاب if
در برنامه نويسی مواردی پيش می آيد که بخواهيم دستور يا دستوراتی، هنگامی که شرط خاصی برقرار است، توسط برنامه به اجرا در آيد. اين مورد در زندگی روزمره نيز ديده می شود؛ به عنوان مثال " اگر فردا باران نيايد، من به کوه خواهم رفت." شرط مورد نظر نيامدن باران است و عملی که قرار است انجام شود رفتن به کوه می باشد. شيوه پياده سازی ساختار انتخاب if به صورت زير می باشد:
if ( شرط مورد نظر )
دستور مورد نظر ;
به مثال زير توجه کنيد:
if (x == 50)
cout << "x is 50";
اگر از دستور فوق در برنامه استفاده کنيم، اگر مقدار متغير x قبل از رسيدن به شرط فوق برابر 50 باشد عبارت "x is 50" بر روی صفحه نمايش ظاهر خواهد شد وگرنه دستور cout << "x is 50" ; ناديده گرفته می شود و برنامه خط بعدی را اجرا می کند.
توجه داشته باشيد که شرط مورد استفاده در دستور if هر عبارت منطقی می تواند باشد. در مبحث عبارات منطقی (http://pnu-club.com/redirector.php?url=http%3A%2F%2Fwww.elearning.tehr anedu.ir%2Fc%2F1-7.asp)، اينگونه عبارات و شيوه کاربرد آنها را به طور کامل بررسی کرديم.
اگر بخواهيم هنگامی که شرط برقرار می شود، بيش از يک دستور اجرا شود، بايد دستورات مورد نظر را با علامت { } دسته بندی کنيم، به مثال زير توجه کنيد:
if ( x==50 )
{
cout << "x is ";
cout << x;
}
قطعه کد فوق هنگامی که مقدار x عدد 50 باشد، عبارت "x is 50" را در صفحه نمايش چاپ می کند.
ولی در دستورات زير:
if ( x == 50)
cout << "x is ";
cout << x ;
خط آخر برنامه به هر جهت اجرا می شود. به عنوان مثال اگر فرض کنيم x برابر 50 است برنامه به درستی عبارت "x is 50" را چاپ می کند، اما اگر مثلاً x برابر 20 باشد عدد 20 بر روی صفحه نمايش ظاهر خواهد شد. چون عبارت ;cout <<x جز دستورات if قرار ندارد و يک دستور مجزا می باشد.
مورد اخير که توضيح داده شد يکی از مواردی است که بعضی از برنامه نويسان به اشتباه مرتکب آن می شوند. پس در هنگام نوشتن برنامه های خود به دسته بندی دستورات دقت کنيد.
ساختار انتخاب if/else گاهی اوقات نياز داريم که در صورت برقرار بودن شرط خاصی يک سری دستورات اجرا و در صورت برقرار نبودن شرط دسته ای ديگر از دستورات اجرا گردند. به عنوان مثال اگر فردا باران بيايد من به کوه نمی روم در غير اين صورت من به کوه خواهم رفت؛ زبان ++C برای پياده سازی چنين ساختاری شيوه زير را در اختيار ما قرار داده است.
if (شرط مورد نظر)
دستور1 ;
else
دستور2 ;
اگر شرط برقرار باشد دستور1 اجرا می گردد و در غير اين صورت دستور2 اجرا می شود. به مثال زير توجه کنيد:
if ( x = = 50 )
cout << "x is 50";
else
cout << "x is not 50";
اگر مقدار متغير قبل از رسيدن به شرط فوق برابر 50 باشد عبارت "x is 50" برروی صفحه نمايش چاپ می شود در غير اين صورت عبارت "x is not 50" چاپ می شود.
بياد داشته باشيد اگر می خواهيد از بيش از يک دستور استفاده کنيد، حتماً آنها را با { } دسته بندی نماييد. به عنوان مثال:
if ( x > 50 )
{
cout << x;
cout << "is greater than 50";
}
else
{
cout << x;
cout << "is less than 50";
}
اگر متغير x حاوی عدد 100 باشد خروجی به صورت زير می باشد:
100 is greater than 50
و اگر متغير x عدد 10 باشد خروجی به صورت زير است:
10 is less than 50
از ساختارهای if/else های تو در تو می توان برای بررسی حالتهای چندگانه استفاده کرد. برنامه زير در همين رابطه است
:
#include
int main( )
{
int x;
cout << "Please enter a number:";
cin >> x;
if ( x > 0 )
cout << x << "is positive.";
else
if ( x < 0 )
cout << x << "is negative.";
else
cout << "The number that you entered is 0.";
return 0;
}
برنامه فوق را سه بار با سه عدد مختلف اجرا می کنيم. خروجی ها به صورت زير می باشند:
Please enter a number : 10
10 is positive.
Please enter a number : -5
-5 is negative.
Please enter a number : 0
The number that you entered is 0.
نکته : برای وضوح برنامه پيشنهاد می شود همانند برنامه فوق هنگام استفاده از if يا if/else و يا ديگر ساختارهای کنترلی از تورفتگی های مناسب استفاده کنيد. يعنی به عنوان مثال دستور if را به صورت زير:
if ( x > 0 )
cout << x << "is positive.";
بنويسيم و نه به صورت زير :
if ( x > 0 )
cout << x << "is positive
گردآورنده :طه - TAHA
ساختار چند انتخابی switch
در دو مبحث قبلی ساختارهای if و if/else را بررسی کرديم. در برنامه نويسی گاهی به الگوريتمی نياز پيدا می کنيم که در آن متغيری به ازای هر مقدار صحيح ثابتی، باعث اجرای يک دستور خاص شود و به ازای هر مقدار اعمال مختلف انجام پذيرد. برای نيل به اين هدف ++C ساختار چند انتخابی switch را که به صورت زير می باشد در اختيار ما قرار داده است:
switch (عبارتی که بايد مورد بررسی قرار گيرد )
{
case مقدار ثابت 1 :
مجموعه دستورات 1
break;
case مقدار ثابت 2 :
مجموعه دستورات 2
break;
.
.
.
case n مقدار ثابت :
n مجموعه دستورات
break;
default :
مجموعه دستورات حالت پيش فرض
}
ساختار switch به شيوه زير عمل می کند:
switch ابتدا عبارت داخل پرانتز را مورد ارزيابی قرار می هد و سپس آن را با مقدار ثابت 1 مورد مقايسه قرار می دهد. اگر برابر بودند مجموعه دستورات 1 را اجرا خواهد شد، تا هنگامی که برنامه به دستور break برسد، هنگامی که برنامه به دستور break رسيد از ساختار چند انتخابی switch خارج می شود. اگر عبارت داخل پرانتز با مقدار ثابت 1 برابر نبود ساختار switch عبارت داخل پرانتز را با مقدار ثابت 2 مورد مقايسه قرار می دهد، در صورت برابر بودن مجموعه دستورات 2 اجرا می گردد. اين روال همينطور ادامه پيدا می کند. در صورتی که عبارت داخل پرانتز با هيچ يک از مقادير ثابت برابر نباشد، مجموعه دستورات حالت default (پيش فرض) اجرا می گردد. به برنامه زير توجه کنيد:
#include
int main( )
{
int x;
cout << "Please enter a number:";
cin >> x;
switch (x) {
case 1:
cout << "x is 1";
break;
case 2:
cout << "x is 2";
break;
default:
cout << "Unknown value";
}
return 0;
}
برنامه فوق را سه بار با سه عدد مختلف اجرا می کنيم. خروجی ها به صورت زير می باشند:
Please enter a number:1
x is 1
Please enter a number:2
x is 2
Please enter a number:5
Unknown value
توجه داشته باشيد که ساختار switch را می توان با ساختار if/else نيز پياده سازی کرد. به عنوان مثال ساختار switch به کار رفته در مثال فوف معادل ساختارif/elseزير می باشد:
if (x == 1)
cout << "x is 1";
else
if (x == 2)
cout << "x is 2";
else
cout << Unknown value";
ما الزامی به استفاده از حالت default در ساختار switch نداريم ولی توصيه می شود که حالت پيش فرض را به کار ببريم چون معمولاً امکان دارد که عبارت برابر با هيچ يک از مقادير ثابت نباشد و با به کار بردن حالت پيش فرض می توانيد پيغام مناسبی در اين رابطه به صفحه نمايش بفرستيد.
توجه داشته باشيد اگر دستور break بعد از هر مجموعه از دستورات استفاده نکنيم برنامه از ساختار switch خارج نخواهد شد و مجموعه دستورات بعدی اجرا می گردد تا به اولين دستور break برسد. اين مورد به ما امکان ايجاد حالتهای ترکيبی را می دهد. البته در به کار بردن اين تکنيک دقت لازم را بکنيد.
#include
int main( )
{
int x;
cout << "Please enter a number:";
cin >> x;
switch (x) {
case 1:
case 2:
case 3:
cout << "x is (1 or 2 or 3)";
break;
default:
cout << "x is not (1 or 2 or 3)";
}
return 0;
}
برنامه فوق را سه بار با سه عدد مختلف اجرا می کنيم. خروجی ها به صورت زير می باشند:
Please enter a number:1
x is (1 or 2 or 3)
Please enter a number:2
x is (1 or 2 or 3)
Please enter a number:5
x is not (1 or 2 or 3)
گردآورنده :طه - TAHA
ساختار تکرار do/while
ساختار تکرار do/while مشابه ساختار تکرار while می باشد. در ساختار تکرار while شرط حلقه در ابتدا بررسی می شود ولی در ساختار تکرار do/while شرط در انتهای حلقه مورد بررسی قرار می گيرد، بدين ترتيب در ساختار تکرار do/while دستورات حلقه حداقل يکبار اجرا خواهند شد. ساختار تکرار do/while به صورت زير می باشد:
do {
مجموعه دستورات
}while ( شرط مورد نظر );
به عنوان مثال به برنامه زير توجه نماييد:
#include
int main()
{
int counter = 1;
do {
cout << counter << " ";
}while ( ++counter <= 10 );
cout << endl;
return 0;
}
در اين برنامه اعداد 1 تا 10 با فاصله بر روی صفحه نمايش چاپ خواهند شد. دقت کنيد که متغير counter در قسمت شرط حلقه ، يک واحد اضافه می گردد سپس مقدارش با عدد 10 مقايسه می گردد.
1 2 3 4 5 6 7 8 9 10
مثال: برنامه ای بنويسيد که ليست نمرات يک کلاس را دريافت کرده و تعداد قبولی ها و مردودی ها را مشخص کند. ضمنا در ابتدای برنامه تعداد نمرات ليست پرسيده شود.
#include
int main( )
{
float mark;
int howmany,counter=1;
int passes=0,failures=0;
cout << "How many marks : ";
cin >> howmany;
do {
cout << "Enter mark "<<<" : ?; cin>>mark;
if (mark>=10)
++passes;
else
++failures;
}while (++counter <= howmany);
cout<<"Passed : "<<
cout<<"Failed : "<<
return 0;
}
خروجی برنامه به صورت زير می باشد :
How many marks : 10
Enter mark 1 : 18
Enter mark 2 : 15
Enter mark 3 : 9
Enter mark 4 : 17.5
Enter mark 5 : 9.75
Enter mark 6 : 8
Enter mark 7 : 11
Enter mark 8 : 13
Enter mark 9 : 5
Enter mark 10 : 13
Passed : 6
Failed : 4
گردآورنده :طه - TAHA
ساختار تکرار for
ساختار تکرار for نيز مانند دو ساختار قبلی يک حلقه تکرار می سازد. از ساختار تکرار for معمولاً هنگامی که دفعات تکرار حلقه براساس يک شمارنده می باشد استفاده می شود. ساختار تکرار for به صورت زير می باشد:
for ( افزايش يا کاهش ; شرط حلقه ; تعريف متغير )
مقدار شمارنده شمارنده و تعيين
مقدار اوليه
{
مجموعه دستورات
}
ساختار تکرار for را با ساختار تکرار while نيز می توان پياده سازی کرد به عنوان مثال دو برنامه زير اعداد 1 تا 5 را بر روی صفحه نمايش چاپ می کنند:
#include
int main()
{
int counter = 1;
while ( counter <= 5 ) {
cout << counter << endl;
++counter;
}
return 0;
}
برنامه فوق با حلقه while نوشته شده بود. در برنامه زير معادل حلقه while فوق را با حلقه for پياده سازی می کنيم:
#include
int main()
{
for ( int counter = 1; counter <= 5; counter++ )
cout << counter << endl;
return 0;
}
در برنامه فوق هنگامی که دستور for اجرا می شود متغير کنترلی counter تعريف می گردد و عدد 1 در آن قرار می گيرد. سپس شرط حلقه مورد بررسی قرار می گيرد (counter<=5) چون مقدار counter ، عدد 1 می باشد پس شرط درست است و دستور حلقه، يعنی دستور cout اجرا می گردد و اولين عدد يعنی 1 نمايش داده می شود. پس از آن دستور ++counter اجرا می گردد و مقدار متغير counter يک واحد اضافه می شود. سپس مجدداً شرط حلقه بررسی و در صورت برقرار بودن شرط دستور cout اجرا می گردد. اين روال تا وقتی که شرط برقرار باشد ادامه می يابد و به محض برقرار نبودن شرط يعنی هنگامی که counter حاوی عدد 6 شود خاتمه می يابد و برنامه به پايان می رسد.
1 2 3 4 5
در برنامه قبلی اگر حلقه for را به صورت زير بازنويسی کنيم:
for(int counter=10; counter>=1; counter=counter-2)
خروجی برنامه اعداد زوج 10 تا 1 به صورت معکوس می باشد، يعنی :
10 8 6 4 2
توجه داشته باشيد که در حلقه فوق به جای استفاده از دستور counter=counter-1 می توانستيم از دستور counter -= 2 استفاده کنيم.
مثال : برنامه ای بنويسيد که مجموع اعداد زوج 1 تا 100 را محاسبه کند.
#include
int main ( )
{ int sum = 0;
for (int num = 2; num <= 100; num += 2)
sum += num;
cout << "2 + 4 + 6 + ... + 100 =" <<
return 0;
}
2 + 4 + 6 + ... + 100 =2550
توجه داشته باشيد که حلقه for در برنامه فوق را با کمک عملگر کاما ( , ) می توانيم به صورت زير نيز بنويسيم:
for (int num = 2;
num <= 100;
sum += num, num +=2);
ضمناً شکستن حلقه به چند خط نيز مشکلی ايجاد نمی کند. البته دو مورد اخير توصيه نمی شوند، چون از خوانايی برنامه می کاهند.
مثال : برنامه ای بنويسيد که عددی را از ورودی دريافت کرده و 2 به توان آن عدد را محاسبه و در خروجی چاپ نمايد.
#include
int main( )
{
unsigned long int x=1;
int power;
cout << "Enter power:";
cin >>power;
for (int counter=1;counter<=power;counter++)
x*=2;
cout << "2 ^ " << power << " = " << x <
return 0;
}
Enter power:25
2 ^ 25 = 33554432
در مثال های فوق، دستورات حلقه for را داخل { } قرار نداديم چون حلقه for تنها شامل يک دستور بود، توجه داشته باشيد که اگر بيش از يک دستور در حلقه به کار رود ملزم به استفاده از { } می باشيم.
مثال : برنامه ای بنويسيد که جدول ضرب 5X5 را ايجاد کند.
#include
int main( )
{
for (int x=1;x<=5;x++)
{
for (int y=1;y<=5;y++)
cout <<<"\t";
cout<
}
return 0;
}
خروجی برنامه به صورت زير خواهد بود:
1 2 3 4 5
2 4 6 8 10
3 6 9 12 15
4 8 12 16 20
5 10 15 20 25
در برنامه فوق حلقه شامل متغير x ، دارای دو دستور for و cout بود، به همين علت از { } استفاده شد. اما حلقه شامل متغير y تنها دارای يک دستور cout بود. اگر دقت کرده باشيد دستور ;"cout<<x*y<<"\t دارای علامت t\ بود. به کار بردن t\ باعث جدول بندی و مرتب شدن خروجی می شود. در حقيقت مکان نمای صفحه نمايش را در محل جدول بندی قرار می دهد. ضمناً در مثال فوق يک ساختار for در دل ساختار for ديگری استفاده شد به اين شيوه استفاده حلقه های تودرتو گفته می شود که در برنامه نويسی ها به کرات از آنها استفاده می شود. در ضمن توجه داشته باشيد که اگر از دستور ;cout <<endl استفاده نشود، خروجی به صورت نا مرتب زير خواهد بود:
1 2 3 4 5 2 4 6 8 10
3 6 9 12 15 4 8 12 16 20
5 10 15 20 25
نکته : در حلقه های تکرار ممکن است شرط حلقه را به اشتباه بنويسيم يا به عنوان مثال شمارنده حلقه را افزايش ندهيم در چنين حالاتی ممکن است پس از اجرای برنامه، برنامه به اتمام نرسد و حلقه همچنان تکرار شود. در صورت بروز چنين مشکلی با فشردن کليد Ctrl همراه با Break (Ctrl+Break) اجرای برنامه به صورت ناگهانی قطع می شود و به محيط ويرايشگر ++C باز می گرديد و می توانيد کد اشتباه را درست کنيد. سپس برنامه را مجدداً اجرا کنيد.
گردآورنده :طه - TAHA
توابع بازگشتی
برنامه هايی که تا کنون نوشتيم يک تابع، تابع ديگری را فراخوانی می کرد. در برنامه نويسی ممکن است نياز پيدا کنيم که تابعی خودش را به صورت مستقيم يا غير مستقيم فراخوانی کند. به چنين توابعی، توابع بازگشتی گفته می شود . ابتدا از ديد رياضياتی توابع بازگشتی را بررسی می کنيم. دنباله اعداد زير را در نظر بگيريد :
2 , 5 , 11 , 23 , ...
جمله پنجم دنباله اعداد فوق چه عددی می باشد؟ حدس شما چيست؟ اگر کمی دقت کنيد متوجه خواهيد شد که هر جمله از دنباله فوق برابر است با دو برابر جمله قبلی بعلاوه يک. پس جمله پنجم برابر است با 2*23+1=47 دنباله فوق را توسط فرمول زير نيز می توان مشخص کرد :
d1 = 2
dn = 2*dn-1+1
همانطور که متوجه شده ايد در اين دنباله هر جمله به جملات قبلی خود وابسته است و برای بدست آوردن آن نياز به بازگشت روی جملات قبلی داريم تا اينکه سرانجام به جمله اول که عدد 2 می باشد برسيم. فرمول فوق را به صورت تابعی زير بازنويسی می کنيم :
d(1) = 2
d(n) = 2*d(n-1)+1
همانطور که در تابع فوق می بينيد يک حالت پايه وجود دارد که همان d(1)=2 می باشد و يکه حالت بازگشتی که تابع با يک واحد کمتر دوباره فراخوانی می شود d(n) = 2*d(n-1)+1 . توابع بازگشتی به طور کلی دارای يک يا چند حالت پايه و يک بخش بازگشتی می باشند. که معمولاً در بخش بازگشتی تابع با مقداری کمتر مجدداً فراخوانی می شود. تابع بازگشتی فوق به زبان ++C به صورت زير می باشد :
long int d(long int n)
{
if (n == 1)
return 2;
else
return 2*d(n-1)+1;
}
در زير برنامه ای می نويسيم تا با استفاده از تابع فوق 20 جمله اول دنباله مذکور را نمايش دهد.
#include <iostream.h>
long int d(long int);
int main( )
{
for (int i=1;i<=20;i++)
{
cout<<d(i)<<"\t";
if (i%5==0) cout<<endl;
}
return 0;
}
long int d(long int n)
{
if (n == 1)
return 2;
else
return 2*d(n-1)+1;
}
2 5 11 23 47
95 191 383 767 1535
3071 6143 12287 24575 49151
98303 196607 393215 786431 1572863
تابع، بازگشت را تا رسيدن به حالت پايه ادامه می دهد و به محض رسيدن به حالت پايه محاسبات بازگشتی پی در پی موجب رسيدن به جواب مورد نظر می شود.
مسئله برجهای هانوی (Towers of Hanoi)
http://pnu-club.com/imported/2009/09/223.gif
هر برنامه نويسی بايد به نحوی با مسائل کلاسيک دست وپنجه نرم کرده باشد . يکی از معروفترين مسائل کلاسيک ، مسئله برجهای هانوی می باشد. طبق افسانه ای در معبدی در شرق دور، کاهنان معبدی تعدادی ديسک را از يک ستون به ستون ديگر جا به جا می کردند . ستون اول در ابتدا دارای 64 ديسک با اندازه های مختلف می باشد، که بزرگترين ديسک در پايين ستون و کوچکترين ديسک در بالای ستون قرار دارد. کاهنان بايد همه ديسکها را از يک ستون به ستون دوم منتقل می کردند. با اين شرط که در هر بار جا به جايی تنها يک ديسک منتقل شود و نيز ديسک بزرگتری روی ديسک کوچکتر قرار نگيرد. ضمناً ستون سومی به عنوان ستون کمکی در اختيار آنها می باشد. گويند هنگامی که کاهنان معبد همه 64 ديسک را با روش گفته شده از ستون اول به ستون دوم منتقل کنند جهان به پايان می رسد.
برای راحتی کار کاهنان و برای اينکه دچار اشتباه و دوباره کاری در انتقال نشوند می خواهيم برنامه ای بنويسيم که ترتيب انتقال ديسکها را چاپ کند.
برای نوشتن اين برنامه ، مسئله را بايد با ديد بازگشتی نگاه کنيم . انتقال n ديسک را به شيوه زير انجام می دهيم :
1- ابتدا n-1 ديسک را از ستون اول به ستون دوم به کمک ستون سوم منتقل کن.
2- ديسک آخر (بزرگترين ديسک) را از ستون اول به ستون سوم منتقل کن.
3- n-1 ديسک قرار گرفته در ستون دوم را به کمک ستون اول به ستون سوم منتقل کن.
مراحل انجام کار هنگام انتقال آخرين ديسک يعنی وقتی که n=1 می باشد، يعنی حالت پايه به اتمام می رسد. در حالت n=1 يک ديسک بدون کمک ستون کمکی به ستون ديگر منتقل می شود.
تابع بازگشتی مورد استفاده برای حل مسئله برجهای هانوی را با چهار آرگومان می نويسيم.
1- تعداد ديسکها
2- ستون مبدأ
3- ستون کمکی
4- ستون مقصد
تابع هانوی و برنامه ای که در آن اين تابع مورد استفاده قرار گرفته است به صورت زير می باشد :
#include <iostream.h>
int hanoi(int, char, char, char);
int main( )
{ int disks;
cout<<"Moving disks form tower A to C."<<endl;
cout<<"How many disks do you want to move?";
cin>>disks;
cout<<hanoi(disks,'A','B','C')<<endl;
return 0;
}
int hanoi(int n, char first, char help, char second)
{
if (n == 1) {
cout << "Disk " << n << " from tower " << first
<< " to tower " << second << endl;
}
else {
hanoi(n-1, first, second, help);
cout << "Disk " << n << " from tower " << first
<< " to tower " << second << endl;
hanoi(n-1, help, first, second);
}
return 0;
}
خروجی برنامه با فرض اينکه می خواهيم مراحل انتقال چهار ديسک را ببينيم به صورت زير می باشد :
Moving disks form tower A to C.
How many disks do you want to move?4
Disk 1 from tower A to tower B
Disk 2 from tower A to tower C
Disk 1 from tower B to tower C
Disk 3 from tower A to tower B
Disk 1 from tower C to tower A
Disk 2 from tower C to tower B
Disk 1 from tower A to tower B
Disk 4 from tower A to tower C
Disk 1 from tower B to tower C
Disk 2 from tower B to tower A
Disk 1 from tower C to tower A
Disk 3 from tower B to tower C
Disk 1 from tower A to tower B
Disk 2 from tower A to tower C
Disk 1 from tower B to tower C
0
روال فراخوانی تابع هانوی به صورت شکل زير می باشد:
http://pnu-club.com/imported/2009/09/3885.jpg
گردآورنده :طه - TAHA
توليد اعداد تصادفی
يکی از کاربردهای اساسی کامپيوتر، استفاده از آن در کارهای شبيه سازی می باشد. در اينجا به بررسی نحوه توليد اعداد تصادفی می پردازيم. اعداد تصادفی در مسائل شبيه سازی کاربرد فراوانی دارند، به عنوان مثال شبيه سازی پرتاب سکه، پرتاب تاس و مسائلی از اين قبيل.
برای توليد اعداد تصادفی زبان ++C تابعی با نام rand() را که در فايل کتابخانه ای stdlib.h قرار دارد، در اختيار ما گذاشته است. به عنوان مثال دستور زير :
i = rand();
يک عدد تصادفی بين 1 تا 32767 را در متغير i قرار می دهد . تابعrand()اعداد را با احتمال مساوی در اين بازه انتخاب می کند پس شانس انتخاب هر عددی در اين بازه با اعداد ديگر برابر است.
معمولاً بازه اعدادی که توسط تابع rand توليد می شود، با آنچه که مورد نياز ماست متفاوت می باشد. به عنوان مثال برای شبيه سازی پرتاب سکه به دو عدد تصادفی و برای تاس به شش عدد تصادفی نياز داريم. فرض کنيد که می خواهيد عدد 31250 را به عددی بين 1 تا 6 تبديل کنيد. چه راه کاری را در نظر می گيريد؟ راهی که برای اين تبديل وجود دارد استفاده از باقيمانده صحيح می باشد، همانطور که می دانيد باقيمانده صحيح تقسيم هر عددی بر 6 يکی از اعداد 0 تا 5 می باشد. پس با اضافه کردن 1 واحد به باقيمانده ، عددی بين 1 تا 6 خواهيم داشت.
حال اگر به جای متغير a ، تابع rand() را قرار دهيم عبارت rand()%6+1 عددی تصادفی بين 1 تا 6 به ما می دهد به طور کلی برای بدست آوردن عددی تصادفی در بازه [a,b] می توانيم از فرمول زير استفاده کنيم.
rand()%(b-a+1)+a
به عنوان مثال خروجی قطعه برنامه زير عدد صحيحی در بازه [20,100] می باشد.
int a = 20 , b = 100;
cout<< rand()%(b-a+1)+a;
برنامه زير 20 عدد تصادفی بين 1 تا 6 را ايجاد می کند. که اين برنامه را می توان 20 بار پرتاب يک تاس در نظر گرفت :
#include <iostream.h>
#include <stdlib.h>
int main()
{
for (int i = 1; i<= 20; i++ )
{
cout << rand() % 6 + 1<<"\t";
if ( i % 5 == 0 )
cout << endl;
}
return 0;
}
خروجی برنامه فوق به صورت زير می باشد :
5 5 3 5 5
2 4 2 5 5
5 3 2 2 1
5 1 4 6 4
يک بار ديگر برنامه فوق را اجرا کنيد و خروجی را مجدداً بررسی کنيد. خواهيد ديد خروجی دقيقاً همان اعداد قبلی می باشد. خروجی تابع rand() اعداد تصادفی می باشد ولی با اجرای دوباره برنامه همان اعداد مجدداً به همان ترتيب قبلی تکرار می شوند. اين تکرار يکی از قابليتهای تابع می باشد ودر اشکال زدايی برنامه کاربرد دارد.
اگر بخواهيم که تابع rand() اعداد کاملاً تصادفی ايجاد کند بايد از تابع srand() استفاده کنيم. اين تابع ورودی از نوع اعداد صحيح بدون علامت می گيرد و باعث تصادفی شدن تابع rand() بر اساس مقدار ورودی تابع srand() می شود. تابعsrand() نيز در فايل کتابخانه ای stdlib.h قرار دارد. در برنامه زير به نحوه استفاده از تابع srand() پی خواهيد برد.
#include <iostream.h>
#include <stdlib.h>
int main()
{
unsigned int num;
cout<<"Enter a number: ";
cin>>num;
srand(num);
for (int i = 1; i<= 20; i++ )
{
cout << rand() % 6 + 1<<"\t";
if ( i % 5 == 0 )
cout << endl;
}
return 0;
}
خروجی برنامه به صورت زير می باشد.
Enter a number: 251
3 4 1 4 6
6 4 6 2 5
5 3 1 4 5
1 6 6 6 1
Enter a number: 350
1 4 3 4 1
2 6 2 6 2
4 2 5 3 5
4 4 5 2 3
Enter a number: 251
3 4 1 4 6
6 4 6 2 5
5 3 1 4 5
1 6 6 6 1
همانطور که می بينيد بر اساس ورودی های مختلف خروجی نيز تغيير می کند. توجه داشته باشيد که ورودی های يکسان خروجی های يکسانی دارند.
اگر بخواهيم بدون نياز به وارد کردن عددی توسط کاربر، اعداد تصادفی داشته باشيم می توانيم از تابع time که در فايل کتابخانه ای time.h قرار دارد استفاده کنيم . تابع time ساعت کامپيوتر را می خواند و زمان را بر حسب ثانيه بر می گرداند ، به اين ترتيب دستور زير:
srand(time(0));
باعث می شود که تابع rand() در هر بار اجرای برنامه اعداد متفاوتی را ايجاد کند. اگر برنامه فوق را به صورت زير باز نويسی کنيم با هر بار اجرای برنامه اعداد تصادفی متفاوتی خواهيم داشت.
مثال : برنامه ای بنويسيد که پرتاب سکه ای را شبيه سازی کند ، بدين صورت که سکه را 2000 بار پرتاب کند و دفعات رو يا پشت آمدن سکه را چاپ کند.
#include <iostream.h>
#include <stdlib.h>
#include <time.h>
int main()
{
int back=0,front=0,face;
srand(time(0));
for (int i = 1; i<= 2000; i++ )
{
face=rand()%2+1;
switch(face)
{
case 1:
++back;
break;
case 2:
++front;
break;
default:
cout<<"Error!";
}
}
cout<<"Front: "<< front<<endl;
cout<<"Back : "<< back<<endl;
return 0;
}
گردآورنده :طه - TAHA
نوع داده ای enum
enum يک نوع داده ای تعريف شده توسط برنامه نويس را که به آن نوع داده شمارش می گويند، ايجاد می کند. نحوه ايجاد يک نوع داده شمارش به صورت زير می باشد.
enum {ثابت n و ... و ثابت 2 و ثابت 1} نام نوع داده
اين دستور به ترتيب در ثابت 1 ، ثابت 2 و ... و ثابتn اعداد صحيح متوالی 0 تا n را قرار می دهد . به صورت پيش فرض مقداردهی متغيرها در اين دستور از صفر شروع می شود.
enum TrueFalse {FALSE , TRUE}
دستور فوق به ثابت FALSE ، عدد صفر و به ثابت TRUE عدد 1 را تخصيص می دهد. حال اگر بخواهيم مقداردهی از عددی غير از صفر شروع شود بايد عدد مورد نظر را مشخص کنيم :
enum Days {SAT = 1, SUN, MON, TUE, WED, THU, FRI}
دستور فوق به روزهای هفته به ترتيب اعداد 1 تا 7 را نسبت می دهد. توصيه می شود که نام ثابت های شمارشی را با حروف بزرگ بنويسيد ، بدين صورت اين ثابتها با متغيرهای برنامه ، اشتباه نمی شوند. ضمناً enum را در ابتدای برنامه به کار ببريد.
در حقيقت اين نوع داده به هر يک از موارد ليستی از اعداد نامی را نسبت می دهد. به عنوان نمونه در مثال روزهای هفته هر يک از اعداد 1 تا 7 را با يکی از روزهای هفته نام گذاری کرديم.
مقدار دهی موارد ليست به صورت های مختلف امکان پذير می باشد.
enum Days { MON, TUE, WED, THU, FRI, SAT , SUN = 0}
دستور فوق SUN را با عدد صفر و SAT را با عدد 1- و ... و MON را با عدد -6 مقدار دهی می کند.
enum Colors {BLACK = 2, GREEN = 4, RED = 3,
BLUE = 5, GRAY,WHITE = 0}
در دستور فوق هر يک از موارد با عدد نسبت داده شده مقدار دهی می شوند و GRAY با عدد 6 مقدار دهی می شود چون بعد از BLUE = 5 آمده است.
به محض ساخته شدن ليست ، نوع داده نوشته شده توسط برنامه نويس قابل استفاده می گردد و می توان متغيرهايی را از نوع داده نوشته شده توسط برنامه نويس به همان شيوه ای که ساير متغيرها را تعريف می کرديم، تعريف کرد. به عنوان مثال :
TrueFalse tf1,tf2;
Days day1, day2 = SUN;
Colors color1 = BLACK , color2 = GRAY;
همچنين متغيرها را می توان هنگام ايجاد نوع داده، تعريف کرد. به عنوان مثال :
TrueFalse {FALSE, TRUE} tf1 ,tf2;
نکته : تبديل داده ای از نوع enum به عدد صحيح مجاز می باشد ولی بر عکس اين عمل غير مجاز است. به عنوان مثال :
enum MyEnum {ALPHA, BETA, GAMMA};
int i = BETA;
int j = 3+GAMMA;
دستورات فوق مجاز می باشند، و اين دستورات عدد 1 را در i و 5 را در j قرار می دهند.
enum MyEnum {ALPHA, BETA, GAMMA};
MyEnum x = 2;
MyEnum y = 123;
ولی دستورات فوق غير مجاز می باشند. البته بعضی از کامپايلرها اين موضوع را ناديده می گيرند و تنها يک پيغام اخطار می دهند ولی توصيه می شود که برای پيشگيری از وقوع خطاهای منطقی در برنامه از به کار بردن دستوراتی مانند کدهای فوق خودداری کنيد.
برنامه زير نحوه کاربرد نوع داده enum را نشان می دهد.
#include <iostream.h>
int main()
{
enum PizzaSize{SMALL,MEDIUM,LARGE,EXTRALARGE};
PizzaSize size;
size=LARGE;
cout<<"The small pizza has a value of "<<SMALL;
cout<<"\nThe medium pizza has a value of "<<MEDIUM;
cout<<"\nThe large pizza has a value of "<<size;
return 0;
}
خروجی برنامه به صورت زير می باشد:
The small pizza has a value of 0
The medium pizza has a value of 1
The large pizza has a value of 2
گردآورنده :طه - TAHA
توابع بدون خروجی و آرگومان
در برنامه نويسی به توابعی نياز پيدا می کنيم که نياز ندارند چيزی را به عنوان خروجی تابع برگردانند و يا توابعی که نياز به آرگومان و ورودی ندارند ويا هر دو. زبان ++C برای امکان استفاده از چنين توابعی، کلمه void را در اختيار ما قرار داده است. اگر بخواهيم تابعی بدون خروجی ايجاد کنيم کافی است به جای نوع داده خروجی تابع کلمه void را قرار دهيم. به تابع زير توجه کنيد.
void function (int num)
{
cout << "My input is" << num << endl;
}
همانطور که می بينيد اين تابع نيازی به استفاده از دستور return ندارد چون قرار نيست چيزی را به عنوان خروجی تابع برگرداند. تابع فوق بر اساس مقدار داده ورودی، پيغامی را بر روی صفحه نمايش چاپ می کند.
حال که با void آشنا شديد می توانيم از اين به بعد تابع main را از نوع void تعريف کنيم. در اين صورت ديگر نيازی به استفاده از دستور return 0;در انتهای برنامه نداريم :
void main()
{
دستورات برنامه
}
به عنوان مثال برنامه برج هانوی را که در مبحث توابع بازگشتی نوشتيم با استفاده از نوع void بازنويسی می کنيم.
#include <iostream.h>
void hanoi(int, char, char, char);
void main( )
{
cout<<"Moving 4 disks form tower A to C."<<endl;
hanoi(4,'A','B','C');
}
void hanoi(int n, char first, char help, char second) {
if (n == 1) {
cout << "Disk " << n << " from tower " << first
<< " to tower " << second << endl;
} else {
hanoi(n-1, first, second, help);
cout << "Disk " << n << " from tower " << first
<< " to tower " << second << endl;
hanoi(n-1, help, first, second);
}
}
همانطور که در برنامه فوق می بينيد تابع hanoi بدون دستور return نوشته شده است، زيرا نوع تابع void می باشد، يعنی تابع بدون خروجی است و توابع بدون خروجی را می توانيم مستقيماً همانند برنامه فوق فراخوانی کنيد. يعنی کافی است نام تابع را همراه آرگومانهای مورد نظر بنويسيم.
برای ايجاد توابع بدون آرگومان می توانيد در پرانتز تابع کلمه void را بنويسيد يا اينکه اين پرانتز را خالی گذاشته و در آن چيزی ننويسيد.
void function1();
int function2(void);
در دو دستور فوق تابع function1 از نوع توابع بدون خروجی و بدون آرگومان ايجاد می شود. و تابع function2 از نوع توابع بدون آرگومان و با خروجی از نوع عدد صحيح می باشد، برای آشنايی با نحوه کاربرد توابع بدون آرگومان به برنامه زير توجه کنيد :
#include <iostream.h>
int function(void);
void main( )
{
int num, counter = 0;
float average, sum = 0;
num=function();
while (num != -1){
sum += num ;
++counter;
num=function();
}
if (counter != 0){
average = sum / counter;
cout << "The average is " << average << endl;
}
else
cout << "No numbers were entered." << endl;
}
int function(void){
int x;
cout << "Enter a number (-1 to end):";
cin >>x;
return x;
}
همانطور که در برنامه فوق مشاهده می کنيد تابع function از نوع توابع بدون آرگومان می باشد و دارای خروجی صحيح می باشد. اين تابع در برنامه دو بار فراخوانی شده است و وظيفه اين تابع دريافت متغيری از صفحه کليد و برگرداندن آن متغير به عنوان خروجی تابع می باشدو دستور num=function() عدد دريافت شده از صفحه کليد را در متغير num قرار می دهد اگر به ياد داشته باشيد اين برنامه قبلاً بدون استفاده از تابع در مبحث ساختار تکرار while (http://pnu-club.com/redirector.php?url=http%3A%2F%2Fwww.elearning.tehr anedu.ir%2Fc%2F2-4.asp) نوشته بوديم. برای درک بهتر اين برنامه توصيه می شود آن را با برنامه موجود در مبحث ساختار تکرار while (http://pnu-club.com/redirector.php?url=http%3A%2F%2Fwww.elearning.tehr anedu.ir%2Fc%2F2-4.asp) مقايسه کنيد، و متوجه خواهيد شد که تابع function ما را از دوباره نويسی بعضی از دستورات بی نياز کرده است و نيز برنامه خلاصه تر و مفهوم تر شده است.
ادامه دارد..
قوانين حوزه
قسمتی از برنامه که در آن متغيری تعريف شده و قابل استفاده می باشد، حوزه آن متغير گفته می شود. در زبان ++C به قسمتی از برنامه که با يک علامت ( } ) شروع شده و با علامت ( { ) به پايان می رسد يک بلوک می گويند. به عنوان مثال هنگامی که متغيری را در يک بلوک تعريف می کنيم، متغير فقط در آن بلوک قابل دسترسی می باشد ولذا حوزه آن متغير بلوکی که در آن تعريف شده است ، می باشد. به مثال زير توجه کنيد :
#include <iostream.h>
void main( )
{
{
int x= 1;
cout << x;
}
cout << x;
}
اگر برنامه فوق را بنويسيم و بخواهيم اجرا کنيم پيغام خطای Undefined symbol 'x' را دريافت خواهيم کرد ودليل اين امر اين است که متغير x فقط در بلوک درونی تابع main تعريف شده است، لذا در خود تابع قابل دسترسی نمی باشد. در اين مبحث به بررسی حوزه تابع، حوزه فايل و حوزه بلوک می پردازيم.
متغیری که خارج از همه توابع تعریف می شود، دارای حوزه فایل می باشد و چنین متغیری برای تمام توابع، شناخته شده وقابل استفاده می باشد. به مثال زیر توجه کنید:
#include <iostream.h>
int x=1;
int f();
void main( )
{
cout << x;
cout << f();
cout << x;
}
int f(){
return 2*x;
}
متغیر x دارای حوزه فایل می باشد. لذا در تابع main و تابع f قابل استفاده می باشد. خروجی برنامه فوق به صورت زير می باشد.
121
متغیری که درون توابع و یا به عنوان آرگومان تابع تعریف می گردد، دارای حوزه تابع می باشد و از نوع متغیرهای محلی است و خارج ازتابع قابل استفاده و دسترسی نمی باشد. توابعی که تا کنون نوشتیم ومتغیرهایی که در آن ها تعریف کردیم، همگی دارای حوزه تابع بودند. ضمنا این متغیرها، هنگامی که برنامه از آن تابع خارج می شود، مقادیر خود را از دست می دهند. حال اگر بخواهیم یک متغیر محلی تابع، مقدار خود را حفظ کرده و برای دفعات بعدی فراخوانی تابع نیز نگه دارد، زبان ++c کلمه static را در اختیار ما قرار داده است. کلمه static را باید قبل از نوع متغیر قرار دهیم. مانند:
static int x=1;
دستور فوق متغیر x را از نوع عدد صحیح تعریف می کند و این متغیر با اولین فراخوانی تابع مقدار دهی می شود و در دفعات بعدی فراخوانی تابع مقدار قبلی خود را حفظ می کند. به مثال زیر توجه کنید:
#include <iostream.h>
int f();
void main( )
{
cout << f();
cout << f();
cout << f();
}
int f(){
static int x=0;
x++;
return x;
}
خروجی برنامه فوق به صورت زیر می باشد:
123
برنامه با اولین فراخوانی تابع f به متغیر محلی x مقدار 0 را می دهد، سپس به x یک واحد اضافه می شود و به عنوان خروجی برگردانده می شود. پس ابتدا عدد1 چاپ می گردد. در بار دوم فراخوانی تابع f ، متغیر x دوباره مقداردهی نمی شود، بلکه به مقدار قبلی آن که عدد 1 است، یک واحد اضافه گشته و به عنوان خروجی برگردانده می شود. پس این بار عدد 2 چاپ می گردد و در نهایت با فراخوانی تابع f برای بار سوم عدد 3 چاپ خواهد شد. اگر برنامه فوق را بدون کلمه static بنويسيم، خروجی 111 خواهد بود.
یکی از نکاتی که می توان در قوانین حوزه بررسی کرد، متغیرهای همنام در بلوک های تو در تو می باشد. به مثال زیر توجه کنید:
#include <iostream.h>
void main( )
{
int x=1;
cout << x;
{
int x= 2;
cout << x;
}
cout << x;
}
در برنامه فوق متغیر x یک بار در تابع main تعریف شده است و با دیگر در بلوک درونی. خروجی برنامه به صورت زیر می باشد:
121
ادامه دارد
هنگامی که در بلوک درونی متغیری با نام x را مجددا تعریف می کنیم، متغیر خارج از بلوک از دید برنامه پنهان می گردد و تنها متغير داخل بلوک قابل استفاده می شود. همچنین هنگامی که برنامه از بلوک خارج می گردد، متغیر x بیرونی دوباره قابل استفاده می گردد. ضمنا توجه داشته باشید که مقدار متغیر x تابع main تغییری نکرده است، یعنی با وجود استفاده از متغیری همنام و نیز مقداردهی آن، تاثیری روی متغیر x تابع ایجاد نشده است. چون حوزه متغیر x بلوک درونی تنها داخل آن بلوک می باشد.
برنامه زیر تمام موارد ذکر شده در این مبحث را شامل می شود. بررسی آن و خروجی برنامه شما را در فهم بهتر این مبحث یاری می نماید.
#include <iostream.h>
void useLocal( void ); // function prototype
void useStaticLocal( void ); // function prototype
void useGlobal( void ); // function prototype
int x = 1; // global variable
void main()
{
int x = 5; // local variable to main
cout <<"local x in main's outer scope is "<<x<<endl;
{ // start new scope
int x = 7;
cout <<"local x in main's inner scope is "<<x<<endl;
} // end new scope
cout <<"local x in main's outer scope is "<<x<< endl;
useLocal(); //useLocal has local x
useStaticLocal(); //useStaticLocal has static local x
useGlobal(); //useGlobal uses global x
useLocal(); //useLocal reinitializes its local x
useStaticLocal();//static local x retains its prior value
useGlobal(); //global x also retains its value
cout << "\nlocal x in main is " << x << endl;
} // end main
//useLocal reinitializes local variable x during each call
void useLocal( void )
{
int x = 25; //initialized each time useLocal is called
cout << endl << "local x is " << x
<< " on entering useLocal" << endl;
++x;
cout << "local x is " << x
<< " on exiting useLocal" << endl;
} // end function useLocal
// useStaticLocal initializes static local variable x
// only the first time the function is called; value
// of x is saved between calls to this function
void useStaticLocal( void )
{
// initialized first time useStaticLocal is called.
static int x = 50;
cout << endl << "local static x is " << x
<< " on entering useStaticLocal" << endl;
++x;
cout << "local static x is " << x
<< " on exiting useStaticLocal" << endl;
} // end function useStaticLocal
// useGlobal modifies global variable x during each call
void useGlobal( void )
{
cout << endl << "global x is " << x
<< " on entering useGlobal" << endl;
x *= 10;
cout << "global x is " << x
<< " on exiting useGlobal" << endl;
} // end function useGlobal
خروجی برنامه به صورت زیر می باشد:
local x in main's outer scope is 5
local x in main's inner scope is 7
local x in main's outer scope is 5
local x is 25 on entering useLocal
local x is 26 on exiting useLocal
local static x is 50 on entering useStaticLocal
local static x is 51 on exiting useStaticLocal
global x is 1 on entering useGlobal
global x is 10 on exiting useGlobal
local x is 25 on entering useLocal
local x is 26 on exiting useLocal
local static x is 51 on entering useStaticLocal
local static x is 52 on exiting useStaticLocal
global x is 10 on entering useGlobal
global x is 100 on exiting useGlobal
local x in main is 5
در برنامه فوق سه تابع با نام های useLocal ,useGlobal ,useStaticLocal داریم. متغیر x تعریف شده در ابتدای برنامه با مقدار 1 به عنوان یک متغیر عمومی می باشد و دارای حوزه فایل است. در تابع main، متغیر x با مقدار 5 تعریف شده است. لذا متغیر عمومی x با مقدار 1 نادیده گرفته می شود و هنگام اجرای دستور cout، متغير x با مقدار 5 در خروجی چاپ می شود. در بلوک درونی، متغیر x با مقدار 7 تعریف شده است. لذا x عمومی و x محلی تابع main نادیده گرفته می شوند و تنها x با مقدار 7 توسط دستور cout چاپ می گردد. پس از آنکه بلوک حوزه x با مقدار 7 به اتمام می رسد، دوباره x محلی تابع main با مقدار 5 نمایان می گردد.
تابع useLocal متغیر محلی x را با مقدار 25 در خود تعریف می کند. هنگامی که این تابع در برنامه فراخوانی می شود، تابع ، متغیر x را چاپ می کند، سپس یک واحد به آن اضافه کرده و دوباره x را چاپ می کند. هر بار که این تابع فراخوانی می شود، متغیر x با مقدار 25 در آن تعریف می شود و هنگام خروج از تابع از بین می رود.
تابع useStaticLocal متغیرمحلی x را از نوع static تعریف کرده و با عدد 50 مقداردهی می کند و سپس آن را چاپ کرده و یک واحد به آن اضافه می کند و دوباره چاپش می کند. اما هنگام خروج از تابع مقدار x از بين نمی رود. و با فراخوانی مجدد تابع ، مقدار قبلی متغير x محلی ، برای اين تابع موجود می باشد و دوباره از نو مقداردهی نمی شود. در اينجا هنگامی که تابع دوباره فراخوانی می شود، x حاوی 51 خواهد بود.
تابع useGlobal هيچ متغيری را در خود تعريف نمی کند. لذا هنگامی که به متغير x مراجعه می کند ، متغيرx عمومی مورد استفاده قرار می گيرد. هنگامی که اين تابع فراخوانی می شود مقدار متغير x عمومی چاپ می شود. سپس در 10 ضرب شده و دوباره چاپ می گردد. هنگامی که برای بار دوم تابع useGlobal فراخوانی می شود x عمومی حاوی عدد 100 می باشد.
پس از اينکه برنامه هر يک از توابع فوق را دوبار فراخوانی کرد ، مجددا متغير x تابع main با مقدار 5 چاپ می گردد و اين نشان می دهد که هيچ يک از توابع ، تاثيری روی متغير محلی تابع main نداشتند.
گردآورنده :طه - TAHA
آرگومانهای پیش فرض توابع و عملگرهای حوزه و ارسال آرگومان به توابع
در برنامه نويسی ممکن است تابعی را به دفعات با آرگومانهای يکسانی صدا بزنيم . در چنين حالتی ، برنامه نويس می تواند برای آرگومانهای تابع ، مقداری را به عنوان پيش فرض قرار دهد . هنگامی که در فراخوانی توابع ، آرگومان دارای مقدار پيش فرض حذف شده باشد ، کامپايلر مقدار پيش فرض آن آرگومان را به تابع خواهد فرستاد .
آرگومان های پيش فرض بايد سمت راستی ترين آرگومان های تابع باشند . هنگامی که تابعی با بيش از يک آرگومان فراخوانی می شود ، اگر آرگومان حذف شده سمت راستی ترين آرگومان نباشد ، آنگاه همه آرگومانهای سمت راست آن آرگومان نيز بايد حذف شوند . آرگومان های پيش فرض بايد در اولين جايی که نام تابع آورده می شود ( که معمولاً در پيش تعريف تابع است ) مشخص شوند .
مقادير پيش فرض می توانند اعداد ، مقادير ثابت ، متغيرهای عمومی و يا خروجی تابع ديگر باشند .
برنامه زير نحوه مقدار دهی به آرگومان های پيش فرض و نيز نحوه فراخوانی تابع با مقدار پيش فرض را نشان می دهد . در اين برنامه حجم جعبه ای محاسبه می شود .
#include
// function prototype that specifies default arguments
int boxVolume(int length=1, int width=1, int height=1);
int main()
{
//no arguments--use default values for all dimensions
cout <<"The default box volume is: "<
//specify length; default width and height
cout <<"\n\nThe volume of a box with length 10,\n"
<<"width 1 and height 1 is: "<
//specify length and width; default height
cout <<"\n\nThe volume of a box with length 10,\n"
<<"width 5 and height 1 is: "<
//specify all arguments
cout <<"\n\nThe volume of a box with length 10,\n"
<<"width 5 and height 2 is: "<
<
return 0; // indicates successful termination
} //end main
// function boxVolume calculates the volume of a box
int boxVolume( int length, int width, int height )
{
return length * width * height;
} // end function boxVolume
خروجی برنامه فوق به صورت زير می باشد .
The default box volume is: 1
The volume of a box with length 10,
width 1 and height 1 is: 10
The volume of a box with length 10,
width 5 and height 1 is: 50
The volume of a box with length 10,
width 5 and height 2 is: 100
در پيش تعريف تابع boxVolume به هر يک از سه آرگومان تابع مقدار پيش فرض 1 داده شده است . توجه داشته باشيد که مقادير پيش فرض بايد در پيش تعريف تابع نوشته شوند ، ضمناً نوشتن نام آرگومان های تابع در پيش تعريف الزامی نيست و در برنامه فوق اينکار تنها برای خوانايی بيشتر انجام گرفته است ، البته توصيه می شود که شما نيز از اين شيوه استفاده کنيد . به عنوان مثال پيش فرض تابع boxVolume در برنامه فوق را می توانستيم به صورت زير نيز بنويسيم :
int boxVolume (int = 1 , int = 1 , int = 1 );
در اولين فراخوانی تابع boxVolume در برنامه فوق هيچ آرگومانی به آن داده نشده است لذا هر سه مقدار پيش فرض آرگومان ها مورد استفاده قرار می گيرد و حجم جعبه عدد 1 می شود . در دومين فراخوانی آرگومان lengthارسال می گردد ، لذا مقادير پيش فرض آرگومان های widthو heightاستفاده می شوند . در سومين فراخوانی آرگومان های width و length ارسال می گردند لذا مقادير پيش فرض آرگومان height مورد استفاده قرار می گيرد . در آخرين فراخوانی هر سه آرگومان ارسال می شوند لذا از هيچ مقدار پيش فرضی استفاده نمی شود .
پس هنگامی که يک آرگومان به تابع فرستاده می شود ، آن آرگومان به عنوان length در نظر گرفته می شود و هنگامی که دو آرگومان به تابع boxVolume فرستاده می شود تابع آنها را به ترتيب از سمت چپ به عنوان آرگومان length و سپس width در نظر می گيرد و سرانجام هنگامی که هرسه آرگومان فرستاده می شود به ترتيب از سمت چپ در length و width و height قرار می گيرند .
عملگر يگانی تفکيک حوزه
همانطور که در مبحث قوانين حوزه ديديد تعريف متغيرهای محلی و عمومی با يک نام در برنامه امکان پذير می باشد . زبان ++C عملگر يگانی تفکيک دامنه (::) را برای امکان دستيابی به متغير عمومی همنام با متغير محلی ، در اختيار ما قرار داده است . توجه داشته باشيد که اين عملگر تنها قادر به دستيابی به متغير عمومی در حوزه فايل می باشد . ضمناً متغير عمومی بدون نياز به اين عملگر نيز قابل دستيابی می باشد ؛ به شرط آنکه متغيرمحلی همنام با متغير عمومی ، در برنامه به کار برده نشود . استفاده از عملگر (::) همراه نام متغير عمومی ، در صورتی که نام متغير عمومی برای متغير ديگری به کار برده نشده باشد ، اختياری است . اما توصيه می شود که برای اينکه بدانيد از متغير عمومی استفاده می کنيد از اين عملگر همواره در کنار نام متغير عمومی استفاده کنيد . برنامه زير نحوه کاربرد عملگر (::) را نشان می دهد .
#include
float pi=3.14159;
void main( )
{
int pi=::pi;
cout << "Local pi is : " << pi << endl;
cout << "Global pi is : " << ::pi << endl;
}
خروجی برنامه به صورت زير می باشد :
Local pi is : 3
Global pi is : 3.14159
در برنامه فوق متغير عمومی pi از نوع float تعريف شده است و در تابع متغير محلی pi از نوع int با مقدار اوليه pi عمومی مقدار دهی می شود . توجه داشته باشيد که برای دستيابی به مقدار pi عمومی از عملگر يگانی تفکيک حوزه (::) استفاده شد . پس از مقدار دهی به pi محلی ، توسط دستور cout ، متغير pi محلی که حاوی عدد 3 است چاپ می گردد و در خط بعدی متغير pi عمومی که حاوی 3.14159 می باشد چاپ خواهد شد .
ادامه دارد....
ارسال آرگومان ها به تابع ، با ارجاع
تا به حال ، در تمام توابعی که نوشتيم آرگومان ها با مقدار به توابع فرستاده می شدند . اين بدان معناست که هنگامی که توابع با آرگومانها فرا خوانی می شدند ، چيزی که ما به عنوان ورودی تابع ارسال می کرديم مقدار يا عدد بود و هرگز خود متغير به تابع فرستاده نشد ، به عنوان مثال تابع maximum در مبحث تعريف توابع (http://pnu-club.com/redirector.php?url=http%3A%2F%2Fwww.elearning.tehr anedu.ir%2Fc%2F3-2.asp) را به صورت زير فراخوانی می کنيم :
int a=5, b=6, c=7, max;
max = maximum(a,b,c);
کاری که در اينجا صورت می گيرد فراخوانی تابع و فرستادن مقادير موجود در a وb وc يعنی 5 و 6 و 7 به تابع می باشد . و خود متغيرها فرستاده نمی شوند .
بدين صورت هنگامی که تابع maximum فراخوانی می شود ، مقدار متغيرهای x وy وz به ترتيب برابر 5 و 6 و 7خواهند شد و هرگونه تغييری روی متغيرهای x وy وz در تابع ، تأثيری روی متغيرهای a وb وc نخواهد داشت . زيرا خود متغيرهای a وb وc به تابع فرستاده نشده اند بلکه مقادير موجود در آنها به تابع ارسال گشته اند .
در برنامه نويسی مواردی پيش می آيد که بخواهيد از داخل تابع ، مقادير متغيرهای خارجی را تغيير دهيم ، به عنوان مثال در تابع maximum مقدار متغير aرا از داخل تابع تغيير دهيم . برای نيل به اين هدف بايد از روش ارسال آرگومان ها با ارجاع استفاده کنيم . برای آنکه آرگومان تابعی با ارجاع فرستاده شود ، کافی است در پيش تعريف تابع بعد از تعيين نوع آرگومان يک علامت (&) بگذاريم و نيز در تعريف تابع قبل از نام آرگومان يک علامت (&) قرار دهيم . برای آشنايی با نحوه ارسال آرگومان ها با ارجاع به برنامه زير توجه کنيد .
#include void duplicate (int & , int & );void main ( ){ int a=1 , b=2 ; cout << "a = " << a << " and b = " << b << endl; duplicate (a,b); cout << "a = " << a << " and b = " << b << endl;}void duplicate (int &x , int &y){ x*=2; y*=2; }
خروجی برنامه به صورت زير می باشد .
a = 1 and b = 2a = 2 and b = 4
در برنامه فوق متغيرهای a وb به تابع ارسال می گردند و سپس در دو ضرب می شوند. در اين برنامه مقدار متغيرهای a وb فرستاده نمی شود بلکه خود متغير فرستاده می شود و لذا هنگامی که دستورهای
x*=2;y*=2;
اجرا می گردند مقادير دو متغيرa وb دو برابر می شود . در حقيقت x وyمانند نام مستعاری برای a وb می باشند .
هنگامی که متغيری با ارجاع فرستاده می شود هر گونه تغييری که در متغير معادل آن در تابع صورت گيرد عيناً آن تغيير بر روی متغير ارسالی نيز اعمال می گردد .
مثال : تابعی بنويسيد که دو متغير را به عنوان ورودی دريافت کرده و مقادير آنها را جابه جا کند . از اين تابع در برنامه ای استفاده کنيد .
#include void change (int & , int &);int main ( ) { int a=1 , b=2 ; cout << "a is " << a << " and b is " << b << endl; change (a,b); cout << "a is " << a << " and b is " << b << endl; return 0; }void change (int &x , int &y) { int temp; temp = y; y = x; x = temp; }
خروجی برنامه به صورت زير است :
a is 1 and b is 2a is 2 and b is 1
برنامه فوق مقادير دو متغير a وb را توسط change با شيوه ارسال آرگومان با ارجاع جابه جا می کند .
يکی ديگر از کاربردهای ارسال با ارجاع ، دريافت بيش از يک خروجی از تابع می باشد ، به عنوان مثال تابع prevnext در برنامه زير مقادير صحيح قبل و بعد از اولين آرگومان را به عنوان خروجی بر می گرداند .
#include void prevnext (int ,int & , int &);void main ( ){ int x = 100 , y , z ; cout << "The input of prevnext function is " << x << endl; prevnext (x,y,z) ; cout << "previous =" << y <<",Next =" << z;}void prevnext (int input , int & prev , int & next){ prev = input - 1 ; next = input + 1 ;}
خروجی برنامه فوق به صورت زير می باشد .
The input of prevnext function is 100previous =99,Next =101
همانطور که مشاهده می کنيد آرگومان input مقدار داده موجود در متغير x را دريافت می کند ولی آرگومان های prev وnext خود متغيرهای y وz را دريافت می کنند . لذا تغييرات روی متغيرprev وnext بر روی y وz انجام می گيرد و توسط تابع مقدار دهی می شوند
گردآورنده :طه - TAHA
گرانبار کردن توابع (استفاده از يک نام برای چند تابع)
++C استفاده از يک نام را برای چند تابع ، هنگامی که توابع از نظر نوع آرگومان ها ، تعداد آرگومان ها يا ترتيب قرار گرفتن نوع آرگومان ها با هم متفاوت باشند را امکان پذير کرده است اين قابليت ، گرانبار کردن توابع ناميده می شود . هنگامی که يک تابع گرانبار شده فراخوانی می شود کامپايلر با مقايسه نوع ، تعداد و ترتيب آرگومان ها تابع درست را انتخاب می کند . معمولاً از توابع گرانبار شده برای ايجاد چند تابع با نامهای يکسان که کار يکسانی را بر روی انواع داده ای متفاوتی انجام می دهند استفاده می شود . به عنوان مثال اکثر توابع رياضی زبان ++C برای انواع داده ای متفاوت گرانبار شده اند . گرانبار کردن توابعی که کار يکسانی را انجام می دهند برنامه را قابل فهم تر و خواناتر می سازد . برنامه زير نحوه به کار گيری توابع گرانبار شده را نشان می دهد .
#include
int square( int );
double square( double );
void main()
{
// calls int version
int intResult = square( 7 );
// calls double version
double doubleResult = square( 7.5 );
cout << "\nThe square of integer 7 is "
<< intResult
<< "\nThe square of double 7.5 is "
<< doubleResult
<< endl;
} // end main
// function square for int values
int square( int x )
{
cout <<"Called square with int argument: "
<< x << endl;
return x * x;
} // end int version of function square
// function square for double values
double square( double y )
{
cout <<"Called square with double argument: "
<< y << endl;
return y * y;
} // end double version of function square
خروجی برنامه به صورت زير می باشد .
Called square with int argument: 7
Called square with double argument: 7.5
The square of integer 7 is 49
The square of double 7.5 is 56.25
برنامه فوق برای محاسبه مربع يک عدد صحيح (int) و يک عدد اعشاری (double) از تابع گرانبارشده square استفاده می کند .هنگامی که دستور:
int intResult = square (7) ;
اجرا می گردد تابع square با پيش تعريف :
int square (int) ;
فراخوانی می شود و هنگامی که دستور :
double doubleResult = square (7.5) ;
اجرا می گردد تابع square با پيش تعريف :
double square (double );
فراخوانی می شود .
نکته : توجه داشته باشيد که توابع گرانبار شده الزامی ندارند که وظيفه يکسانی را انجام دهند . و ممکن است کاملاً با هم تفاوت داشته باشند ، ولی توصيه می شود که توابعی را گرانبار کنيد که يک کار را انجام می دهند .
ادامه دارد..
اعلان آرايه ها
يک آرايه مجموعه ای از خانه ها متوالی حافظه می باشد که دارای يک نام و يک نوع می باشند . به هر يک از اين خانه ها يک عنصر آرايه گفته می شود . برای دستيابی به يک عنصر آرايه ، بايد نام آرايه و شمارنده آن خانه را مشخص کنيم . لذا عناصر آرايه توسط متغيری به نام انديس مشخص می شوند به همين دليل، آرايه ها را متغيرهای انديس دار نيز می گويند . نام آرايه ، از قواعد نام گذاری متغيرها پيروی می کند .اعلان آرايه ها به صورت زير است :
طول آرايه] نام آرايه نوع داده آرايه];
به عنوان مثال دستور زير آرايه ای به طول 6 ، با نام num را از نوع int ايجاد می کند .
int num [6];
توجه داشته باشيد که تمام عناصر دارای نام يکسانی می باشند و تنها با انديس از هم تفکيک می شوند . به عنوان مثال عنصر با انديس 2 دارای مقدار 23560- می باشد ، ضمناً انديس عناصر از 0 شروع می شود .
استفاده از يک عبارت محاسباتی به جای انديس عناصر امکان پذير می باشد ، به عنوان مثال با فرض اينکه متغير a حاوی 2 و متغير b حاوی 3 باشد ، دستور زير:
num [a+b] + = 3;
سه واحد به عنصر num [5] اضافه خواهد کرد و اين عنصر حاوی عدد 3 می گردد . برای چاپ مجموع سه عنصر اول آرايه می توانيد از دستور زير استفاده کنيد :
cout << num[0] + num[1] + num[2] << endl;
برای تقسيم عنصر چهارم آرايه بر 2 و قرار دادن حاصل در متغير x از دستور زير می توانيد استفاده کنيد :
x = num[3]/2;
نکته :توجه داشته باشيد که عنصر چهارم آرايه با عنصر شماره چهار ( با انديس چهار ) متفاوت می باشد . همانطور که در دستور فوق ديديد عنصر شماره چهار دارای انديس سه می باشد ، دليل اين امر اينست که انديس گذاری از صفر شروع می شود . در آرايه فوق عنصر چهارم آرايه num[3]=-50 می باشد ولی عنصر شماره چهار ( با انديس چهار ) num[4]=32500 می باشد .
همانند متغيرها چند آرايه را نيز می توان توسط يک دستور تعريف کرد :
int b[100] , x[27] ;
دستور فوق 100 خانه از نوع عدد صحيح را برای آرايه با نام b و 27 خانه از نوع عدد صحيح را برای آرايه با نام x در نظر می گيرد .
برای مقدار دهی اوليه به هر يک از عناصر آرايه می توانيد از شيوه زير استفاده کنيد :
int n[5] = {32 , 27 , 64 , 18 , 95 }
دستور فوق عناصر آرايه n را به صورت زير مقدار دهی می کند .
اگر طول آرايه هنگام تعريف آرايه تعيين نشده باشد و ليست مقدار عناصر نوشته شود ، همانند دستور زير :
int n[] = { 1 , 2 , 3 , 4 , 5 }
در اين صورت کامپايلر به تعداد عناصر ليست ، خانه حافظه برای آرايه در نظر می گيرد ، مثلاً در دستور فوق 5 خانه حافظه برای آرايه n در نظر گرفته می شود .
راه ديگری که برای مقدار دهی اوليه به عناصر آرايه وجود دارد استفاده از روش زير است :
int num[10] = {0}
دستور فوق 10 خانه حافظه برای آرايه num در نظر می گيرد و مقادير همه آنها را صفر می کند . توجه داشته باشيد که اگر از دستور زير استفاده کنيم :
int num[10] = {1}
تمامی عناصر مقدار 1 را نمی گيرند بلکه عنصر اول آرايه يک می شود و بقيه عناصر مقدار صفر را می گيرند .
در تعريف آرايه ديديد که طول آرايه را با عدد صحيح ثابتی تعيين می کنيم . هر جا که از عدد ثابتی استفاده می شود ، متغير ثابت نيز می توان به کار برد . متغيرهای ثابت به صورت زير تعريف می شوند :
const مقدار متغير = نام متغير ثابت نوع داده متغير ;
به عنوان مثال :
const int arraySize = 10;
دستور فوق عدد 10 را به متغير arraySize ثابت انتساب می دهد . توجه داشته باشيد که مقدار يک متغير ثابت را در طول برنامه نمی توان تغيير داد و نيز متغير ثابت در هنگام تعريف شدن ، مقدار اوليه اش نيز بايد تعيين گردد . به متغيرهای ثابت ، متغيرهای فقط خواندنی نيز گفته می شود . کلمه "متغير ثابت" يک کلمه مرکب ضد و نقيض می باشد چون کلمه متغير متضاد ثابت می باشد و اين اصطلاحی است که برای اينگونه متغيرهای در اکثر زبانهای برنامه نويسی به کار می رود . برنامه زير نحوه تعريف يک متغير ثابت را نشان می دهد :
#include
void main()
{
const int x = 7;
cout << "The value of constant variable x is: "
<< x << endl;
}
برنامه فوق عدد 7 را در متغير ثابت x قرار می دهد و توسط دستور cout آنرا چاپ می کند . همانطور که گفتيم مقدار متغير ثابت در هنگام تعريف بايد تعيين گردد و نيز ثابت قابل تغيير نمی باشد ، به برنامه زير توجه کنيد .
#include
void main()
{
const int x;
x=7;
}
برنامه فوق هنگام کامپايل شدن دو پيغام خطا خواهد داد ، چون متغير ثابت هنگام تعريف مقدار دهی نشده و نيز در برنامه دستوری برای تغيير مقدار آن آورده نشده است .
Compiling C:\TCP\BIN\CONST1.CPP:
Error : Constant variable 'x' must be initialized
Error : Cannot modify a const object
مثال : در برنامه زير طول آرايه توسط متغير ثابتی تعيين می گردد و عناصر آرايه توسط حلقه for مقدار دهی شده و سپس توسط حلقه for ديگری ، مقدار عناصر آرايه چاپ می گردد .
#include
void main()
{
const int arraySize = 10;
int s[ arraySize ];
for ( int i = 0; i < arraySize; i++ )
s[ i ] = 2 + 2 * i;
cout << "Element Value" << endl;
for ( int j = 0; j < arraySize; j++ )
cout << j << "\t " << s[ j ] << endl;
}
خروجی برنامه فوق به صورت زير می باشد :
Element Value
0 2
1 4
2 6
3 8
4 10
5 12
6 14
7 16
8 18
9 20
ادامه دارد
چند مثال از آرايه ها و کاربرد آنها
مثال : برنامه ای بنويسيد که 10 عدد صحيح را ورودی دريافت کرده و در آرايه ای قرار داده سپس مجموع عناصر آرايه را محاسبه کرده و درخروجی چاپ نمايد .
#include
void main()
{
const int arraySize = 10;
int total = 0,i;
int a[ arraySize ];
for (i = 0; i < arraySize; i++)
{
cout << "Enter number " << i << " : ";
cin >> a[ i ];
}
for (i = 0; i < arraySize; i++ )
total += a[ i ];
cout << "Total of array element values is "
<< total << endl;
}
خروجی برنامه به صورت زير می باشد :
Enter number 0 : 12
Enter number 1 : 3
Enter number 2 : 4
Enter number 3 : 654
Enter number 4 : 34
Enter number 5 : 2
Enter number 6 : 123
Enter number 7 : 794
Enter number 8 : 365
Enter number 9 : 23
Total of array element values is 2014
مثال : برنامه ای بنويسيد که توسط آرايه ، نمودار ميله ای افقی برای اعداد {1 و17 و5 و13 و9 و11 و7 و15 و3 و19 } رسم کند .
#include
int main()
{
const int arraySize = 10;
int n[ arraySize ] = { 19, 3, 15, 7, 11,
9, 13, 5, 17, 1 };
cout << "Element" << " Value" << endl;
for ( int i = 0; i < arraySize; i++ ) {
cout << i << "\t " << n[ i ] << "\t";
for ( int j = 0; j < n[ i ]; j++ )
cout << '*';
cout << endl;
}
return 0;
}
خروجی برنامه به صورت زير می باشد :
Element Value
0 19 *******************
1 3 ***
2 15 ***************
3 7 *******
4 11 ***********
5 9 *********
6 13 *************
7 5 *****
8 17 *****************
9 1 *
مثال : برنامه ای بنويسيد که يک تاس را 6000 بار پرتاب کرده و توسط آرايه ای تعداد دفعات آمدن هر وجه را حساب کند .( تعداد دفعات آمدن هر وجه را يک عنصر آرايه ای در نظر بگيريد )
#include
#include
#include
void main()
{
const int arraySize = 7;
int frequency[ arraySize ] = { 0 };
srand( time( 0 ) );
for ( int roll = 1; roll <= 6000; roll++ )
++frequency[ 1 + rand() % 6 ];
cout << "Face Frequency" << endl;
for ( int face = 1; face < arraySize; face++ )
cout << face << "\t" << frequency[face] << endl;
}
خروجی برنامه به صورت زير می باشد :
Face Frequency
1 1023
2 990
3 1008
4 971
5 1025
6 983
دستور ++frequency [rand()%6 + 1]; ، مقدار عنصر مربوط به هر وجه را يک واحد اضافه می کند ، زيرا rand()%6 + 1 عددی بين 1 تا 6 توليد می کند ، پس هر بار به طور تصادفی تنها مقدار عنصر مربوط به يکی از وجوه افزايش می يابد .
ادامه دارد
يکی از کار برد های آرايه ها ، استفاده از آنها برای ذخيره رشته ای از حروف می باشد . تا به حال متغيرهايی که از ورودی دريافت می کرديم و يا آرايه هايی که تا به اينجا ديديد تنها شامل اعداد می شدند در اينجا به عنوان مثال نحوه دريافت يک نام از ورودی و چاپ آن در خروجی را بررسی می کنيم .(در فصل بعد يعنی اشاره گرها و رشته ها ، به طور مفصل تر راجع به رشته ها صحبت خواهيم کرد )
يک عبارت رشته ای مانند: "hello" در واقع آرايه ای از حروف می باشد.
char string1[]="hello";
دستور فوق آرايه ای به نام string1را با کلمه hello مقدار دهی می کند. طول آرايه فوق برابر است با طول کلمه helloيعنی 5 بعلاوه يک واحد که مربوط است به کاراکتر پوچ که انتهای رشته را مشخص می کند. لذا آرايه string1 دارای طول 6 می باشد. کاراکتر پوچ در زبان ++C توسط '\0' مشخص می گردد. انتهای کليه عبارات رشته ای با اين کاراکتر مشخص می شود.
char string1[]={'h','e','l','l','o','\0'}
دستور فوق عناصر آرايه string1 را جداگانه مقدار دهی می کند. توجه داشته باشيد که عناصر آرايه در دستور فوق داخل (') قرار گرفتند و نيز انتهای رشته با '\0' تعيين شد. نتيجه همانند دستور char string1[]="hello"; می باشد.
چون عبارت رشته ای، آرايه ای از حروف می باشند، لذا به هر يک از حروف رشته، توسط انديس عنصری که شامل آن حرف می باشد، می توان دسترسی پيدا کرد. به عنوان مثال string1[0] شامل 'h' و string1[3] شامل 'l' و string1[5] شامل '\0' می باشد.
توسط دستور cin نيز می توان به طور مستقيم کلمه وارد شده از صفحه کليد را در آرايه ای رشته ای قار داد.
char string2[20];
دستور فوق يک آرايه رشته ای که قابليت دريافت کلمه ای با طول 19 به همراه کاراکتر پوچ را دارا می باشد.
cin >> string2;
دستور فوق رشته ای از حروف را از صفحه کليد خوانده و در string2 قرار می دهدو کاراکتر پوچ را به انتهای رشته وارد شده توسط کاربر اضافه می کند. به طور پيش فرض دستور cin کاراکتر ها را از صفحه کليد تا رسيدن به اولين فضای خالی در يافت می کند. به عنوان مثال اگر هنگام اجرای دستور cin >> string2; کاربر عبارت "hello there" را وارد کند، تنها کلمه hello در string2 قرار می گيرد. چون عبارت وارد شده شامل کاراکتر فاصله است. برنامه زير نحوه به کار گيری آرايه های رشته ای را نشان می دهد.
#include
void main()
{
char name[ 20 ];
cout << "Please Enter your name : ";
cin >> name;
cout << "Welcome, " << name
<< " to this program. \n" ;
cout << "Your separated name is\n";
for ( int i = 0; name[ i ] != '\0'; i++ )
cout << name[ i ] << ' ';
}
خروجی برنامه به صورت زير می باشد :
Please Enter your name : Mohammad
Welcome, Mohammad to this program.
Your separated name is
M o h a m m a d
در برنامه فوق حلقه for ، حروف نام وارد شده توسط کاربر را جدا جدا در خروجی چاپ می کند. ضمنا شرط حلقه name[ i ] != '\0' می باشد و تا وقتی اين شرط برقرار است که حلقه به انتهای رشته نرسيده باشد.
ادامه دارد..
در مبحث قوانين حوزه ديديد که اگر بخواهيم يک متغير محلی تابع، مقدار خود را حفظ کرده و برای دفعات بعدی فراخوانی تابع نيز نگه دارد، از کلمه static استفاده کرديم. نوع static را برای آرايه ها نيز می توان به کار برد و از همان قوانين گفته شده در مبحث مذکور پيروی می کند. به برنامه زير و خروجی آن توجه کنيد.
#include
void staticArrayInit( void );
void automaticArrayInit( void );
int main()
{
cout << "First call to each function:\n";
staticArrayInit();
automaticArrayInit();
cout << "\n\nSecond call to each function:\n";
staticArrayInit();
automaticArrayInit();
cout << endl;
return 0;
}
// function to demonstrate a static local array
void staticArrayInit( void )
{
// initializes elements to 0
// first time function is called
static int array1[ 3 ]={0};
cout << "\nValues on entering staticArrayInit:\n";
// output contents of array1
for ( int i = 0; i < 3; i++ )
cout << "array1[" << i << "] = "
<< array1[ i ] << " ";
cout << "\nValues on exiting staticArrayInit:\n";
// modify and output contents of array1
for ( int j = 0; j < 3; j++ )
cout << "array1[" << j << "] = "
<< ( array1[ j ] += 5 ) << " ";
} // end function staticArrayInit
// function to demonstrate an automatic local array
void automaticArrayInit( void )
{
// initializes elements each time function is called
int array2[ 3 ] = { 1, 2, 3 };
cout << endl << endl;
cout << "Values on entering automaticArrayInit:\n";
// output contents of array2
for ( int i = 0; i < 3; i++ )
cout << "array2[" << i << "] = "
<< array2[ i ] << " ";
cout << "\nValues on exiting automaticArrayInit:\n";
// modify and output contents of array2
for ( int j = 0; j < 3; j++ )
cout << "array2[" << j << "] = "
<< ( array2[ j ] += 5 ) << " ";
}
خروجی برنامه به صورت زير می باشد :
First call to each function:
Values on entering staticArrayInit:
array1[0] = 0 array1[1] = 0 array1[2] = 0
Values on exiting staticArrayInit:
array1[0] = 5 array1[1] = 5 array1[2] = 5
Values on entering automaticArrayInit:
array2[0] = 1 array2[1] = 2 array2[2] = 3
Values on exiting automaticArrayInit:
array2[0] = 6 array2[1] = 7 array2[2] = 8
Second call to each function:
Values on entering staticArrayInit:
array1[0] = 5 array1[1] = 5 array1[2] = 5
Values on exiting staticArrayInit:
array1[0] = 10 array1[1] = 10 array1[2] = 10
Values on entering automaticArrayInit:
array2[0] = 1 array2[1] = 2 array2[2] = 3
Values on exiting automaticArrayInit:
array2[0] = 6 array2[1] = 7 array2[2] = 8
در برنامه فوق عناصر آرايه array1 در اولين بار فراخوانی تابع staticArrayInit مقدار صفر را می گيرند ولی در دفعات بعدی فراخوانی اين تابع، آخرين مقدار قبلی خود را حفظ می کنند . اما آرايه array2 در هر بار فراخوانی تابع automaticArrayInit مقدار دهی اوليه می شود و با خروج از تابع مقدار خود را از دست می دهد.
گردآورنده :طه - TAHA
Powered by vBulletin™ Version 4.2.2 Copyright © 2024 vBulletin Solutions, Inc. All rights reserved.