CPP Book Sade

‫‪www.SourceSara.
com‬‬ ‫ﺳﺎﯾﺖ ﺳﻮرس ﺳﺮا ‪ -‬آﻣﻮزش ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ و ﺳﻮرس ﮐﺪﻫﺎي آﻣﺎده‬
‫‪C++‬‬
‫به زبان ساده‬
‫منبع کتاب ‪w3-farsi.com :‬‬
‫مؤلف ‪ :‬یونس ابراهیمی‬
‫به زبان ساده‬
‫‪w3-farsi.com‬منبع کتاب ‪ :‬سایت‬
‫مؤلف ‪ :‬یونس ابراهیمی‬

‫‪www.SourceSara.com‬‬ ‫ﺳﺎﯾﺖ ﺳﻮرس ﺳﺮا ‪ -‬آﻣﻮزش ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ و ﺳﻮرس ﮐﺪﻫﺎي آﻣﺎده‬
‫راههای ارتباط با نویسنده‬
‫سایت ‪w3-farsi.com :‬‬
‫جیمیل ‪younes.ebrahimi.1391@gmail.com :‬‬
‫‪Contents‬‬
‫‪ C++‬چیست ‪8 ......................................................................................................................................................‬‬
‫نصب و پیکربندی‪9................................................................................................................................. MinGW‬‬
‫ساخت یک برنامه ساده ‪61 ....................................................................................................................................‬‬
‫توضیحات‪02 .....................................................................................................................................................‬‬
‫کاراکترهای کنترلی‪06............................................................................................................................................‬‬
‫متغیر ‪02..........................................................................................................................................................‬‬
‫انواع ساده ‪02 ....................................................................................................................................................‬‬
‫استفاده از متغیرها ‪01 ..........................................................................................................................................‬‬
‫ثابت ‪22 ...........................................................................................................................................................‬‬
‫عبارات و عملگرها ‪26 ................................................................................................................................................‬‬
‫عملگرهای ر یاضی‪20............................................................................................................................................‬‬
‫عملگرهای تخصیصی ‪23 ......................................................................................................................................‬‬
‫عملگرهای مقایسه ای ‪21 .....................................................................................................................................‬‬
‫عملگرهای منطقی ‪28 ..........................................................................................................................................‬‬
‫تقدم عملگرها ‪23 ................................................................................................................................................‬‬
‫گرفتن ورودی از کاربر ‪24 ............................................................................................................................................‬‬
‫ساختارهای تصمیم ‪28 ..............................................................................................................................................‬‬
‫دستور‪29 ....................................................................................................................................................... if‬‬

‫دستور‪32 ............................................................................................................................................. if…else‬‬
‫عملگر شرطی ‪32 .................................................................................................................................................‬‬
‫دستور ‪ if‬چندگانه ‪33............................................................................................................................................‬‬
‫دستور ‪ if‬تو در تو ‪34 ...........................................................................................................................................‬‬
‫استفاده از عملگرهای منطقی ‪39 ..............................................................................................................................‬‬
‫دستور‪16 .............................................................................................................................................. Switch‬‬
‫تکرار ‪13 ...............................................................................................................................................................‬‬
‫حلقه‪11 ................................................................................................................................................. While‬‬
‫حلقه‪14............................................................................................................................................. do while‬‬
‫حلقه‪19 ...................................................................................................................................................... for‬‬
‫حلقههای تو در تو)‪42 .................................................................................................................. (Nested Loops‬‬
‫خارج شدن از حلقه با استفاده از ‪ break‬و‪40 ................................................................................................ continue‬‬
‫آرایهها ‪42 ............................................................................................................................................................‬‬
‫آرایههای چند بعدی ‪41.........................................................................................................................................‬‬
‫متد‪86 .................................................................................................................................................................‬‬
‫مقدار برگشتی از یک متد ‪80 ...................................................................................................................................‬‬
‫پارامترها و آرگومانها ‪83 .....................................................................................................................................‬‬
‫ارسال آرگومانها به روش ارجاع ‪88 .........................................................................................................................‬‬
‫ارسال آرایه به عنوان آرگومان ‪92...............................................................................................................................‬‬
‫محدوده متغیر ‪90 ...............................................................................................................................................‬‬
‫پارامترهای اختیار ی ‪90 .........................................................................................................................................‬‬
‫سربارگذار ی متدها ‪92 ...........................................................................................................................................‬‬
‫بازگشت)‪93 ................................................................................................................................... (Recursion‬‬
‫شمارش ‪94...........................................................................................................................................................‬‬
‫)‪626 .............................................................................................................................................. (Enumeration‬‬
‫پیش پردازنده ها ‪626 ................................................................................................................................................‬‬
‫اشاره گرها ‪622 .......................................................................................................................................................‬‬
‫ساختارها ‪622 .........................................................................................................................................................‬‬
‫برنامه نویسی شیء گرا ‪623 ........................................................................................................................................‬‬

‫‪ w3-farsi.com‬تخصصی ترین سایت آموزش سی شارپ‬ ‫‪4‬‬
‫) ‪621 ................................................................................................................. (Object Oriented Programming‬‬
‫کالس ‪621 .............................................................................................................................................................‬‬
‫سازنده ها)‪628 ................................................................................................................................ (Constructors‬‬
‫مخرب ها)‪666 ................................................................................................................................... (Destructors‬‬
‫فیلدهای فقط – خواندنی ‪662......................................................................................................................................‬‬
‫سطح دسترسی ‪661 .................................................................................................................................................‬‬
‫کپسوله کردن ‪668 ....................................................................................................................................................‬‬
‫)‪602 ........................................................................................................................................... (Encapsulation‬‬
‫خواص)‪600 ....................................................................................................................................... (Properties‬‬
‫فضای نام ‪602 ........................................................................................................................................................‬‬
‫وراثت ‪608............................................................................................................................................................‬‬
‫سطح دسترسی ‪626 .................................................................................................................................................‬‬
‫‪622 ........................................................................................................................................................Protect‬‬
‫اعضای‪623 ................................................................................................................................................. Static‬‬
‫کالس‪624 .................................................................................................................................................. Static‬‬
‫سربارگذار ی عملگرها ‪629 ..........................................................................................................................................‬‬
‫چند ر یختی)‪620 ........................................................................................................................... (Polymorphism‬‬

‫تقدیم به‪:‬‬
‫همسر و پسر عزیزم‬

‫فصل اول‬
‫مبانی زبان سی پالس پالس‬

‫‪ w3-farsi.com‬تخصصی ترین سایت آموزش زبان های خانواده ‪C‬‬ ‫‪8‬‬
‫‪ C++‬چیست‬
‫‪ C++‬یک زبان برنامه نویسی است که از ‪ paradigm‬یا سبکهای مختلف برنامه نویسی پشتیبانی میکند‪ C++.‬نسخه توسعه یافته‬
‫زبان ‪ C‬میباشد و بیشتر کدهای زبان ‪ C‬به راحتی میتواند در ‪ C++‬کامپایل شود‪ .‬در ‪ C++‬از ویژگیهای مهمی که به ‪ C‬اضافه‬
‫شده است میتوان به برنامه نویسی شی گرا ‪ ،‬سربارگذاری عملگرها‪ ،‬وراثت چندگانه و مدیریت خطاها اشاره نمود‪ .‬توسعه ‪ C++‬در‬
‫سال ‪ 9191‬آغاز شد و ‪ 9‬سال پس از زبان ‪ C‬به نمایش گذاشته شد‪.‬با وجود قدیمی بودن زبانهای ‪ C‬و ‪ c++‬هنوز هم به صورت‬
‫گسترده ای در نرم افزارهای صنعتی مورد استفاده قرار میگیرد‪ .‬این زبانها برای ساخت هر چیزی از سیستم عامل گرفته تا نرم‬
‫افزارهای توکار ‪ ،‬برنامههای دسکتاپ و بازیها مورد استفاده قرار میگیرد‪.‬‬
‫در مقایسه با زبانهای جدید تر ‪ ،‬برنامههای نوشته شده با ‪ C++‬اغلب پیچیده تر میباشند و زمان بیشتری برای توسعه نیاز دارد‪.‬در‬
‫عوض‪C++ ،‬زبانی است که به شما اجازه میدهد که هم به صورت ‪( High-level‬نزدیک به زبان انسان) و هم به صورت‪low-‬‬
‫‪( level‬نزدیک به زبان ماشین ) سخت افزار را تحت کترل خود قرار دهید‪.‬همچنین با پشتیبانی از سبکها یا پارادایمهای مختلف‬
‫برنامه نویسی از جمله روی ه ای ‪ ،‬شی گرا یا عمومی ‪ ،‬دست برنامه نویس را در انتخاب سبک مورد نظرش آزاد میگذارد‪ .‬اکنون ‪5‬‬
‫نسخه از استاندارد این زبان منتشر شده است؛ و استاندارد ‪ C++17‬نیز برای انتشار در سال ‪ 7199‬برنامه ریزی شده است‪.‬‬
‫سال‬ ‫استاندارد‪C++‬‬ ‫نام غیر رسمی‬
‫‪1998‬‬ ‫‪ISO/IEC 14882:1998‬‬ ‫‪C++98‬‬
‫‪2003‬‬ ‫‪ISO/IEC 14882:2003‬‬ ‫‪C++03‬‬
‫‪2007‬‬ ‫‪ISO/IEC TR 19768:2007‬‬ ‫‪C++07/TR1‬‬
‫‪2011‬‬ ‫‪ISO/IEC 14882:2011‬‬ ‫‪C++11‬‬
‫‪2014‬‬ ‫‪ISO/IEC 14882:2014‬‬ ‫‪C++14‬‬
‫‪2017‬‬ ‫هنوز تعیین نشده‪.‬‬ ‫‪C++17‬‬
‫برای اجرای کدهای ‪ C++‬نیاز به یک کامپایلر داریم‪ .‬کامپایلرها و محیطهای برنامه نویسی )‪ (IDE‬گوناگونی برای زبان ‪C++‬‬
‫وجود دارند از بین معروفترین آنها میتوان موارد زیر اشاره نمود‪:‬‬
‫‪Turbo C‬‬ ‫‪‬‬

‫‪Turbo C++‬‬ ‫‪‬‬
‫‪Borland C++‬‬ ‫‪‬‬
‫‪Microsoft C++/C‬‬ ‫‪‬‬
‫‪1‬‬ ‫فصل اول ‪ :‬مبانی زبان سی پالس پالس‬
‫زبان ‪ C++‬وابسته به یک سیستم عامل نیست یعنی شما بعد از نوشتن برنامه خود به زبان‪ ، C++‬اگر کد استانداری نوشته باشید‬
‫میتوانید با توجه به سیستم عامل‪ ،‬کدتان را کامپایل کنید‪ .‬میتوان کد ‪ C++‬را در هر محیطی‪ ،‬مثالً ‪NotePad‬در ویندوز و یا‬
‫‪ gEdit‬در گنو‪/‬لینوکس نوشته و بعد آن را بوسیله یک کامپایلر کامپایل کنیم‪ ،‬ولی برای راحتی کار ما میتوانیم از یک ‪ IDE‬مناسب‪،‬‬
‫نیز بهره ببریم‪ .‬البته در این سری آموزشی ما از راحتترین روش برای کامپایل کدها استفاده میکنیم‪.‬‬
‫نصب و پیکربندی ‪MinGW‬‬
‫همانطور که اشاره شد برای اجرای کدهای ‪ C++‬نیاز به یک کامپایلر داریم‪ .‬کامپایلری که در این سری آموزشی میخواهیم از آن‬
‫استفاده کنیم ‪ MinGW‬میباشد که میتوانید آن را از لینک زیر دانلود کنید‪:‬‬
‫‪dl.w3-farsi.com/Software/Cplusplus/mingw-w64-install.exe‬‬
‫نصب ‪MinGW‬‬
‫بعد از دانلود فایل باال بر روی آن دو بار کلیک کرده و مراحل زیر را برای نصب و پیکربندی آن طی کنید‪:‬‬


‫پیکربندی‪MinGW‬‬
‫بعد از اتمام نصب نوبت به پیکربندی ‪ MinGW‬میرسد‪ .‬در کل باید مسیر پوشه ‪ bin‬نرم افزار ‪ MinGW‬را در متغیر ‪ PATH‬ویندوز‬
‫قرار دهید‪ .‬پوشه ‪ bin‬نرم افزار ‪ MinGW‬ما در مسیر زیر قرار دارد و البته ممکن است برای شما این مسیر متفاوت باشد‪:‬‬
‫‪C:\Program Files (x86)\mingw-w64\i686-6.3.0-posix-dwarf-rt_v5-rev2\mingw32\bin‬‬
‫مسیر پوشه ‪ bin‬را کپی کرده و مراحل زیر را طی کنید‪:‬‬



‫همانطور که در شکل باال مشاهده میکنید بعد از کلیک بر روی متغیر ‪ path‬سپس دکمه ‪ Edit‬پنجره ای به صورت زیر نشان‬
‫داده میشود ‪ .‬نشانگر ماوس را به آخر جعبه متن برده و سپس یک عالمت سیمیکالن (;) گذاشته و مسیر پوشه ‪ bin‬خود را بعد‬
‫از عالمت سمیکالن کپی کنید‪:‬‬
‫در نهایت دکمه ‪ OK‬تمام پنجرههای باز را بزنید‪ .‬با این کار پیکربندی هم به اتمام میرسد‪ .‬در درس بعد نحوه اجرای اولین برنامه‬
‫با سی پالس پالس را به شما آموزش میدهیم‪.‬‬

‫ساخت یک برنامه ساده‬
‫اجازه بدهید یک برنامه بسیار ساده به زبان سی پالس پالس )‪ (C++‬بنویسیم‪ .‬این برنامه یک پیغام را در محیط کنسول نمایش‬
‫میدهد‪ .‬در این درس میخواهم ساختار و دستور زبان یک برنامه ساده ‪ C++‬را توضیح دهم‪ .‬هر چند که محیطهای کدنویسی‬
‫زیادی برای ‪ C++‬وجود دارند ولی ما از سادهترین روش برای کدنویسی استفاده میکنیم‪ .‬برنامه ‪ NotePad‬ویندوز را باز کرده و‬
‫کدهای زیر را در داخل آن بنویسید‪:‬‬
‫>‪#include <iostream‬‬
‫)(‪int main‬‬
‫{‬
‫;"!‪std::cout << "Welcome to C++ Tutorials‬‬
‫}‬
‫حال فایل را با نام ‪ Myapp‬و پسوند ‪ cpp.‬به صورت زیر در درایو ‪ D‬ذخیره کنید‪:‬‬
‫ساختار یک برنامه در‪++ C‬‬
‫مثال باال سادهترین برنامه ای است که شما میتوانید در ‪ C++‬بنویسید ‪.‬هدف در مثال باال نمایش یک پیغام در صفحه نمایش‬
‫است‪ .‬هر زبان برنامه نویسی دارای قواعدی برای کدنویسی است‪ .‬اجازه بدهید هر خط کد را در مثال باال توضیح بدهیم‪ .‬در خط‬
‫اول فایل هدر یا سرایند آمده است‪ .‬فایلهای سرآیند کتابخانه استاندارد ‪ C++‬میباشند و در این برنامه ما به فایل سرایند‬
‫‪iostream‬نیاز داریم (در درسهای آینده در مورد این فایلها به طور مفصل توضیح میدهیم)‪ .‬خط ‪ 1‬متد )(‪ main‬یا متد‬
‫اصلی نامیده میشود‪ .‬هر متد شامل یک سری کد است که وقتی اجرا میشوند که متد را صدا بزنیم‪ .‬درباره متد و نحوه صدا زدن‬
‫آن در فصول بعدی توضیح خواهیم داد‪ .‬متد )(‪ main‬نقطه آغاز اجرای برنامه است‪ .‬این بدان معناست که ابتدا تمام کدهای‬
‫داخل متد )(‪ main‬و سپس بقیه کدها اجرا میشود‪ .‬درباره متد )(‪ main‬در فصول بعدی توضیح خواهیم داد‪ .‬متد )(‪main‬‬
‫و سایر متدها دارای آکوالد و کدهایی در داخل آنها میباشند و وقتی کدها اجرا میشوند که متدها را صدا بزنیم‪ .‬هر خط کد در‬
‫‪C++‬به یک سمیکالن ( ; ) ختم میشود ‪ .‬اگر سمیکالن در آخر خط فراموش شود برنامه با خطا مواجه میشود‪ .‬مثالی از یک خط‬
‫کد در ‪ C++‬به صورت زیر است‪:‬‬
‫این خط کد پیغام !‪Welcome to Visual C++ Tutorials‬را در صفحه نمایش نشان میدهد‪ .‬از شیء ‪ cout‬برای چاپ‬
‫یک رشته استفاده میشود ‪ .‬یک رشته گروهی از کاراکترها است‪ ،‬که به وسیله دابل کوتیشن (“) محصور شده است ‪.‬مانند‬
‫‪:“Welcome to Visual C++ Tutorials!”.‬‬
‫یک کاراکتر میتواند یک حرف‪ ،‬عدد‪ ،‬عالمت یا … باشد‪ .‬در کل مثال باال نحوه استفاده از شیء ‪ cout‬است که در داخل فضای‬
‫نام ‪ std‬قرار دارد را نشان میدهد‪ .‬توضیحات بیشتر در درسهای آینده آمده است ‪. C++‬فضای خالی و خطوط جدید را نادیده‬
‫میگیرد‪ .‬بنابراین شما میتوانید همه برنامه را در یک خط بنویسید‪ .‬اما اینکار خواندن و اشکال زدایی برنامه را مشکل میکند‪ .‬یکی‬
‫از خطاهای معمول در برنامه نویسی فراموش کردن سمیکالن در پایان هر خط کد است ‪.‬به مثال زیر توجه کنید ‪:‬‬
‫<< ‪std::cout‬‬
‫;"!‪"Welcome to C++ Tutorials‬‬
‫سی پالس پالس فضای خالی باال را نادیده میگیرد و از کد باال اشکال نمیگیرد‪ .‬اما از کد زیر ایراد میگیرد‪:‬‬
‫; << ‪std::cout‬‬
‫;"!‪"Welcome to C++ Tutorials‬‬
‫به سمیکالن آخر خط اول توجه کنید‪ .‬برنامه با خطای نحوی مواجه میشود چون دو خط کد مربوط به یک برنامه هستند و شما‬
‫فقط باید یک سمیکالن در آخر آن قرار دهید‪ .‬همیشه به یاد داشته باشید که ‪ C++‬به بزرگی و کوچکی حروف حساس است‪ .‬یعنی‬
‫به طور مثال ‪ MAN‬و ‪ man‬در سی پالس پالس با هم فرق دارند‪ .‬رشتهها و توضیحات از این قاعده مستثنی هستند که در درسهای‬
‫آینده توضیح خواهیم داد‪ .‬مثالً کدهای زیر با خطا مواجه میشوند و اجرا نمیشوند‪:‬‬
‫;"!‪std::cOUT << "Welcome to C++ Tutorials‬‬

‫;"!‪STD::cout << "Welcome to C++ Tutorials‬‬
‫;"!‪Std::Cout << "Welcome to C++ Tutorials‬‬
‫تغییر در بزرگی و کوچکی حروف از اجرای کدها جلوگیری میکند‪ .‬اما کد زیر کامالً بدون خطا است‪:‬‬
‫همیشه کدهای خود را در داخل آکوالد بنویسید‪.‬‬
‫{‬
‫;‪statement1‬‬
‫}‬
‫این کار باعث میشود که کدنویسی شما بهتر به چشم بیاید و تشخیص خطاها راحت تر باشد‪.‬‬
‫کامپایل و اجرای برنامه‬
‫برای کامپایل و اجرای برنامه‪cmd ،‬ویندوز را باز کرده و سپس به درایو ‪ D‬یعنی جایی که فایل را ذخیره کردهاید بروید‪:‬‬
‫]‪Microsoft Windows [Version 6.1.7601‬‬

‫‪Copyright (c) 2009 Microsoft Corporation.‬‬ ‫‪All rights reserved.‬‬
‫‪C:\Users\YounesCsharp>D:‬‬
‫>\‪D:‬‬
‫حال برای کامپایل برنامه کد زیر را نوشته و دکمه ‪ Enter‬را بزنید‪:‬‬

‫‪D:\>g++ MyApp.cpp -o MyApp.exe‬‬
‫و در نهایت برای اجرای برنامه کد زیر را بنویسید‪:‬‬

‫‪D:\>g++ MyApp.cpp -o MyApp.exe‬‬
‫‪D:\>MyApp.exe‬‬
‫!‪Welcome to C++ Tutorials‬‬
‫>\‪D:‬‬
‫مشاهده میکنید که پیغام ‪ !Welcome to C++ Tutorials‬چاپ میشود‪.‬‬
‫وارد کردن فضای نام در برنامه‬
‫در برنامه فوق ما یک فضای نام در برنامه مان با نام ‪ std‬داریم‪ ،‬اما سی پالس پالس دارای تعداد زیادی فضای نام میباشد‪ .‬یکی‬
‫از این فضاهای نامی ‪ ،‬فضای نام ‪ std‬است که شیء ‪ cout‬که ما از آن در برنامه باال استفاده کردیم در این فضای نام قرار دارد‪.‬‬
‫اینکه قبل از استفاده از هر کالس ابتدا فضای نام آن را مانند کد باال بنویسیم کمی خسته کننده است‪ .‬خوشبختانه ‪ C++‬به ما اجازه‬
‫میدهد که برای جلوگیری از تکرار مکررات‪ ،‬فضاهای نامی را که قرار است در برنامه استفاده کنیم با استفاده از دستور ‪ using‬و‬
‫کلمه ‪ namespace‬در ابتدای برنامه وارد نماییم‪:‬‬
‫;‪using namespace NameofNameSpace‬‬
‫دستور باال نحوه وارد کردن یک فضای نام در برنامه را نشان میدهد ‪ .‬در نتیجه به جای آنکه به صورت زیر ابتدا نام فضای نام و‬
‫سپس نام کالس را بنویسیم‪:‬‬
‫میتوانیم فضای نام را با دستوری که ذکر شد وارد برنامه کرده و کد باال را به صورت خالصه شده زیر بنویسیم‪:‬‬
‫;"!‪cout << "Welcome to C++ Tutorials‬‬

‫ً‬
‫عموما در ابتدای برنامه و قبل از همه کدها نوشته‬ ‫دستورات ‪ using‬که باعث وارد شدن فضاهای نامی به برنامه میشوند‬
‫میشوند‪ ،‬پس برنامه این درس را میتوان به صورت زیر نوشت‪:‬‬
‫;‪using namespace std‬‬
‫{‬
‫;"!‪cout << "Welcome to C++ Tutorials‬‬
‫}‬
‫حال که با خصوصیات و ساختار اولیه ‪ C++‬آشنا شدید در درسهای آینده مطالب بیشتری از این زبان برنامه نویسی قدرتمند‬
‫خواهید آموخت‪.‬‬
‫توضیحات‬
‫وقتی که کدی تایپ میکنید شاید بخواهید که متنی جهت یادآوری وظیفه آن کد به آن اضافه کنید‪ .‬در ‪( C++‬و بیشتر زبانهای‬
‫برنامه نویسی) میتوان این کار را با استفاده از توضیحات انجام داد‪ .‬توضیحات متونی هستند که توسط کامپایلر نادیده گرفته‬
‫میشوند و به عنوان بخشی از کد محسوب نمیشوند‪.‬‬
‫هدف اصلی ا ز ایجاد توضیحات‪ ،‬باال بردن خوانایی و تشخیص نقش کدهای نوشته شده توسط شما‪ ،‬برای دیگران است‪ .‬فرض کنید‬
‫که میخواهید در مورد یک کد خاص‪ ،‬توضیح بدهید‪ ،‬میتوانید توضیحات را در باالی کد یا کنار آن بنویسید‪ .‬از توضیحات برای‬
‫مستند سازی برنامه هم استفاده میشود‪ .‬در برنامه زیر نقش توضیحات نشان داده شده است‪:‬‬
‫‪1‬‬ ‫>‪#include <iostream‬‬

‫‪2‬‬ ‫;‪using namespace std‬‬
‫‪3‬‬
‫‪4‬‬ ‫)(‪int main‬‬
‫‪5‬‬ ‫{‬
‫‪6‬‬ ‫‪// This line will print the message hello world‬‬
‫‪7‬‬ ‫;"!‪cout << "Hello World‬‬
‫‪8‬‬ ‫}‬
‫در کد باال‪ ،‬خط ‪ 1‬یک توضیح درباره خط ‪ 9‬است که به کاربر اعالم میکند که وظیفه خط ‪ 9‬چیست؟ با اجرای کد باال فقط جمله‬
‫‪Hello World‬چاپ شده و خط ‪ 9‬در خروجی نمایش داده نمیشود چون کامپایلر توضیحات را نادیده میگیرد ‪.‬توضیحات بر‬
‫دو نوعاند‪:‬‬
‫توضیحات تک خطی‬
‫‪// single line comment‬‬
‫توضیحات چند خطی‬

‫‪/* multi‬‬
‫‪line‬‬
‫‪comment */‬‬
‫توضیحات تک خطی همانگونه که از نامش پیداست‪ ،‬برای توضیحاتی در حد یک خط به کار میروند‪ .‬این توضیحات با عالمت ‪//‬‬
‫شروع میشوند و هر نوشته ای که در سمت راست آن قرار بگیرد جز توضیحات به حساب میآید‪ .‬این نوع توضیحات معموال ً در باال‬
‫یا کنار کد قرار میگیرند‪ .‬اگر توضیح درباره یک کد به بیش از یک خط نیاز باشد از توضیحات چند خطی استفاده میشود‪ .‬توضیحات‬
‫چند خطی با ‪*/‬شروع و با ‪ */‬پایان مییابند‪ .‬هر نوشته ای که بین این دو عالمت قرار بگیرد جز توضیحات محسوب میشود‪.‬‬
‫کاراکترهای کنترلی‬
‫کاراکترهای کنترلی کاراکترهای ترکیبی هستند که با یک بک اسلش )\( شروع میشوند و به دنبال آنها یک حرف یا عدد میآید‬
‫و یک رشته را با فرمت خاص نمایش میدهند‪ .‬برای مثال برای ایجاد یک خط جدید و قرار دادن رشته در آن میتوان از کاراکتر‬
‫کنترلی ‪\n‬استفاده کرد‪:‬‬
‫{‬
‫;"‪cout << "Hello\nWorld‬‬
‫}‬
‫‪Hello‬‬
‫‪World‬‬
‫مشاهده کردید که کامپایلر بعد از مواجهه با کاراکتر کنترلی ‪ \n‬نشانگر ماوس را به خط بعد برده و بقیه رشته را در خط بعد‬
‫نمایش میدهد‪ .‬جدول زیر لیست کاراکترهای کنترلی و کارکرد آنها را نشان میدهد‪:‬‬
‫کاراکتر کنترلی‬ ‫عملکرد‬ ‫کاراکتر کنترلی‬ ‫عملکرد‬
‫’\‬ ‫چاپ کوتیشن‬ ‫‪\f‬‬ ‫‪Form Feed‬‬
‫”\‬ ‫چاپ دابل کوتیشن‬ ‫‪\n‬‬ ‫خط جدید‬
‫\\‬ ‫چاپ بک اسلش‬ ‫‪\r‬‬ ‫سر سطر رفتن‬
‫‪\0‬‬ ‫چاپ فضای خالی‬ ‫‪\t‬‬ ‫حرکت به صورت افقی‬
‫‪\a‬‬ ‫صدای بیپ‬ ‫‪\v‬‬ ‫حرکت به صورت عمودی‬

‫‪\b‬‬ ‫حرکت به عقب‬ ‫‪\u‬‬ ‫چاپ کاراکتر یونیکد‬
‫ما برای استفاده از کاراکترهای کنترلی از بک اسلش )\( استفاده میکنیم‪.‬از آنجاییکه \ معنای خاصی به رشتهها میدهد برای‬
‫چاپ بک اسلش )\( باید از )\\( استفاده کنیم‪:‬‬
‫;"‪cout << "We can print a \\ by using the \\\\ escape sequence.‬‬
‫‪We can print a \ by using the \\ escape sequence.‬‬
‫یکی از موارد استفاده از \\‪ ،‬نشان دادن مسیر یک فایل در ویندوز است‪:‬‬
‫;"‪cout << "C:\\Program Files\\Some Directory\\SomeFile.txt‬‬
‫‪C:\Program Files\Some Directory\SomeFile.txt‬‬
‫از آنجاییکه از دابل کوتیشن )“( برای نشان دادن رشتهها استفاده میکنیم برای چاپ آن از ”\استفاده میکنیم‪:‬‬
‫;"‪cout << "I said, \"Motivate yourself!\".‬‬
‫‪I said, "Motivate yourself!".‬‬
‫همچنین برای چاپ کوتیشن )‘( از ’\استفاده میکنیم‪:‬‬
‫;"‪cout << "The programmer\'s heaven.‬‬
‫‪The programmer's heaven.‬‬
‫برای ایجاد فاصله بین حروف یا کلمات از ‪\t‬استفاده میشود‪:‬‬
‫;"‪cout << "Left\tRight‬‬
‫‪Left‬‬ ‫‪Right‬‬
‫هر تعداد کاراکتر که بعد از کاراکتر کنترلی ‪ \r‬بیایند به اول سطر منتقل و جایگزین کاراکترهای موجود میشوند‪:‬‬
‫;"‪cout << "Mitten\rK‬‬
‫‪Kitten‬‬
‫مثالً در مثال باال کاراکتر ‪ K‬بعد از کاراکتر کنترلی ‪ \r‬آمده است‪.‬کاراکتر کنترلی حرف ‪ K‬را به ابتدای سطر برده و جایگزین حرف ‪M‬‬
‫میکند‪ .‬برای چاپ کاراکترهای یونیکد میتوان از ‪\u‬استفاده کرد‪ .‬برای استفاده از ‪،\u‬مقدار در مبنای ‪ 91‬کاراکتر را درست بعد از‬
‫عالمت ‪ \u‬قرار میدهیم‪.‬برای مثال اگر بخواهیم عالمت)⌐┬( را چاپ کنیم باید بعد از عالمت ‪ \u‬مقدار ‪ A9 11‬را قرار دهیم مانند‬
‫‪:‬‬
‫;"‪cout << "\u00A9‬‬
‫⌐┬‬
‫برای مشاهده لیست مقادیر مبنای ‪ 91‬برای کاراکترهای یونیکد به لینک زیر مراجعه نمایید‪:‬‬
‫‪http://www.ascii.cl/htmlcodes.htm‬‬
‫اگر کامپایلر به یک کاراکتر کنترلی غیر مجاز برخورد کند‪ ،‬برنامه پیغام خطا میدهد‪.‬بیشترین خطا زمانی اتفاق میافتد که برنامه‬
‫نویس برای چاپ اسلش )\( از \\ استفاده میکند ‪ .‬برای دریافت اطالعات بیشتر در مورد کاراکترهای کنترلی به لینک زیر مراجعه‬
‫کنید‪:‬‬
‫‪https://msdn.microsoft.com/en-us/library/h21280bw.aspx‬‬
‫متغیر‬
‫متغیر مکانی از حافظه است که شما میتوانید مقادیری را در آن ذخیره کنید‪.‬میتوان آن را به عنوان یک ظرف تصور کرد که دادههای‬
‫خود را در آن قرار دادهاید‪.‬محتویات این ظرف میتواند پاک شود یا تغییر کند‪.‬هر متغیر دارای یک نام نیز هست‪.‬که از طریق آن‬
‫میتوان متغیر را از دیگر متغیرها تشخیص داد و به مقدار آن دسترسی پیدا کرد‪.‬همچنین دارای یک مقدار میباشد که میتواند‬
‫توسط کاربر انتخاب شده باشد یا نتیجه یک محاسبه باشد‪.‬مقدار متغیر میتواند تهی نیز باشد‪.‬متغیر دارای نوع نیز هست بدین‬
‫معنی که نوع آن با نوع داده ای که در آن ذخیره میشود یکی است‪ .‬متغیر دارای عمر نیز هست که از روی آن میتوان تشخیص‬
‫داد که متغیر باید چقدر در طول برنامه مورد استفاده قرار گیرد‪.‬و در نهایت متغیر دارای محدوده استفاده نیز هست که به شما‬
‫میگوید که متغیر در چه جای برنامه برای شما قابل دسترسی است‪.‬ما از متغیرها به عنوان یک انبار موقتی برای ذخیره داده استفاده‬
‫میکنیم‪ .‬هنگامی که یک برنامه ایجاد میکنیم اح تیاج به یک مکان برای ذخیره داده ‪،‬مقادیر یا دادههایی که توسط کاربر وارد‬
‫میشوند داریم‪.‬ایم مکان همان متغیر است‪ .‬برای این از کلمه متغیر استفاده میشود چون ما میتوانیم بسته به نوع شرایط هر جا‬
‫که الزم باشد مقدار آن را تغییر دهیم‪ .‬متغیرها موقتی هستند و فقط موقعی مورد استفاده قرار میگیرند که برنامه در حال اجراست‬
‫و وقتی شما برنامه را میبندید محتویات متغیرها نیز پاک میشود‪ .‬قبالً ذکر شد که به وسیله نام متغیر میتوان به آن دسترسی‬
‫پیدا کرد‪ .‬برای نامگذاری متغیرها باید قوانین زیر را رعایت کرد‪:‬‬
‫نام متغیر باید با یک از حروف الفبا )‪ (a-z or A-Z‬شروع شود‪.‬‬ ‫‪‬‬
‫نمیتواند شامل کاراکترهای غیرمجاز مانند ‪#, ?, ^, $.‬باشد‪.‬‬ ‫‪‬‬

‫نمیتوان از کلمات رزرو شده در ‪ C++‬برای نام متغیر استفاده کرد‪.‬‬ ‫‪‬‬
‫نام متغیر نباید دارای فضای خالی )‪ (spaces‬باشد‪.‬‬ ‫‪‬‬
‫اسامی متغیرها نسبت به بزرگی و کوچکی حروف حساس هستند‪ .‬در ‪ C++‬دو حرف مانند ‪a‬و ‪A‬دو کاراکتر مختلف‬ ‫‪‬‬
‫به حساب میآیند‪.‬‬
‫دو متغیر با نامهای ‪ myNumber‬و ‪ MyNumber‬دو متغیر مختلف محسوب میشوند چون یکی از آنها با حرف کوچک ‪m‬و دیگری‬
‫با حرف بزرگ ‪M‬شروع میشود‪ .‬شما نمیتوانید دو متغیر را که دقیق شبیه هم هستند را در یک ‪( scope‬محدوده) تعریف کنید‪.‬‬
‫‪ Scope‬به معنای یک بلوک کد است که متغیر در آن قابل دسترسی و استفاده است‪ .‬در مورد ‪ Scope‬در فصلهای آینده بیشتر‬
‫توضیح خواهیم داد‪ .‬متغیر دارای نوع هست که نوع داده ای را که در خود ذخیره میکند را نشان میدهد‪ .‬معمولترین انواع داده‬
‫‪int, double, string, char, float‬میباشند ‪ .‬برای مثال شما برای قرار دادن یک عدد صحیح در متغیر باید از نوع‬
‫‪int‬استفاده کنید‪.‬‬
‫انواع ساده‬
‫انواع ساده انواعی از دادهها هستند که شامل اعداد‪ ،‬کاراکترها و رشتهها و مقادیر بولی میباشند‪ .‬به انواع ساده انواع اصلی نیز‬
‫گفته میشود چون از آنها برای ساخت انواع پیچیده تری مانند کالسها و ساختارها استفاده میشود‪ .‬انواع ساده دارای مجموعه‬
‫مشخصی از مقادیر هستند و محدوده خاصی از اعداد را در خود ذخیره میکنند‪ .‬در ‪ C++‬هفت نوع داده وجود دارد که در جدول‬
‫زیر ذکر شدهاند‪:‬‬
‫نوع‬ ‫کلمه کلیدی‬
‫‪Boolean‬‬ ‫‪bool‬‬
‫‪Character‬‬ ‫‪char‬‬
‫‪Integer‬‬ ‫‪int‬‬
‫‪Floating point‬‬ ‫‪float‬‬
‫‪Double floating point‬‬ ‫‪double‬‬
‫‪Valueless‬‬ ‫‪void‬‬
‫‪Wide character‬‬ ‫‪wchar_t‬‬

‫انواع باال ( به جز ‪ )void‬میتوانند با عباراتی مثل ‪unsigned ،long ، signed‬و ‪ short‬ترکیب شده و نوعهای دیگری را‬
‫به وجود آورند‪:‬‬
‫نوع‬ ‫مقدار فضایی که از حافظه اشغال میکند‬ ‫محدوده‬
‫‪char‬‬ ‫‪1byte‬‬ ‫‪-128 to 127 or 0 to 255‬‬
‫‪unsigned char‬‬ ‫‪1byte‬‬ ‫‪0 to 255‬‬
‫‪signed char‬‬ ‫‪1byte‬‬ ‫‪-128 to 127‬‬
‫‪int‬‬ ‫‪4bytes‬‬ ‫‪-2147483648 to 2147483647‬‬
‫‪unsigned int‬‬ ‫‪4bytes‬‬ ‫‪0 to 4294967295‬‬
‫‪signed int‬‬ ‫‪4bytes‬‬ ‫‪-2147483648 to 2147483647‬‬
‫‪short int‬‬ ‫‪2bytes‬‬ ‫‪-32768 to 32767‬‬
‫‪unsigned short‬‬
‫‪2bytes‬‬ ‫‪0 to 65,535‬‬
‫‪int‬‬
‫‪signed short‬‬
‫‪2bytes‬‬ ‫‪-32768 to 32767‬‬
‫‪int‬‬
‫‪-9,223,372,036,854,775,808 to‬‬
‫‪long int‬‬ ‫‪8bytes‬‬
‫‪9,223,372,036,854,775,807‬‬
‫‪-9,223,372,036,854,775,808 to‬‬
‫‪signed long int‬‬ ‫‪8bytes‬‬
‫‪9,223,372,036,854,775,807‬‬
‫‪unsigned long‬‬
‫‪8bytes‬‬ ‫‪0 to 18,446,744,073,709,551,615‬‬
‫‪int‬‬
‫‪float‬‬ ‫‪4bytes‬‬ ‫)‪+/- 3.4e +/- 38 (~7 digits‬‬
‫‪double‬‬ ‫‪8bytes‬‬ ‫)‪+/- 1.7e +/- 308 (~15 digits‬‬
‫‪long double‬‬ ‫‪8bytes‬‬ ‫)‪+/- 1.7e +/- 308 (~15 digits‬‬
‫‪wchar_t‬‬ ‫‪2 or 4 bytes‬‬ ‫‪1 wide character‬‬
‫نوع ‪ char‬برای ذخیره کاراکترهای یونیکد استفاده میشود ‪.‬کاراکترها باید داخل یک کوتیشن ساده قرار بگیرند مانند‪(‘a’).‬‬
‫نوع ‪ bool‬فقط میتواند مقادیر درست )‪ (true‬یا نادرست )‪ (false‬را در خود ذخیره کند و بیشتر در برنامههایی که دارای‬
‫ساختار تصمیم گیری هستند مورد استفاده قرار میگیرد‪.‬‬

www.SourceSara.com ‫ آﻣﻮزش ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ و ﺳﻮرس ﮐﺪﻫﺎي آﻣﺎده‬- ‫ﺳﺎﯾﺖ ﺳﻮرس ﺳﺮا‬
C ‫ تخصصی ترین سایت آموزش زبان های خانواده‬w3-farsi.com 71
‫ مقادیر ذخیره شده در یک رشته باید داخل دابل‬.‫برای ذخیره گروهی از کاراکترها مانند یک پیغام استفاده میشود‬string ‫نوع‬
(“massage”)‫ مانند‬.‫کوتیشن قرار گیرند تا توسط کامپایلر به عنوان یک رشته در نظر گرفته شوند‬
‫استفاده از متغیرها‬
:‫در مثال زیر نحوه تعریف و مقدار دهی متغیرها نمایش داده شده است‬
#include <iostream>
using namespace std;
int main()
{
//Declare variables
int num1;
int num2;
double num3;
double num4;
bool boolVal;
char myChar;
string message;
//Assign values to variables

num1 = 1;
num2 = 2;
num3 = 3.54;
num4 = 4.12;
boolVal = true;
myChar = 'R';
message = "Hello World!";
//Show the values of the variables

cout << "num1 = " << num1 << endl;
cout << "boolVal = " << boolVal << endl;
cout << "myChar = " << myChar << endl;
cout << "message = " << message << endl;
}
‫تعریف متغیر‬
‫در کد باال متغیرهایی با نوع و نام متفاوت تعریف شدهاند‪ .‬ابتدا باید نوع دادههایی را که این متغیرها قرار است در خود ذخیره کنند‬
‫را مشخص کنیم و سپس یک نام برای آنها در نظر بگیریم و در آخر سیمیکولن بگذاریم‪.‬همیشه به یاد داشته باشید که قبل از مقدار‬
‫دهی و استفاده از متغیر باید آن را تعریف کرد‪ .‬شاید برایتان این سؤال پیش آمده باشد که کاربرد ‪ endl‬چیست؟ ‪ endl‬برای‬
‫ایجاد خط جدید مورد استفاده قرار گرفته است‪ .‬یعنی نشانگر ماوس را همانند کاراکتر کنترلی \‪ n‬به خط بعد میبرد‪ ،‬در نتیجه‬
‫خروجی کد باال در خطوط جداگانه چاپ میشود ‪.‬‬
‫‪//Declare variables‬‬
‫;‪int num1‬‬
‫;‪double num3‬‬
‫;‪double num4‬‬
‫;‪bool boolVal‬‬
‫;‪char myChar‬‬
‫;‪string message‬‬
‫نحوه تعریف متغیر به صورت زیر است ‪:‬‬
‫;‪data_type identifier‬‬
‫‪ date_type‬همان نوع داده است مانند ‪double ، int‬و ‪ dentifier .….‬نیز نام متغیر است که به ما امکان استفاده و‬
‫دسترسی به مقدار متغیر را میدهد ‪.‬برای تعریف چند متغیر از یک نوع میتوان به صورت زیر عمل کرد‪:‬‬
‫;‪data_type identifier1, identifier2, ... indentifierN‬‬
‫مثال‬
‫;‪int num1, num2, num3, num4, num5‬‬

‫;‪string message1, message2, message3‬‬
‫در مثال باال ‪ 5‬متغیر از نوع صحیح و ‪ 1‬متغیر از نوع رشته تعریف شده است‪.‬توجه داشته باشید که بین متغیرها باید عالمت کاما‬
‫)‪(,‬باشد‪.‬‬
‫نامگذاری متغیرها‬
‫نام متغیر باید با یک حرف یا زیرخط و به دنبال آن حرف یا عدد شروع شود‪.‬‬ ‫‪‬‬
‫نمیتوان از کاراکترهای خاص مانند & ‪#, %,‬یا عدد برای شروع نام متغیر استفاده کرد مانند ‪2numbers.‬‬ ‫‪‬‬
‫نام متغیر نباید دارای فاصله باشد‪.‬برای نامهای چند حرفی میتوان به جای فاصله از عالمت زیرخط یا _استفاده کرد‪.‬‬ ‫‪‬‬
‫نامهای مجاز‪:‬‬
‫‪num1‬‬ ‫‪myNumber‬‬ ‫‪studentCount‬‬ ‫‪total‬‬ ‫‪first_name‬‬ ‫‪_minimum‬‬

‫‪num2‬‬ ‫‪myChar‬‬ ‫‪average‬‬ ‫‪amountDue‬‬ ‫‪last_name‬‬ ‫‪_maximum‬‬
‫‪name‬‬ ‫‪counter‬‬ ‫‪sum‬‬ ‫‪isLeapYear‬‬ ‫‪color_of_car‬‬ ‫‪_age‬‬
‫نامهای غیر مجاز‪:‬‬
‫‪123‬‬ ‫‪#numbers#‬‬ ‫‪#ofstudents‬‬ ‫‪1abc2‬‬

‫‪123abc‬‬ ‫‪$money‬‬ ‫‪first name‬‬ ‫‪ty.np‬‬
‫‪my number‬‬ ‫‪this&that‬‬ ‫‪last name‬‬ ‫‪1:00‬‬
‫اگر به نامهای مجاز در مثال باال توجه کنید متوجه قراردادهای به کار رفته در نامگذاری آنها خواهید شد‪.‬یکی از روشهای نامگذاری‪،‬‬
‫نامگذاری کوهان شتری است‪.‬در این روش که برای متغیرهای دو کلمه ای به کار میرود‪،‬اولین حرف اولین کلمه با حرف کوچک و‬
‫اولین حرف دومین کلمه با حرف بزرگ نمایش داده میشود مانند ‪ . myNumber:‬توجه کنید که اولین حرف کلمه ‪ Number‬با حرف‬
‫بزرگ شروع شده است‪ .‬مثال دیگر کلمه ‪ numberOfStudents‬است‪.‬اگز توجه کنید بعد از اولین کلمه حرف اول سایر کلمات با‬
‫حروف بزرگ نمایش داده شده است‪.‬‬
‫محدوده متغیر‬
‫متغیرهای ابتدای درس در داخل متد )(‪ main‬تعریف شدهاند‪ .‬در نتیجه این متغیرها فقط در داخل متد )(‪ main‬قابل دسترسی‬
‫هستند‪ .‬محدوده یک متغیر مشخص میکند که متغیر در کجای کد قابل دسترسی است‪ .‬هنگامیکه برنامه به پایان متد )(‪main‬‬
‫میرسد متغیرها از محدوده خارج و بدون استفاده میشوند تا زمانی که برنامه در حال اجراست‪.‬محدوده متغیرها انواعی دارد که‬
‫در درسهای بعدی با آنها آشنا میشوید‪ .‬تشخیص محدوده متغیر بسیار مهم است چون به وسیله آن میفهمید که در کجای کد‬
‫میتوان از متغیر استفاده کرد‪ .‬باید یاد آور شد که دو متغیر در یک محدوده نمیتوانند دارای نام یکسان باشند‪ .‬مثالً کد زیر در برنامه‬
‫ایجاد خطا میکند‪:‬‬
‫از آنجاییکه ‪ C++‬به بزرگی و کوچک بودن حروف حساس است میتوان از این خاصیت برای تعریف چند متغیر هم نام ولی با‬
‫حروف متفاوت (از لحاظ بزرگی و کوچکی) برای تعریف چند متغیر از یک نوع استفاده کرد مانند‪:‬‬
‫;‪int Num1‬‬
‫;‪int NUM1‬‬
‫مقداردهی متغیرها‬
‫ً‬
‫فورا بعد از تعریف متغیرها مقادیری را به آنها اختصاص داد‪.‬این عمل را مقداردهی مینامند‪ .‬در زیر نحوه مقدار دهی‬ ‫میتوان‬
‫متغیرها نشان داده شده است‪:‬‬
‫;‪data_type identifier = value‬‬
‫به عنوان مثال‪:‬‬
‫;‪int myNumber = 7‬‬
‫همچنین میتوان چندین متغیر را فقط با گذاشتن کاما بین آنها به سادگی مقدار دهی کرد‪:‬‬
‫;‪data_type variable1 = value1, varaible2 = value2, ... variableN, valueN‬‬

‫;‪int num1 = 1, num2 = 2, num3 = 3‬‬
‫تعریف متغیر با مقدار دهی متغیرها متفاوت است‪ .‬تعریف متغیر یعنی انخاب نوع و نام برای متغیر ولی مقدار دهی یعنی اختصاص‬
‫یک مقدار به متغیر‪.‬‬
‫اختصاص مقدار به متغیر‬
‫در زیر نحوه اختصاص مقادیر به متغیرها نشان داده شده است‪:‬‬
‫;‪num1 = 1‬‬
‫;‪num2 = 2‬‬
‫;‪num3 = 3.54‬‬
‫;‪num4 = 4.12‬‬
‫;‪boolVal = true‬‬
‫;'‪myChar = 'R‬‬
‫;"!‪message = "Hello World‬‬
‫به این نکته توجه کنید که شما به مغیری که هنوز تعریف نشده نمیتوانید مقدار بدهید‪ .‬شما فقط میتوانید از متغیرهایی استفاده‬
‫کنید که هم تعریف و هم مقدار دهی شده باشند‪ .‬مثالً متغیرهای باال همه قابل استفاده هستند‪ .‬در این مثال ‪ num1‬و ‪ num2‬هر دو‬
‫تعریف شدهاند و مقادیری از نوع صحیح به آنها اختصاص داده شده است‪ .‬اگر نوع داده با نوع متغیر یکی نباشد برنامه پیغام‬
‫خطا میدهد‪.‬‬
‫ثابت‬
‫ً‬
‫حتما باید مقدار دهی اولیه شوند و اگر مقدار دهی‬ ‫ثابتها انواعی هستند که مقدار آنها در طول برنامه تغییر نمیکند‪ .‬ثابتها‬
‫آنها فراموش شود در برنامه خطا به وجود میآید‪ .‬بعد از این که به ثابتها مقدار اولیه اختصاص داده شد هرگز در زمان اجرای‬
‫برنامه نمیتوان آن را تغییر داد ‪.‬برای تعریف ثابتها باید از کلمه کلیدی ‪ const‬و ‪ define#‬استفاده کرد ‪.‬معموال ً نام ثابتها‬
‫را طبق قرارداد با حروف بزرگ مینویسند تا تشخیص آنها در برنامه راحت باشد‪ .‬نحوه تعریف ثابت در زیر آمده است‪:‬‬
‫;‪const data_type identifier = initial_value‬‬
‫در کد باال ابتدا کلمه کلیدی ‪ const‬و سپس نوع ثابت و بعد نام ثابت را با حروف بزرگ مینویسیم‪ .‬و در نهایت یک مقدار را به‬
‫آن اختصاص میدهیم و عالمت سمیکالن میگذاریم‪.‬‬
‫‪#define data_type identifier initial_value‬‬
‫در روش باال فقط ‪ define#‬را نوشته و سپس نام ثابت و بعد مقداری که قرار است دریافت کند‪ .‬به این نکته توجه کنید که در‬
‫روش باال نه عالمت سمیکالن وجود دارد و نه عالمت مساوی‪ .‬مثال‪:‬‬
‫{‬
‫;‪const int NUMBER = 1‬‬
‫‪NUMBER = 20; //ERROR, Cant modify a constant‬‬
‫;‪cout << NUMBER‬‬

‫}‬
‫{‬
‫‪#define NUMBER 1‬‬
‫‪NUMBER = 20; //ERROR, Cant modify a constant‬‬
‫;‪cout << NUMBER‬‬

‫}‬
‫در این مثال میبینید که مقدار دادن به یک ثابت ‪،‬که قبالً مقدار دهی شده برنامه را با خطا مواجه میکند‪.‬نکته دیگری که نباید‬
‫فراموش شود این است که نب اید مقدار ثابت را با مقدار دیگر متغیرهای تعریف شده در برنامه برابر قرار داد‪.‬‬
‫مثال‪:‬‬
‫;‪int someVariable‬‬
‫;‪const int MY_CONST = someVariable‬‬
‫ممکن است این سؤال برایتان پیش آمده باشد که دلیل استفاده از ثابتها چیست؟ اگر مطمئن هستید که مقادیری در برنامه‬
‫وجود دارند که هرگز در طول برنامه تغییر نمیکنند بهتر است که آنها را به صورت ثابت تعریف کنید‪.‬این کار هر چند کوچک کیفیت‬
‫برنامه شما را باال میبرد‪.‬‬
‫عبارات و عملگرها‬
‫ابتدا با دو کلمه آشنا شوید‪:‬‬
‫عملگر ‪ :‬نمادهایی هستند که اعمال خاص انجام میدهند‪.‬‬ ‫‪‬‬
‫عملوند ‪ :‬مقادیری که عملگرها بر روی آنها عملی انجام میدهند‪.‬‬ ‫‪‬‬
‫مثالً ‪ :X+Y‬یک عبارت است که در آن ‪ X‬و ‪ Y‬عملوند و عالمت ‪ +‬عملگر به حساب میآیند‪.‬‬
‫زبانهای برنامه نویسی جدید دارای عملگرهایی هستند که از اجزاء معمول زبان به حساب میآیند ‪. C++‬دارای عملگرهای مختلفی‬
‫از جمله عملگرهای ریاضی‪ ،‬تخصیصی ‪ ،‬مقایسه ای‪ ،‬منطقی و بیتی میباشد‪ .‬از عملگرهای ساده ریاضی میتوان به عملگر جمع و‬
‫تفریق اشاره کرد‪ .‬سه نوع عملگر در ‪ C++‬وجود دارد‪:‬‬
‫یگانی – )‪ (Unary‬به یک عملوند نیاز دارد‬ ‫‪‬‬
‫دودویی – )‪(Binary‬به دو عملوند نیاز دارد‬ ‫‪‬‬
‫سه تایی – )‪ (Ternary‬به سه عملوند نیاز دارد‬ ‫‪‬‬
‫انواع مختلف عملگر که در این بخش مورد بحث قرار میگیرند عبارتاند از‪:‬‬
‫عملگرهای ریاضی‬ ‫‪‬‬
‫عملگرهای تخصیصی‬ ‫‪‬‬

‫عملگرهای مقایسه ای‬ ‫‪‬‬
‫عملگرهای منطقی‬ ‫‪‬‬
‫عملگرهای بیتی‬ ‫‪‬‬
‫عملگرهای ریاضی‬ ‫‪‬‬
‫عملگرهای ریاضی‬
‫‪ C++‬از عملگرهای ریاضی برای انجام محاسبات استفاده میکند‪ .‬جدول زیر عملگرهای ریاضی سی پالس پالس را نشان میدهد‪:‬‬
‫نتیجه‬ ‫مثال‬ ‫دسته‬ ‫عملگر‬
‫‪Var1‬برابر است با حاصل جمع ‪var2‬و ‪var3‬‬ ‫;‪var1 = var2 + var3‬‬ ‫‪Binary‬‬ ‫‪+‬‬
‫‪Var1‬برابر است با حاصل تفریق ‪var2‬و ‪var3‬‬ ‫;‪var1 = var2 – var3‬‬ ‫‪Binary‬‬ ‫‪-‬‬
‫‪Var1‬برابر است با حاصلضرب ‪var2‬در ‪var3‬‬ ‫;‪var1 = var2 * var3‬‬ ‫‪Binary‬‬ ‫*‬
‫‪Var1‬برابر است با حاصل تقسیم ‪var2‬بر ‪var3‬‬ ‫;‪var1 = var2 / var3‬‬ ‫‪Binary‬‬ ‫‪/‬‬
‫‪Var1‬برابر است با باقیمانده تقسیم ‪var2‬و ‪var3‬‬ ‫;‪var1 = var2 % var3‬‬ ‫‪Binary‬‬ ‫‪%‬‬
‫‪Var1‬برابر است با مقدار ‪var2‬‬ ‫;‪var1 = +var2‬‬ ‫‪Unary‬‬ ‫‪+‬‬
‫‪Var1‬برابر است با مقدار ‪var2‬ضربدر ‪- 1‬‬ ‫‪var1 = -var2‬‬ ‫‪Unary‬‬ ‫‪-‬‬
‫مثال باال در از نوع عددی استفاده شده است‪.‬اما استفاده از عملگرهای ریاضی برای نوع رشته ای نتیجه متفاوتی دارد‪ .‬همچنین در‬
‫جمع دو کاراکتر کامپایلر معادل عددی آنها را نشان میدهد‪ .‬دیگر عملگرهای ‪ C++‬عملگرهای کاهش و افزایش هستند‪.‬این‬
‫عملگرها مقدار ‪ 9‬را از متغیرها کم یا به آنها اضافه میکنند‪ .‬از این متغیرها اغلب در حلقهها استفاده میشود‪:‬‬
‫مقدار ‪ var1‬برابر است با ‪ var2‬بعالوه ‪1‬‬ ‫;‪var1 = ++var2‬‬ ‫‪Unary‬‬ ‫‪++‬‬
‫مقدار ‪ var1‬برابر است با ‪ var2‬منهای ‪1‬‬ ‫;‪var1 = – -var2‬‬ ‫‪Unary‬‬ ‫‪- -‬‬
‫با‪var2‬‬ ‫است‬ ‫برابر‬ ‫‪var1‬‬ ‫مقدار‬

‫;‪var1 = var2++‬‬ ‫‪Unary‬‬ ‫‪++‬‬
‫به متغیر ‪ var2‬یک واحد اضافه میشود‬
‫با‪var2‬‬ ‫است‬ ‫برابر‬ ‫‪var1‬‬ ‫مقدار‬

‫;–‪var1 = var2‬‬ ‫‪Unary‬‬ ‫–‬
‫از متغیر ‪ var2‬یک واحد کم میشود‬
‫به این نکته توجه داشته باشید که محل قرار گیری عملگر در نتیجه محاسبات تأثیر دارد‪ .‬اگر عملگر قبل از متغیر ‪ var2‬بیاید افزایش‬
‫یا کاهش ‪ var1‬اتفاق میافتد‪.‬چنانچه عملگرها بعد از متغیر ‪ var2‬قرار بگیرند ابتدا ‪ var1‬برابر ‪var2‬میشود و سپس متغیر‬
‫‪var2‬افزایش یا کاهش مییابد‪ .‬به مثالهای زیر توجه کنید‪:‬‬
‫{‬
‫;‪int x = 0‬‬
‫;‪int y = 1‬‬
‫;‪x = ++y‬‬
‫;‪cout << "x= {0}" << x << endl‬‬

‫;‪cout << "y= {0}" << y << endl‬‬
‫}‬
‫‪x=2‬‬
‫‪y=2‬‬
‫{‬
‫;‪int x = 0‬‬
‫;‪int y = 1‬‬
‫;‪x = --y‬‬
‫;‪cout << "x= {0}" << x << endl‬‬

‫;‪cout << "y= {0}" << y << endl‬‬
‫}‬
‫‪x=0‬‬
‫‪y=0‬‬
‫همانطور که در دو مثال باال مشاهده میکنید‪،‬درج عملگرهای ‪ --‬و ‪ ++‬قبل از عملوند ‪ y‬باعث میشود که ابتدا یک واحد از ‪ y‬کم‬
‫و یا یک واحد به ‪ y‬اضافه شود و سپس نتیجه در عملوند ‪ x‬قرار بگیرد‪ .‬حال به دو مثال زیر توجه کنید‪:‬‬
‫{‬
‫;‪int x = 0‬‬
‫;‪int y = 1‬‬
‫;‪x = y--‬‬
‫;‪cout << "x= {0}" << x << endl‬‬

‫;‪cout << "y= {0}" << y << endl‬‬
‫}‬
‫‪x=1‬‬
‫‪y=0‬‬
‫{‬
‫;‪int x = 0‬‬
‫;‪int y = 1‬‬
‫;‪x = y++‬‬
‫;‪cout << "x= {0}" << x << endl‬‬

‫;‪cout << "y= {0}" << y << endl‬‬
‫}‬
‫‪x=1‬‬
‫‪y=2‬‬
‫همانطور که در دو مثال باال مشاهده میکنید‪،‬درج عملگرهای ‪ --‬و ‪ ++‬بعد از عملوند ‪ y‬باعث میشود که ابتدا مقدار ‪ y‬در داخل‬
‫متغیر ‪ x‬قرار بگیرد و سپس یک واحد از ‪ y‬کم و یا یک واحد به ان اضافه شود‪ .‬حال میتوانیم با ایجاد یک برنامه نحوه عملکرد‬
‫عملگرهای ریاضی در ‪ C++‬را یاد بگیریم‪:‬‬
‫{‬
‫‪//Variable declarations‬‬
‫;‪int num1, num2‬‬
‫;‪string msg1, msg2‬‬
‫‪//Assign test values‬‬

‫;‪num1 = 6‬‬
‫;‪num2 = 3‬‬
‫‪//Demonstrate use of mathematical operators‬‬

‫;‪cout << "The sum of num1 and num2 is " << (num1 + num2) << endl‬‬
‫;‪cout << "The difference of num1 and num2 is " << (num1 - num2) << endl‬‬
‫;‪cout << "The product of num1 and num2 is " << (num1 * num2) << endl‬‬
‫;‪cout << "The quotient of num1 and num2 is " << (num1 / num2) << endl‬‬
‫;‪cout << "The remainder of num1 and num2 is " << (num1 % num2) << endl‬‬
‫;" ‪msg1 = "Hello‬‬

‫;"!‪msg2 = "World‬‬
‫;‪cout << msg1 + msg2‬‬
‫}‬
‫‪The sum of 6 and 3 is 9.‬‬

‫‪The difference of 6 and 3 is 3.‬‬
‫‪The product of 6 and 3 is 18.‬‬
‫‪The quotient of 6 and 3 is 2.‬‬
‫‪The remainder of 6 divided by 3 is 0‬‬
‫!‪Hello World‬‬
‫برنامه باال نتیجه هر عبارت را نشان میدهد‪ .‬در این برنامه از ‪ endl‬برای نشان دادن نتایج در سطرهای متفاوت استفاده شده‬
‫است‪ C++ .‬خط جدید و فاصله و فضای خالی را نادیده میگیرد‪ .‬در خط ‪ 77‬مشاهده میکنید که دو رشته به وسیله عملگر ‪ +‬به‬
‫هم متصل شدهاند‪ .‬نتیجه استفاده از عملگر ‪ +‬برای چسباندن دو کلمه “ ‪ “Hello‬و ”!‪ “World‬رشته ”!‪“Hello World‬‬
‫خواهد بود‪ .‬به فاصلههای خالی بعد از اولین کلمه توجه کنید اگر آنها را حذف کنید از خروجی برنامه نیز حذف میشوند‪.‬‬
‫عملگرهای تخصیصی‬
‫نوع دیگر از عملگرهای ‪ C++‬عملگرهای جایگزینی نام دارند‪ .‬این عملگرها مقدار متغیر سمت راست خود را در متغیر سمت چپ‬
‫قرار میدهند‪ .‬جدول زیر انواع عملگرهای تخصیصی در سی شارپ را نشان میدهد‪:‬‬
‫نتیجه‬ ‫مثال‬ ‫عملگر‬
‫مقدار ‪ var1‬برابر است با مقدار ‪var2‬‬ ‫;‪var1 = var2‬‬ ‫=‬
‫مقدار ‪ var1‬برابر است با حاصل جمع ‪ var1‬و ‪var2‬‬ ‫;‪var1 += var2‬‬ ‫=‪+‬‬
‫مقدار ‪ var1‬برابر است با حاصل تفریق ‪ var1‬و ‪var2‬‬ ‫;‪var1 -= var2‬‬ ‫=‪-‬‬
‫مقدار ‪ var1‬برابر است با حاصل ضرب ‪ var1‬در ‪var2‬‬ ‫;‪var1 *= var2‬‬ ‫=*‬
‫مقدار ‪ var1‬برابر است با حاصل تقسیم ‪ var1‬بر ‪var2‬‬ ‫;‪var1 /= var2‬‬ ‫=‪/‬‬
‫مقدار ‪ var1‬برابر است با باقیمانده تقسیم ‪ var1‬بر ‪var2‬‬ ‫;‪var1 %= var2‬‬ ‫=‪%‬‬
‫استفاده از این نوع عملگرها در واقع یک نوع خالصه نویسی در کد است‪ .‬مثالً شکل اصلی کد ‪var1 += var2‬به صورت ‪var1‬‬
‫‪= var1 + var2‬میباشد‪ .‬این حالت کدنویسی زمانی کارایی خود را نشان میدهد که نام متغیرها طوالنی باشد‪ .‬برنامه زیر‬
‫چگونگی استفاده از عملگرهای تخصیصی و تأثیر آنها را بر متغیرها نشان میدهد‪.‬‬
‫{‬
‫;‪int number‬‬
‫;‪cout << "Assigning 10 to number..." << endl‬‬

‫;‪number = 10‬‬
‫;‪cout << "Number = " << number << endl‬‬
‫;‪cout << "Adding 10 to number..." << endl‬‬

‫;‪number += 10‬‬
‫;‪cout << "Subtracting 10 from number..." << endl‬‬

‫;‪number -= 10‬‬
‫}‬
‫‪Assigning 10 to number...‬‬
‫‪Number = 10‬‬
‫‪Adding 10 to number...‬‬
‫‪Subtracting 10 from number...‬‬
‫در برنامه از ‪ 1‬عملگر تخصیصی استفاده شده است‪ .‬ابتدا یک متغیر و مقدار ‪ 10‬با استفاده از عملگر = به آن اختصاص داده شده‬
‫است‪.‬سپس به آن با استفاده از عملگر =‪ +‬مقدار ‪ 91‬اضافه و در آخر به وسیله عملگر =‪ -‬عدد ‪ 91‬از آن کم شده است‪.‬‬
‫عملگرهای مقایسه ای‬
‫از عملگرهای مقایسه ای برای مقایسه مقادیر استفاده میشود ‪.‬نتیجه این مقادیر یک مقدار بولی(منطقی) است‪.‬این عملگرها اگر‬
‫نتیجه مقایسه دو مقدار درست باشد مقدار ‪ 9‬و اگر نتیجه مقایسه اشتباه باشد مقدار ‪ 1‬را نشان میدهند‪ .‬این عملگرها به طور‬
‫معمول در دستورات شرطی به کار میروند به این ترتیب که باعث ادامه یا توقف دستور شرطی میشوند‪.‬جدول زیر عملگرهای‬
‫مقایسه ای در ‪ C++‬را نشان میدهد‪:‬‬
‫‪var1‬در صورتی ‪ 1‬است که مقدار ‪ var2‬با مقدار ‪ var3‬برابر باشد‬

‫‪var1 = var2 == var3‬‬ ‫‪Binary‬‬ ‫==‬
‫در غیر اینصورت ‪ 0‬است‬
‫‪var1‬در صورتی ‪ 1‬است که مقدار ‪ var2‬با مقدار ‪ var3‬برابر نباشد‬

‫‪var1 = var2 != var3‬‬ ‫‪Binary‬‬ ‫=!‬
‫‪var1‬در صورتی ‪ 1‬است که مقدار ‪ var2‬کوچکتر از ‪ var3‬مقدار‬

‫‪var1 = var2 < var3‬‬ ‫‪Binary‬‬ ‫<‬
‫باشد در غیر اینصورت ‪ 0‬است‬
‫‪var1‬در صورتی ‪ 1‬است که مقدار‪ var2‬بزرگتر ازمقدار ‪var3‬باشد‬

‫‪var1 = var2 > var3‬‬ ‫‪Binary‬‬ ‫>‬
‫‪var1‬در صورتی ‪ 1‬است که مقدار ‪ var2‬کوچکتر یا مساوی مقدار‬

‫‪var1 = var2 <= var3‬‬ ‫‪Binary‬‬ ‫=<‬
‫‪var3‬باشد در غیر اینصورت ‪ 0‬است‬
‫‪var1‬در صورتی ‪ 1‬است که مقدار ‪ var2‬بزرگتر یا مساوی ‪var3‬‬

‫‪var1 = var2 >= var3‬‬ ‫‪Binary‬‬ ‫=>‬
‫مقدار باشد در غیر اینصورت ‪ 0‬است‬
‫برنامه زیر نحوه عملکرد این عملگرها را نشان میدهد‪:‬‬
‫{‬
‫;‪int num1 = 10‬‬
‫;‪int num2 = 5‬‬
‫‪cout‬‬ ‫<<‬ ‫‪num1‬‬ ‫<<‬ ‫"‬ ‫==‬ ‫"‬ ‫<<‬ ‫‪num2‬‬ ‫<<‬ ‫"‬ ‫‪:‬‬ ‫"‬ ‫<<‬ ‫‪(num1‬‬ ‫;‪== num2) << endl‬‬
‫‪cout‬‬ ‫<<‬ ‫‪num1‬‬ ‫<<‬ ‫"‬ ‫=!‬ ‫"‬ ‫<<‬ ‫‪num2‬‬ ‫<<‬ ‫"‬ ‫‪:‬‬ ‫"‬ ‫<<‬ ‫‪(num1‬‬ ‫;‪!= num2) << endl‬‬
‫‪cout‬‬ ‫<<‬ ‫‪num1‬‬ ‫<<‬ ‫"‬ ‫<‬ ‫"‬ ‫<<‬ ‫‪num2‬‬ ‫<<‬ ‫"‬ ‫‪:‬‬ ‫"‬ ‫<<‬ ‫‪(num1‬‬ ‫;‪< num2) << endl‬‬
‫‪cout‬‬ ‫<<‬ ‫‪num1‬‬ ‫<<‬ ‫"‬ ‫>‬ ‫"‬ ‫<<‬ ‫‪num2‬‬ ‫<<‬ ‫"‬ ‫‪:‬‬ ‫"‬ ‫<<‬ ‫‪(num1‬‬ ‫;‪> num2) << endl‬‬
‫‪cout‬‬ ‫<<‬ ‫‪num1‬‬ ‫<<‬ ‫"‬ ‫=<‬ ‫"‬ ‫<<‬ ‫‪num2‬‬ ‫<<‬ ‫"‬ ‫‪:‬‬ ‫"‬ ‫<<‬ ‫‪(num1‬‬ ‫;‪<= num2) << endl‬‬
‫‪cout‬‬ ‫<<‬ ‫‪num1‬‬ ‫<<‬ ‫"‬ ‫=>‬ ‫"‬ ‫<<‬ ‫‪num2‬‬ ‫<<‬ ‫"‬ ‫‪:‬‬ ‫"‬ ‫<<‬ ‫‪(num1‬‬ ‫;‪>= num2) << endl‬‬
‫}‬
‫‪10 == 5 : 0‬‬
‫‪10‬‬ ‫=!‬ ‫‪5‬‬ ‫‪:‬‬ ‫‪1‬‬

‫‪10‬‬ ‫<‬ ‫‪5‬‬ ‫‪:‬‬ ‫‪0‬‬
‫‪10‬‬ ‫>‬ ‫‪5‬‬ ‫‪:‬‬ ‫‪1‬‬
‫‪10‬‬ ‫=<‬ ‫‪5‬‬ ‫‪:‬‬ ‫‪0‬‬
‫‪10‬‬ ‫=>‬ ‫‪5‬‬ ‫‪:‬‬ ‫‪1‬‬
‫در مثال باال ابتدا دو متغیر را که میخواهیم با هم مقایسه کنیم را ایجاد کرده و به آنها مقادیری اختصاص میدهیم‪.‬سپس با‬
‫استفاده از یک عملگر مقایسه ای آنها را با هم مقایسه کرده و نتیجه را چاپ میکنیم‪.‬به این نکته توجه کنید که هنگام مقایسه دو‬
‫متغیر از عملگر == به جای عملگر = باید استفاده شود‪ .‬عملگر = عملگر تخصیصی است و در عبارتی مانند ‪ x = y‬مقدار ‪ y‬را در‬
‫به ‪ x‬اختصاص میدهد ‪ .‬عملگر == عملگر مقایسه ای است که دو مقدار را با هم مقایسه میکند مانند ‪ x==y‬و اینطور خوانده‬
‫میشود ‪ x‬برابر است با‪y .‬‬
‫عملگرهای منطقی‬
‫عملگرهای منطقی بر روی عبارات منطقی عمل میکنند و نتیجه آنها نیز یک مقدار بولی است‪ .‬از این عملگرها اغلب برای شرطهای‬
‫پیچیده استفاده میشود‪ .‬همانطور که قبالً یاد گرفتید مقادیر بولی میتوانند ‪ false‬یا ‪ true‬باشند‪ .‬فرض کنید که ‪ var2‬و‬
‫‪var3‬دو مقدار بولی هستند‪.‬‬
‫مثال‬ ‫دسته‬ ‫نام‬ ‫عملگر‬
‫;‪var1 = var2 && var3‬‬ ‫‪Binary‬‬ ‫منطقی ‪AND‬‬ ‫&&‬
‫;‪var1 = var2 || var3‬‬ ‫‪Binary‬‬ ‫منطقی ‪OR‬‬ ‫||‬
‫;‪var1 = !var1‬‬ ‫‪Unary‬‬ ‫منطقی ‪NOT‬‬ ‫!‬
‫عملگر منطقی )&&(‪AND‬‬
‫اگر مقادیر دو طرف عملگر ‪true ، AND‬باشند عملگر ‪ AND‬مقدار ‪ true‬را بر میگرداند‪ .‬در غیر اینصورت اگر یکی از مقادیر یا هر‬
‫دوی آنها ‪ false‬باشند مقدار ‪ false‬را بر میگرداند‪ .‬در زیر جدول درستی عملگر ‪ AND‬نشان داده شده است‪:‬‬
‫‪X‬‬ ‫‪Y‬‬ ‫‪X && Y‬‬
‫‪true‬‬ ‫‪true‬‬ ‫‪true‬‬
‫‪true‬‬ ‫‪false‬‬ ‫‪false‬‬

‫‪false‬‬ ‫‪true‬‬ ‫‪false‬‬
‫‪false‬‬ ‫‪false‬‬ ‫‪false‬‬
‫برای درک بهتر تأثیر عملگر ‪ AND‬یاد آوری میکنم که این عملگر فقط در صورتی مقدار ‪ true‬را نشان میدهد که هر دو عملوند‬
‫مقدارشان ‪ true‬باشد‪.‬در غیر اینصورت نتیجه تمام ترکیبهای بعدی ‪ false‬خواهد شد‪ .‬استفاده از عملگر ‪AND‬مانند استفاده‬
‫از عملگرهای مقایسه ای است‪ .‬به عنوان مثال نتیجه عبارت زیر درست )‪ (true‬است اگر سن )‪ (age‬بزرگتر از ‪ 98‬و ‪salary‬‬
‫کوچکتر از ‪ 9111‬باشد‪.‬‬
‫;)‪result = (age > 18) && (salary < 1000‬‬
‫عملگر ‪ AND‬زمانی کارامد است که ما با محدود خاصی از اعداد سرو کار داریم‪ .‬مثالً عبارت ‪10 <= x <= 100‬بدین معنی است‬
‫که ‪ x‬میتواند مقداری شامل اعداد ‪ 91‬تا ‪ 911‬را بگیرد‪ .‬حال برای انتخاب اعداد خارج از این محدوده میتوان از عملگر منطقی‬
‫‪AND‬به صورت زیر استفاده کرد‪.‬‬
‫;)‪inRange = (number <= 10) && (number >= 100‬‬
‫عملگر منطقی )||(‪OR‬‬
‫اگر یکی یا هر دو مقدار دو طرف عملگر ‪، OR‬درست )‪ (true‬باشد‪،‬عملگر ‪ OR‬مقدار ‪ true‬را بر میگرداند‪ .‬جدول درستی عملگر‬
‫‪OR‬در زیر نشان داده شده است ‪:‬‬
‫‪X‬‬ ‫‪Y‬‬ ‫‪X || Y‬‬
‫‪true‬‬ ‫‪true‬‬ ‫‪true‬‬
‫‪true‬‬ ‫‪false‬‬ ‫‪true‬‬
‫‪false‬‬ ‫‪true‬‬ ‫‪true‬‬
‫‪false‬‬ ‫‪false‬‬ ‫‪false‬‬
‫در جدول باال مشاهده میکنید که عملگر ‪ OR‬در صورتی مقدار ‪ false‬را بر میگرداند که مقادیر دو طرف آن ‪ false‬باشند‪ .‬کد‬
‫زیر را در نظر بگیرید‪.‬نتیجه این کد در صورتی درست )‪ (true‬است که رتبه نهایی دانش آموز )‪ (finalGrade‬بزرگتر از ‪ 95‬یا‬
‫یا نمره نهایی امتحان آن ‪ 911‬باشد‪.‬‬
‫;)‪isPassed = (finalGrade >= 75) || (finalExam == 100‬‬

‫عملگر منطقی )!(‪NOT‬‬
‫برخالف دو اپراتور ‪ OR‬و ‪ AND‬عملگر منطقی ‪ NOT‬یک عملگر یگانی است و فقط به یک عملوند نیاز دارد‪ .‬این عملگر یک مقدار یا‬
‫اصطالح بولی را نفی میکند ‪.‬مثالً اگر عبارت یا مقدار ‪ true‬باشد آنرا ‪ false‬و اگر ‪ false‬باشد آنرا ‪ true‬میکند‪ .‬جدول‬
‫زیر عملکرد اپراتور ‪ NOT‬را نشان میدهد‪:‬‬
‫‪X‬‬ ‫‪!X‬‬
‫‪true‬‬ ‫‪false‬‬
‫‪false‬‬ ‫‪true‬‬
‫نتیجه کد زیر در صورتی درست است که( ‪ age‬سن) بزرگتر یا مساوی ‪ 98‬نباشد‪.‬‬
‫;)‪isMinor = !(age >= 18‬‬
‫عملگرهای بیتی‬
‫عملگرهای بیتی به شما اجازه میدهند که شکل باینری انواع دادهها را دستکاری کنید‪ .‬برای درک بهتر این درس توصیه میشود که‬
‫شما سیستم باینری و نحوه تبدیل اعداد دهدهی به باینری را از لینک زیر یاد بگیرید ‪:‬‬
‫‪http://www.w3-farsi.com/?p=5698‬‬
‫در سیستم باینری (دودویی) که کامپیوتر از آن استفاده میکند وضعیت هر چیز یا خاموش است یا روشن‪ .‬برای نشان دادن حالت‬
‫روشن از عدد ‪ 9‬و برای نشان دادن حالت خاموش از عدد ‪ 1‬استفاده میشود‪ .‬بنابراین اعداد باینری فقط میتوانند صفر یا یک‬
‫باشند‪.‬اعداد باینری را اعداد در مبنای ‪ 7‬و اعداد اعشاری را اعداد در مبنای ‪ 91‬می گویند‪ .‬یک بیت نشان دهنده یک رقم باینری است‬
‫و هر بایت نشان دهنده ‪ 8‬بیت است‪ .‬به عنوان مثال برای یک داده از نوع ‪ int‬به ‪ 17‬بیت یا ‪ 4‬بایت فضا برای ذخیره آن نیاز‬
‫داریم‪ ،‬این بدین معناست که اعداد از ‪ 17‬رقم ‪ 1‬و ‪ 9‬برای ذخیره استفاده میکنند‪ .‬برای مثال عدد ‪ 911‬وقتی به عنوان یک متغیر از‬
‫نوع ‪ int‬ذخیره میشود در کامپیوتر به صورت زیر خوانده میشود‪:‬‬
‫‪000000000000000000000000000001100100‬‬
‫عدد ‪ 911‬در مبنای ده معادل عدد ‪ 9911911‬در مبنای ‪ 7‬است‪ .‬در اینجا ‪ 9‬رقم سمت راست نشان دهنده عدد ‪ 911‬در مبنای ‪ 7‬است و‬
‫مابقی صفرهای سمت راست برای پر کردن بیتهایی است که عدد از نوع ‪ int‬نیاز دارد‪ .‬به این نکته توجه کنید که اعداد باینری‬
‫از سمت راست به چپ خوانده میشوند‪ .‬عملگرهای بیتی ‪ C++‬در جدول زیر نشان داده شدهاند‪:‬‬
‫;‪x = y & z‬‬ ‫‪Binary‬‬ ‫بیتی‪AND‬‬ ‫&‬
‫;‪x = y | z‬‬ ‫‪Binary‬‬ ‫بیتی‪OR‬‬ ‫|‬
‫;‪x = y ^ z‬‬ ‫‪Binary‬‬ ‫بیتی‪XOR‬‬ ‫^‬
‫;‪x = ~y‬‬ ‫‪Unary‬‬ ‫بیتی‪NOT‬‬ ‫~‬
‫;‪x &= y‬‬ ‫‪Binary‬‬ ‫بیتی‪AND Assignment‬‬ ‫=&‬
‫;‪x |= y‬‬ ‫‪Binary‬‬ ‫بیتی‪OR Assignment‬‬ ‫=|‬
‫;‪x ^= y‬‬ ‫‪Binary‬‬ ‫بیتی‪XOR Assignment‬‬ ‫=^‬
‫عملگر بیتی )&(‪AND‬‬
‫عملگر بیتی ‪ AND‬کاری شبیه عملگر منطقی ‪ AND‬انجام میدهد با این تفاوت که این عملگر بر روی بیتها کار میکند‪ .‬اگر مقادیر‬
‫دو طرف آن ‪ 9‬باشد مقدار ‪ 9‬را بر میگرداند و اگر یکی یا هر دو طرف آن صفر باشد مقدار صفر را بر میگرداند‪ .‬جدول درستی عمگر‬
‫بیتی ‪ AND‬در زیر آمده است‪:‬‬
‫‪X‬‬ ‫‪Y‬‬ ‫‪X AND Y‬‬
‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬
‫‪1‬‬ ‫‪0‬‬ ‫‪0‬‬
‫‪0‬‬ ‫‪1‬‬ ‫‪0‬‬
‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬
‫در زیر نحوه استفاده از عملگر بیتی ‪ AND‬آمده است‪:‬‬
‫;‪int result = 5 & 3‬‬
‫;‪cout << result‬‬
‫‪1‬‬
‫همانطور که در مثال باال مشاهده میکنید نتیجه عملکرد عملگر ‪ AND‬بر روی دو مقدار ‪ 5‬و ‪ 1‬عدد ‪ 9‬میشود‪ .‬اجازه بدهید ببینیم که‬
‫چطور این نتیجه را به دست میآید‪:‬‬
‫‪5: 00000000000000000000000000000101‬‬
‫‪3: 00000000000000000000000000000011‬‬
‫‪------------------------------------‬‬
‫‪1: 00000000000000000000000000000001‬‬
‫ابتدا دو عدد ‪ 5‬و ‪ 1‬به معادل باینریشان تبدیل میشوند‪ .‬از آنجاییکه هر عدد صحیح ‪(int) 32‬بیت است از صفر برای پر کردن‬
‫بیتهای خالی استفاده میکنیم‪ .‬با استفاده از جدول درستی عملگر بیتی ‪ AND‬میتوان فهمید که چرا نتیجه عدد یک میشود‪.‬‬
‫عملگر بیتی )|(‪OR‬‬
‫اگر مقادیر دو طرف عملگر بیتی ‪ OR‬هر دو صفر باشند نتیجه صفر در غیر اینصورت ‪ 9‬خواهد شد‪ .‬جدول درستی این عملگر در زیر‬
‫آمده است‪:‬‬
‫‪X‬‬ ‫‪Y‬‬ ‫‪X OR Y‬‬
‫‪1‬‬ ‫‪1‬‬ ‫‪1‬‬
‫‪1‬‬ ‫‪0‬‬ ‫‪1‬‬
‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬
‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬
‫نتیجه عملگر بیتی ‪ OR‬در صورتی صفر است که عملوندهای دو طرف آن صفر باشند‪ .‬اگر فقط یکی از دو عملوند یک باشد نتیجه‬
‫یک خواهد شد‪ .‬به مثال زیر توجه کنید‪:‬‬
‫;‪int result = 7 | 9‬‬
‫‪15‬‬
‫وقتی که از عملگر بیتی ‪ OR‬برای دو مقدار در مثال باال (‪ 9‬و ‪ )1‬استفاده میکنیم نتیجه ‪ 95‬میشود‪ .‬حال بررسی میکنیم که چرا این‬
‫نتیجه به دست آمده است؟‬
‫‪7: 00000000000000000000000000000111‬‬
‫‪9: 00000000000000000000000000001001‬‬
‫‪-----------------------------------‬‬
‫‪15: 00000000000000000000000000001111‬‬
‫با استفاده از جدول درستی عملگر بیتی ‪ OR‬میتوان نتیجه استفاده از این عملگر را تشخیص داد‪ .‬عدد ‪ 9999‬باینری معادل عدد ‪95‬‬
‫صحیح است‪.‬‬
‫عملگر بیتی )^(‪XOR‬‬
‫جدول درستی این عملگر در زیر آمده است‪:‬‬
‫‪X‬‬ ‫‪Y‬‬ ‫‪X XOR Y‬‬
‫‪1‬‬ ‫‪1‬‬ ‫‪0‬‬
‫‪1‬‬ ‫‪0‬‬ ‫‪1‬‬
‫‪0‬‬ ‫‪1‬‬ ‫‪1‬‬
‫‪0‬‬ ‫‪0‬‬ ‫‪0‬‬
‫در صورتیکه عملوندهای دو طرف این عملگر هر دو صفر یا هر دو یک باشند نتیجه صفر در غیر اینصورت نتیجه یک میشود‪ .‬در‬
‫مثال زیر تأثیر عملگر بیتی ‪XOR‬را بر روی دو مقدار مشاده میکنید‪:‬‬
‫;‪int result = 5 ^ 7‬‬
‫‪2‬‬
‫در زیر معادل باینری اعداد باال (‪ 5‬و ‪ )9‬نشان داده شده است‪.‬‬
‫‪5: 00000000000000000000000000000101‬‬
‫‪7: 00000000000000000000000000000111‬‬
‫‪-----------------------------------‬‬
‫‪2: 00000000000000000000000000000010‬‬
‫با نگاه کردن به جدول درستی عملگر بیتی‪ ، XOR‬میتوان فهمید که چرا نتیجه عدد ‪ 7‬میشود‪.‬‬
‫عملگر بیتی )~(‪NOT‬‬
‫این عملگر یک عملگر یگانی است و فقط به یک عملوند نیاز دارد‪ .‬در زیر جدول درستی این عملگر آمده است‪:‬‬
‫‪X‬‬ ‫‪NOT X‬‬
‫‪1‬‬ ‫‪0‬‬
‫‪0‬‬ ‫‪1‬‬
‫عملگر بیتی ‪ NOT‬مقادیر بیتها را معکوس میکند‪ .‬در زیر چگونگی استفاده از این عملگر آمده است‪:‬‬
‫;‪int result = ~7‬‬
‫‪-8‬‬
‫به نمایش باینری مثال باال که در زیر نشان داده شده است توجه نمایید‪.‬‬
‫‪7: 00000000000000000000000000000111‬‬
‫‪------------------------------------‬‬
‫‪-8: 11111111111111111111111111111000‬‬
‫عملگر بیتی تغییر مکان)‪(shift‬‬
‫این نوع عملگرها به شما اجازه میدهند که بیتها را به سمت چپ یا راست جا به جا کنید‪ .‬دو نوع عملگر بیتی تغییر مکان وجود‬
‫دارد که هر کدام دو عملوند قبول میکنند ‪ .‬عملوند سمت چپ این عملگرها حالت باینری یک مقدار و عملوند سمت راست تعداد‬
‫جابه جایی بیتها را نشان میدهد‪.‬‬
‫;‪x = y << 2‬‬ ‫‪Binary‬‬ ‫تغییر مکان به سمت چپ‬ ‫>>‬
‫;‪x = y >> 2‬‬ ‫‪Binary‬‬ ‫تغییر مکان به سمت راست‬ ‫<<‬
‫عملگر تغییر مکان به سمت چپ‬
‫این عملگر بیتهای عملوند سمت چپ را به تعداد ‪ n‬مکان مشخص شده توسط عملوند سمت راست‪ ،‬به سمت چپ منتقل میکند‪.‬‬
‫;‪int result = 10 << 2‬‬
‫‪40‬‬
‫در مثال باال ما بیتهای مقدار ‪ 91‬را دو مکان به سمت چپ منتقل کردهایم‪ ،‬حال بیایید تأثیر این انتقال را بررسی کنیم‪:‬‬
‫‪10: 00000000000000000000000000001010‬‬
‫‪------------------------------------‬‬
‫‪40: 00000000000000000000000000101000‬‬
‫مشاهده میکنید که همه بیتها به اندازه دو واحد به سمت چپ منتقل شدهاند‪ .‬در این انتقال دو صفر از صفرهای سمت چپ کم‬
‫میشود و در عوض دو صفر به سمت راست اضافه میشود‪.‬‬
‫عملگر تغییر مکان به سمت راست‬
‫این عملگر شبیه به عمگر تغییر مکان به سمت چپ است با این تفاوت که بیتها را به سمت راست جا به جا میکند‪ .‬به عنوان‬
‫مثال‪:‬‬
‫;‪int result = 100 >> 4‬‬
‫‪6‬‬
‫با استفاده از عملگرتغییر مکان به سمت راست بیتهای مقدار ‪ 911‬را به اندازه ‪ 4‬واحد به سمت چپ جا به جا میکنیم‪ .‬اجازه بدهید‬
‫تأثیر این جا به جایی را مورد بررسی قرار دهیم‪:‬‬
‫‪100: 00000000000000000000000001100100‬‬
‫‪------------------------------------‬‬
‫‪6: 00000000000000000000000000000110‬‬
‫هر بیت به اندازه ‪ 4‬واحد به سمت راست منتقل میشود‪،‬بنابراین ‪ 4‬بیت اول سمت راست حذف شده و چهار صفر به سمت چپ‬
‫اضافه میشود‪.‬‬
‫تقدم عملگرها‬
‫تقدم عملگرها مشخص میکند که در محاسباتی که بیش از دو عملوند دارند ابتدا کدام عملگر اثرش را اعمال کند‪ .‬عملگرها در ‪C++‬‬
‫در محاسبات دارای حق تقدم هستند‪.‬به عنوان مثال‪:‬‬
‫;‪number = 1 + 2 * 3 / 1‬‬
‫اگر ما حق تقدم عملگرها را رعایت نکنیم و عبارت باال را از سمت چپ به راست انجام دهیم نتیجه ‪ 1‬خواهد شد (‪ 9+7=1‬سپس‬
‫‪ 1×1=1‬و در آخر ‪.)1/9=1‬اما کامپایلر با توجه به تقدم عملگرها محاسبات را انجام میدهد‪.‬برای مثال عمل ضرب و تقسیم نسبت به‬
‫ به دست‬1 ‫ میشود که نتیجه‬9 ‫ و سپس نتیجه آنها تقسیم بر‬1 ‫ ضربدر‬7 ‫بنابراین در مثال فوق ابتدا عدد‬.‫جمع و تفریق تقدم دارند‬
:‫ از باال به پایین آمده است‬C++ ‫ در جدول زیر تقدم عملگرهای‬.‫ حاصل میشود‬9 ‫ جمع میشود و عدد‬9 ‫ با‬1 ‫در آخر عدد‬.‫میآید‬
Level Precedence group Operator Grouping
1 Scope :: Left-to-right
++ –
()
2 Postfix (unary) Left-to-right
[]
. ->
++ –
~ !
+ -
3 Prefix (unary) & * Right-to-left
new delete
sizeof
(type)
4 Pointer-to-member .* ->* Left-to-right
5 Aritdmetic: scaling * / % Left-to-right
6 Aritdmetic: addition + - Left-to-right
7 Bitwise shift << >> Left-to-right
8 Relational < > <= >= Left-to-right
9 Equality == != Left-to-right
10 And & Left-to-right
11 Exclusive or ^ Left-to-right
12 Inclusive or | Left-to-right
13 Conjunction && Left-to-right
14 Disjunction || Left-to-right
Assignment-level = *= /= %= += -=
15 Right-to-left
expressions >>= <<= &= ^= |=
‫‪?:‬‬
‫‪16‬‬ ‫‪Sequencing‬‬ ‫‪,‬‬ ‫‪Left-to-right‬‬
‫ابتدا عملگرهای با باالترین و سپس عملگرهای با پایینترین حق تقدم در محاسبات تأثیر میگذارند‪.‬به این نکته توجه کنید که تقدم‬
‫عملگرها ‪++‬و – به مکان قرارگیری آنها بستگی دارد (در سمت چپ یا راست عملوند باشند)‪ .‬به عنوان مثال‪:‬‬
‫;‪int number = 3‬‬
‫‪number1 = 3 + ++number; //results to 7‬‬

‫‪number2 = 3 + number++; //results to 6‬‬
‫در عبارت اول ابتدا به مقدار‪ number‬یک واحد اضافه شده و ‪ 4‬میشود و سپس مقدار جدید با عدد ‪ 1‬جمع میشود و در نهایت‬
‫عدد ‪ 9‬به دست میآید‪.‬در عبارت دوم مقدار عددی ‪ 1‬به مقدار ‪ number‬اضافه میشود و عدد ‪ 1‬به دست میآید‪.‬سپس این مقدار‬
‫در متغیر ‪ number2‬قرار میگیرد‪ .‬و در نهایت مقدار ‪ number‬به ‪ 4‬افزایش مییابد‪ .‬برای ایجاد خوانایی در تقدم عملگرها و انجام‬
‫محاسباتی که در آنها از عملگرهای زیادی استفاده میشود از پرانتز استفاده میکنیم‪:‬‬
‫;)) ‪number = ( 1 + 2 ) * ( 3 / 4 ) % ( 5 - ( 6 * 7‬‬
‫در مثال باال ابتدا هر کدام از عباراتی که داخل پرانتز هستند مورد محاسبه قرار میگیرند‪.‬به نکته ای در مورد عبارتی که در داخل پرانتز‬
‫سوم قرار دارد توجه کنید‪.‬در این عبارت ابتدا مقدار داخلیترین پرانتز مورد محاسبه قرار میگیرد یعنی مقدار ‪ 1‬ضربدر ‪ 9‬شده و سپس‬
‫از ‪ 5‬کم میشود ‪ .‬اگر دو یا چند عملگر با حق تقدم یکسان موجود باشد ابتدا باید هر کدام از عملگرها را که در ابتدای عبارت میآیند‬
‫مورد ارزیابی قرار دهید‪ .‬به عنوان مثال‪:‬‬
‫;‪number = 3 * 2 + 8 / 4‬‬
‫هر دو عملگر * و ‪ /‬دارای حق تقدم یکسانی هستند‪ .‬بنابر این شما باید از چپ به راست آنها را در محاسبات تأثیر دهید‪.‬یعنی ابتدا‬
‫‪ 1‬را ضربدر ‪ 7‬میکنید و سپس عدد ‪ 8‬را بر ‪ 4‬تقسیم میکنید‪ .‬در نهایت نتیجه دو عبارت را جمع کرده و در متغیر ‪ number‬قرار‬
‫میدهید‪.‬‬
‫گرفتن ورودی از کاربر‬
‫سی پالس پالس دارای تعدادی شیء و متد برای گرفتن ورودی از کاربر میباشد‪ .‬حال میخواهیم درباره ‪ cin‬یکی دیگر از اشیاء‬
‫کالس ‪ Istraem‬بحث کنیم که یک مقدار را از کاربر دریافت میکند‪ .‬کار ‪ cin‬این است که تمام کاراکترهایی را که شما در محیط‬
‫کنسول تایپ میکنید تا زمانی که دکمه ‪ Enter‬را میزنید میخواند‪ .‬به برنامه زیر توجه کنید‪:‬‬
‫>‪#include <string‬‬
‫{‬
‫;‪string name‬‬
‫;‪int age‬‬
‫;‪double height‬‬
‫;" ‪cout << "Enter your name:‬‬

‫;‪cin >> name‬‬
‫;" ‪cout << "Enter your age:‬‬
‫;‪cin >> age‬‬
‫;" ‪cout << "Enter your height:‬‬
‫;‪cin >> height‬‬
‫‪//Print a blank line‬‬

‫;‪cout << endl‬‬
‫‪//Show the details you typed‬‬

‫;‪cout << "Name is " << name << endl‬‬
‫;‪cout << "Age is " << age << endl‬‬
‫;‪cout << "Height is " << height << endl‬‬
‫}‬
‫‪Enter your name: John‬‬

‫‪Enter your age: 18‬‬
‫‪Enter your height: 160.5‬‬
‫‪Name is John.‬‬
‫‪Age is 18.‬‬
‫‪Height is 160.5.‬‬
‫ابتدا ‪ 1‬متغیر را برای ذخیره داده در برنامه تعریف میکنیم (خطوط ‪ 8‬و ‪ 1‬و ‪ .)91‬برنامه از کاربر میخواهد که نام خود را وارد کند‬
‫(خط ‪ .)97‬در خط ‪ 91‬شما به عنوان کاربر نام خود را وارد میکنید ‪ .‬مقدار متغیر نام‪ ،‬برابر مقداری است که توسط ‪ cin‬خوانده‬
‫میشود‪.‬از آنجاییکه نام از نوع رشته است باید کتابخانه مربوط به رشتهها را در ابتدای برنامه وارد کنیم‪:‬‬
‫>‪#include <string‬‬
‫سپس برنامه از ما سن را سؤال میکند(خط ‪ .)94‬آن را در خط ‪ 95‬وارد کرده و در نهایت در خط ‪ 91‬و ‪ 99‬هم قد را وارد میکنیم‪.‬‬
‫ساختارهای تصمیم‬
‫ً‬
‫تقریبا همه زبانها ی برنامه نویسی به شما اجازه اجرای کد را در شرایط مطمئن میدهند‪ .‬حال تصور کنید که یک برنامه دارای ساختار‬
‫تصمیم گیری نباشد و همه کدها را اجرا کند‪ .‬این حالت شاید فقط برای چاپ یک پیغام در صفحه مناسب باشد ولی فرض کنید که‬
‫شما بخواهید اگر مقدار یک متغیر با یک عدد برابر باشد سپس یک پیغام چاپ شود آن وقت با مشکل مواجه خواهید شد ‪. C++‬‬
‫راههای مختلفی برای رفع این نوع مشکالت ارائه میدهد‪ .‬در این بخش با مطالب زیر آشنا خواهید شد‪:‬‬
‫دستور‪if‬‬ ‫‪‬‬
‫دستور‪if…else‬‬ ‫‪‬‬
‫عملگر سه تایی‬ ‫‪‬‬
‫دستور ‪ if‬چندگانه‬ ‫‪‬‬
‫دستور ‪ if‬تو در تو‬ ‫‪‬‬
‫عملگرهای منطقی‬ ‫‪‬‬
‫دستور‪switch‬‬ ‫‪‬‬
‫دستور ‪if‬‬
‫میتوان با استفاده از دستور ‪ if‬و یک شرط خاص که باعث ایجاد یک کد میشود یک منطق به برنامه خود اضافه کنید‪ .‬دستور‬
‫‪if‬سادهترین دستور شرطی است که برنامه میگوید اگر شرطی برقرار است کد معینی را انجام بده‪ .‬ساختار دستور ‪ if‬به صورت‬
‫زیر است‪:‬‬
‫)‪if (condition‬‬
‫;‪code to execute‬‬
‫قبل از اجرای دستور ‪ if‬ابتدا شرط بررسی میشود‪.‬اگر شرط برقرار باشد یعنی درست باشد سپس کد اجرا میشود‪.‬شرط یک عبارت‬
‫مقایسه ای است‪ .‬میتوان از عملگرهای مقایسه ای برای تست درست یا اشتباه بودن شرط استفاده کرد‪ .‬اجازه بدهید که نگاهی‬
‫به نحوه استفاده از دستور ‪ if‬در داخل برنامه بیندازیم ‪.‬برنامه زیر پیغام ‪ Hello World‬را اگر مقدار ‪ number‬کمتر از ‪ 91‬و‬
‫‪Goodbye World‬را اگر مقدار ‪ number‬از ‪ 91‬بزرگتر باشد در صفحه نمایش میدهد‪.‬‬

‫‪3‬‬
‫‪4‬‬ ‫)(‪int main‬‬
‫‪5‬‬ ‫{‬
‫‪6‬‬ ‫‪//Declare a variable and set it a value less than 10‬‬
‫‪7‬‬ ‫;‪int number = 5‬‬

‫‪8‬‬
‫‪9‬‬ ‫‪//If the value of number is less than 10‬‬
‫‪10‬‬ ‫)‪if (number < 10‬‬
‫‪11‬‬ ‫;‪cout << "Hello World." << endl‬‬
‫‪12‬‬
‫‪13‬‬ ‫‪//Change the value of a number to a value which is greater than 10‬‬
‫‪14‬‬ ‫;‪number = 15‬‬
‫‪15‬‬
‫‪16‬‬ ‫‪//If the value of number is greater than 10‬‬
‫‪17‬‬ ‫)‪if (number > 10‬‬
‫‪18‬‬ ‫;"‪cout << "Goodbye World.‬‬
‫‪19‬‬ ‫}‬
‫‪Hello World.‬‬
‫‪Goodbye World.‬‬
‫در خط ‪ 9‬یک متغیر با نام ‪ number‬تعریف و مقدار ‪ 5‬به آن اختصاص داده شده است‪ .‬وقتی به اولین دستور ‪ if‬در خط ‪91‬‬
‫میرسیم برنامه تشخیص میدهد که مقدار ‪ number‬از ‪ 91‬کمتر است یعنی ‪ 5‬کوچکتر از ‪ 91‬است‪.‬‬
‫منطقی است که نتیجه مقایسه درست میباشد بنابراین دستور ‪ if‬دستور را اجرا میکند(خط ‪ )99‬و پیغام ‪ Hello World‬چاپ‬
‫میشود‪ .‬حال مقدار ‪ number‬را به ‪ 95‬تغییر میدهیم (خط ‪.)94‬وقتی به دومین دستور ‪ if‬در خط ‪ 99‬میرسیم برنامه مقدار‬
‫‪number‬را با ‪ 91‬مقایسه میکند و چون مقدار ‪ number‬یعنی ‪ 95‬از ‪10‬بزرگتر است برنامه پیغام ‪ Goodbye World‬را چاپ‬
‫میکند(خط ‪ .)98‬به این نکته توجه کنید که دستور ‪ if‬را میتوان در یک خط نوشت‪:‬‬
‫;"‪if (number > 10) cout << "Goodbye World.‬‬
‫شما میتوانید چندیندستور را در داخل دستور ‪ if‬بنویسید‪ .‬کافیست که از یک آکوالد برای نشان دادن ابتدا و انتهای دستورات‬
‫استفاده کنید‪ .‬همه دستورات داخل بین آکوالد جز بدنه دستور ‪ if‬هستند‪ .‬نحوه تعریف چند دستور در داخل بدنه ‪ if‬به صورت‬
‫زیر است‪:‬‬
‫{‬
‫‪.‬‬
‫‪.‬‬
‫‪.‬‬
‫;‪statementN‬‬
‫}‬
‫این هم یک مثال ساده‪:‬‬
‫)‪if (x > 10‬‬

‫{‬
‫;‪cout << "x is greater than 10." << endl‬‬
‫;"‪cout << "This is still part of the if statement.‬‬

‫}‬
‫در مثال باال اگر مقدار ‪ x‬از ‪ 91‬بزرگتر باشد دو پیغام چاپ میشود‪ .‬حال اگر به عنوان مثال آکوالد را حذف کنیم و مقدار ‪ x‬از ‪91‬‬
‫بزرگتر نباشد مانند کد زیر‪:‬‬
‫)‪if (x > 10‬‬

‫;")?‪cout << "This is still part of the if statement. (Really‬‬
‫کد باال در صورتی بهتر خوانده میشود که بین دستورات فاصله بگذاریم‪.‬‬
‫)‪if (x > 10‬‬

‫;")?‪cout << "This is still part of the if statement. (Really‬‬
‫میبیند که دستور دوم (خط ‪ )1‬در مثال باال جز دستور ‪ if‬نیست‪ .‬اینجاست که چون ما فرض را بر این گذاشتهایم که مقدار ‪ x‬از‬
‫‪ 91‬کوچکتر است پس خط )?‪This is still part of the if statement. (Really‬چاپ میشود‪ .‬در نتیجه اهمیت‬
‫وجود آکوالد مشخص میشود‪ .‬به عنوان تمرین همیشه حتی اگر فقط یک دستور در بدنه ‪ if‬داشتید برای آن یک آکوالد بگذارید‪.‬‬
‫فراموش نکنید که از قلم انداختن یک آکوالد باعث به وجود آمدن خطا شده و یافتن آن را سخت میکند‪ .‬مثالی دیگر در مورد‬
‫دستور‪if :‬‬
‫{‬
‫;‪int firstNumber‬‬
‫;‪int secondNumber‬‬
‫;" ‪cout << "Enter a number:‬‬

‫;‪cin >> firstNumber‬‬
‫;" ‪cout << "Enter another number:‬‬

‫;‪cin >> secondNumber‬‬
‫)‪if (firstNumber == secondNumber‬‬

‫{‬
‫;‪cout << firstNumber << " == " << secondNumber << endl‬‬
‫}‬
‫)‪if (firstNumber != secondNumber‬‬
‫{‬
‫;‪cout << firstNumber << " != " << secondNumber << endl‬‬
‫}‬
‫)‪if (firstNumber < secondNumber‬‬
‫{‬
‫;‪cout << firstNumber << " < " << secondNumber << endl‬‬
‫}‬
‫)‪if (firstNumber > secondNumber‬‬
‫{‬
‫;‪cout << firstNumber << " > " << secondNumber << endl‬‬
‫}‬
‫)‪if (firstNumber <= secondNumber‬‬
‫{‬
‫;‪cout << firstNumber << "<= " << secondNumber << endl‬‬
‫}‬
‫)‪if (firstNumber >= secondNumber‬‬
‫{‬
‫;‪cout << firstNumber << " >= " << secondNumber << endl‬‬
‫}‬
‫}‬
‫‪Enter a number: 2‬‬

‫‪Enter another number: 5‬‬
‫‪2 != 5‬‬
‫‪2 < 5‬‬
‫‪2 <= 5‬‬
‫‪10 != 3‬‬
‫‪10 > 3‬‬
‫‪10 >= 3‬‬
‫‪5 == 5‬‬
‫‪5 <= 5‬‬
‫‪5 >= 5‬‬
‫ما از عملگرهای مقایسه ای در دستور ‪ if‬استفاده کردهایم ‪ .‬ابتدا دو عدد که قرار است با هم مقایسه شوند را به عنوان ورودی از‬
‫کاربر میگیریم‪.‬اعداد با هم مقایسه میشوند و اگر شرط درست بود پیغامی چاپ میشود‪.‬به این نکته توجه داشته باشید که شرطها‬
‫مقادیر بولی هستند‪ ،‬بنابراین شما میتوانید نتیجه یک عبارت را در داخل یکمتغیر بولی ذخیره کنید و سپس از متغیر به عنوان شرط‬
‫در دستور ‪ if‬استفاده کنید‪ .‬اگر مقدار ‪ year‬برابر ‪ 7111‬باشد سپس حاصل عبارت در متغیر ‪ isNewMillenium‬ذخیره‬
‫میشود‪.‬میتوان از متغیر برای تشخیص کد اجرایی بدنه دستور ‪ if‬استفاده کرد خواه مقدار متغیر درست باشد یا نادرست‪.‬‬
‫;‪bool isNewMillenium = year == 2000‬‬
‫)‪if (isNewMillenium‬‬
‫{‬
‫;"!‪cout << "Happy New Millenium‬‬
‫}‬
‫دستور ‪if…else‬‬
‫دستور ‪ if‬فقط برای اجرای یک حالت خاص به کار میرود یعنی اگر حالتی برقرار بود کارخاصی انجام شود‪.‬اما زمانی که شما‬
‫بخواهید اگر شرط خاصی برقرار شد یک دستور و اگر برقرار نبود دستور دیگر اجرا شود باید از دستور ‪ if else‬استفاده کنید‪.‬‬
‫ساختار دستور ‪ if else‬در زیر آمده است‪:‬‬
‫{‬
‫;‪code to execute if condition is true‬‬
‫}‬
‫‪else‬‬
‫{‬
‫;‪code to execute if condition is false‬‬
‫}‬
‫‪if‬به کار برده شود‪.‬اگر فقط یک کد اجرایی در داخل‬ ‫ً‬

‫حتما باید با‬ ‫از کلمه کلیدی ‪ else‬نمیتوان به تنهایی استفاده کرد بلکه‬
‫بدنه ‪ if‬و بدنه ‪ else‬دارید استفاده از آکوالد اختیاری است ‪.‬کد داخل بلوک ‪ else‬فقط در صورتی اجرا میشود که شرط داخل‬
‫دستور ‪ if‬نادرست باشد‪ .‬در زیر نحوه استفاده از دستور ‪if…else‬آمده است‪.‬‬

‫‪3‬‬
‫‪4‬‬ ‫)(‪int main‬‬
‫‪5‬‬ ‫{‬
‫‪6‬‬ ‫;‪int number = 5‬‬
‫‪7‬‬
‫‪8‬‬ ‫‪//Test the‬‬ ‫‪condition‬‬
‫‪9‬‬ ‫‪if (number‬‬ ‫)‪< 10‬‬
‫‪10‬‬ ‫{‬
‫‪11‬‬ ‫<< ‪cout‬‬ ‫;‪"The number is less than 10." << endl‬‬
‫‪12‬‬ ‫}‬
‫‪13‬‬ ‫‪else‬‬
‫‪14‬‬ ‫{‬
‫‪15‬‬ ‫<< ‪cout‬‬ ‫;‪"The number is either greater than or equal to 10." << endl‬‬
‫‪16‬‬ ‫}‬
‫‪17‬‬
‫‪18‬‬ ‫‪//Modify value of number‬‬
‫‪19‬‬ ‫;‪number = 15‬‬
‫‪20‬‬
‫‪21‬‬ ‫‪//Repeat the test to yield a different result‬‬
‫‪22‬‬ ‫)‪if (number < 10‬‬
‫‪23‬‬ ‫{‬
‫‪24‬‬ ‫;‪cout << "The number is less than 10." << endl‬‬
‫‪25‬‬ ‫}‬
‫‪26‬‬ ‫‪else‬‬
‫‪27‬‬ ‫{‬
‫‪28‬‬ ‫;‪cout << "The number is either greater than or equal to 10." << endl‬‬
‫‪29‬‬ ‫}‬
‫‪30‬‬ ‫}‬
‫در خط ‪ 1‬یک متغیر به نام ‪ number‬تعریف کردهایم و در خط ‪ 1‬تست میکنیم که آیا مقدار متغیر ‪ number‬از ‪ 91‬کمتر است یا نه‬
‫و چون کمتر است در نتیجه کد داخل بلوک ‪ if‬اجرا میشود (خط ‪ )99‬و اگر مقدار ‪ number‬را تغییر دهیم و به مقداری بزرگتر از‬
‫‪ 91‬تغییر دهیم (خط ‪ ،)91‬شرط نادرست میشود (خط ‪ )77‬و کد داخل بلوک ‪ else‬اجرا میشود (خط ‪.)78‬‬
‫عملگر شرطی‬
‫عملگر شرطی (?‪ ):‬در ‪ C++‬مانند دستور شرطی ‪ if…else‬عمل میکند‪ .‬در زیر نحوه استفاده از این عملگر آمده است‪:‬‬
‫>‪<condition> ? <result if true> : <result if false‬‬
‫عملگر شرطی تنها عملگر سه تایی ‪ C++‬است که نیاز به سه عملوند دارد‪ ،‬شرط‪ ،‬یک مقدار زمانی که شرط درست باشد و یک مقدار‬
‫زمانی که شرط نادرست باشد‪ .‬اجازه بدهید که نحوه استفاده این عملگر را در داخل برنامه مورد بررسی قرار دهیم‪.‬‬
‫>‪#include <String‬‬
‫{‬
‫‪string‬‬ ‫;"‪pet1 = "puppy‬‬
‫‪string‬‬ ‫;"‪pet2 = "kitten‬‬
‫‪string‬‬ ‫;‪type1‬‬
‫‪string‬‬ ‫;‪type2‬‬
‫;"‪type1 = (pet1 == "puppy") ? "dog" : "cat‬‬

‫;"‪type2 = (pet2 == "kitten") ? "cat" : "dog‬‬
‫;‪cout << type1 << endl‬‬

‫;‪cout << type2‬‬
‫}‬
‫‪dog‬‬
‫‪cat‬‬
‫برنامه باال نحوه استفاده از این عملگر شرطی را نشان میدهد‪ .‬خط یک به صورت زیر ترجمه میشود ‪ :‬اگر مقدار ‪ pet1‬برابر با‬
‫‪puppy‬سپس مقدار ‪ dog‬را در ‪ type1‬قرار بده در غیر این صورت مقدار ‪ cat‬را ‪ type1‬قرار بده‪ .‬خط دو به صورت زیر ترجمه‬
‫میشود ‪ :‬اگر مقدار ‪ pet2‬برابر با ‪ kitten‬سپس مقدار ‪ cat‬را در ‪ type2‬قرار بده در غیر این صورت مقدار ‪ dog.‬حال برنامه‬
‫باال را با استفاده از دستور ‪ if else‬مینویسیم‪:‬‬
‫)"‪if (pet1 == "puppy‬‬

‫;"‪type1 = "dog‬‬
‫‪else‬‬
‫;"‪type1 = "cat‬‬
‫هنگامی که چندین دستور در داخل یک بلوک ‪ if‬یا ‪ else‬دارید از عملگر شرطی استفاده نکنید چون خوانایی برنامه را پایین‬
‫میآورد‪.‬‬
‫دستور ‪ if‬چندگانه‬
‫اگر بخواهید چند شرط را بررسی کنید چکار میکنید؟ میتوانید از چندین دستور ‪ if‬استفاده کنید و بهتر است که این دستورات‬
‫‪if‬را به صورت زیر بنویسید‪:‬‬
‫{‬
‫}‬
‫‪else‬‬
‫{‬
‫{‬
‫}‬
‫‪else‬‬
‫{‬
‫{‬
‫}‬
‫‪else‬‬
‫{‬
‫}‬
‫}‬
‫}‬
‫خواندن کد باال سخت است‪ .‬بهتر است دستورات را به صورت تو رفتگی در داخل بلوک ‪ else‬بنویسید‪ .‬میتوانید کد باال را ساده‬
‫تر کنید‪:‬‬
‫{‬
‫}‬
‫)‪else if (condition‬‬
‫{‬
‫}‬
‫)‪else if (condition‬‬
‫{‬
‫}‬
else
{
code to execute;
}
‫ وابسته‬if ‫نیز به دستور‬else if ، else ‫ را یاد گرفتید باید بدانید که مانند‬else if ‫حال که نحوه استفده از دستور‬
else if ‫اشتباه باشد دستور‬else if ‫ حال اگر‬.‫اشتباه باشد‬if ‫وقتی اجرا میشود که اولین دستور‬else if ‫دستور‬.‫است‬
‫را‬if else ‫ برنامه زیر نحوه استفاده از دستور‬.‫اجرا میشود‬else ‫ و اگر آن نیز اجرا نشود در نهایت دستور‬.‫بعدی اجرا میشود‬
:‫نشان میدهد‬
#include <iostream>
#include <String>
int main()
{
int choice;
cout << "What's your favorite color?" << endl;

cout << "[1] Black" << endl;
cout << "[2] White" << endl;
cout << "[3] Blue" << endl;
cout << "[4] Red" << endl;
cout << "[5] Yellown" << endl;
cout << "Enter your choice: ";

cin >> choice;
if (choice == 1)
{
cout << "You might like my black t-shirt." << endl;
}
else if (choice == 2)
{
cout << "You might be a clean and tidy person." << endl;
}
{
cout << "You might be sad today." << endl;
}
{
cout << "You might be inlove right now." << endl;
}
{
cout << "Lemon might be your favorite fruit." << endl;
}
else
{
cout << "Sorry, your favorite color is not in the choices above." << endl;
}
59 ‫ مبانی زبان سی پالس پالس‬: ‫فصل اول‬
What's your favorite color?

[1] Black
[2] White
[3] Blue
[4] Red
[5] Yellow
Enter your choice: 1

You might like my black t-shirt.
What's your favorite color?
[1] Black
[2] White
[3] Blue
[4] Red
[5] Yellow

Sorry, your favorite color is not in the choices above.
‫ بسته به اینکه شما چه چیزی انتخاب میکنید پیغامهای مختلفی چاپ‬.‫ وابسته است‬choice ‫خروجی برنامه باال به متغیر‬
.‫ اجرا میشود‬else ‫اگر عددی که شما تایپ میکنید در داخل حالتهای انتخاب نباشد کد مربوط به بلوک‬.‫میشود‬
‫ تو در تو‬if ‫دستور‬
.‫ دیگر‬if ‫ در داخل دستور‬if ‫ یک دستور ساده‬.‫ استفاده کرد‬C++ ‫ تو در تو در‬if ‫میتوان از دستور‬
if (condition)
{
code to execute;
if (condition)
{
code to execute;
}
else if (condition)
{
if (condition)
{
code to execute;
}
}
}
else
{
if (condition)
{
code to execute;
}
}
:‫ تو در تو را نشان دهیم‬if ‫اجازه بدهید که نحوه استفاده از دستور‬


‫‪2‬‬ ‫>‪#include <string‬‬
‫‪4‬‬
‫‪5‬‬ ‫)(‪int main‬‬
‫‪6‬‬ ‫{‬
‫‪7‬‬ ‫;‪int age‬‬
‫‪8‬‬ ‫;‪string gender‬‬
‫‪9‬‬
‫‪10‬‬ ‫;" ‪cout << "Enter your age:‬‬
‫‪11‬‬ ‫;‪cin >> age‬‬
‫‪12‬‬
‫‪13‬‬ ‫;" ‪cout << "Enter your gender (male/female):‬‬
‫‪14‬‬ ‫;‪cin >> gender‬‬
‫‪15‬‬
‫‪16‬‬ ‫)‪if (age > 12‬‬
‫‪17‬‬ ‫{‬
‫‪18‬‬ ‫)‪if (age < 20‬‬
‫‪19‬‬ ‫{‬
‫‪20‬‬ ‫)"‪if (gender == "male‬‬
‫‪21‬‬ ‫{‬
‫‪22‬‬ ‫;‪cout << "You are a teenage boy." << endl‬‬
‫‪23‬‬ ‫}‬
‫‪24‬‬ ‫‪else‬‬
‫‪25‬‬ ‫{‬
‫‪26‬‬ ‫;‪cout << "You are a teenage girl." << endl‬‬
‫‪27‬‬ ‫}‬
‫‪28‬‬ ‫}‬
‫‪29‬‬ ‫‪else‬‬
‫‪30‬‬ ‫{‬
‫‪31‬‬ ‫;‪cout << "You are already an adult." << endl‬‬
‫‪32‬‬ ‫}‬
‫‪33‬‬ ‫}‬
‫‪34‬‬ ‫‪else‬‬
‫‪35‬‬ ‫{‬
‫‪36‬‬ ‫;‪cout << "You are still too young." << endl‬‬
‫‪37‬‬ ‫}‬
‫‪38‬‬ ‫}‬

‫‪Enter your gender: male‬‬
‫‪You are a teenage boy.‬‬
‫‪Enter your gender: female‬‬
‫‪You are still too young.‬‬
‫اجازه بدهید که برنامه را کالبد شکافی کنیم‪ .‬ابتدا برنامه از شما درباره سنتان سؤال میکند (خط ‪ .)91‬در خط ‪ 91‬درباره جنستان از‬
‫شما سؤال میکند‪.‬سپس به اولین دستور ‪ if‬میرسد(خط ‪ .)91‬در این قسمت اگر سن شما بیشتر از ‪ 97‬سال باشد برنامه وارد بدنه‬
‫دستور ‪ if‬میشود در غیر اینصورت وارد بلوک ‪( else‬خط ‪)14‬مربوط به همین دستور ‪ if‬میشود‪.‬‬
‫حال فرض کنیم که سن شما بیشتر از ‪ 97‬سال است و شما وارد بدنه اولین ‪ if‬شدهاید‪ .‬در بدنه اولین ‪ if‬دو دستور ‪ if‬دیگر را‬
‫مشاهده میکنید‪ .‬اگر سن کمتر ‪ 71‬باشد شما وارد بدنه ‪ if‬دوم میشوید و اگر نباشد به قسمت ‪ else‬متناظر با آن میروید(خط‬
‫‪ .)71‬دوباره فرض میکنیم که سن شما کمتر از ‪ 71‬باشد‪ ،‬در اینصورت وارد بدنه ‪ if‬دوم شده و با یک ‪ if‬دیگر مواجه میشوید(خط‬
‫‪ .)71‬در اینجا جنسیت شما مورد بررسی قرار میگیرد که اگر برابر ”‪ “male‬باشد‪ ،‬کدهای داخل بدنه سومین ‪ if‬اجرا میشود در‬
‫غیر اینصورت قسمت ‪ else‬مربوط به این ‪ if‬اجرا میشود(خط ‪ .)74‬پیشنهاد میشود که از ‪ if‬تو در تو در برنامه کمتر استفاده‬
‫کنید چون خوانایی برنامه را پایین میآورد‪.‬‬
‫استفاده از عملگرهای منطقی‬
‫عملگرهای منطقی به شما اجازه میدهند که چندین شرط را با هم ترکیب کنید‪ .‬این عملگرها حداقل دو شرط را در گیر میکنند و در‬
‫آخر یک مقدار بولی را بر میگردانند‪ .‬در جدول زیر برخی از عملگرهای منطقی آمده است ‪:‬‬
‫تأثیر‬ ‫مثال‬ ‫تلفظ‬ ‫عملگر‬
‫مقدار ‪ Z‬در صورتی ‪ true‬است که هر دو شرط دو‬
‫طرف عملگر مقدارشان ‪ true‬باشد ‪.‬اگر فقط مقدار‬

‫)‪z = (x > 2) && (y < 10‬‬ ‫‪And‬‬ ‫&&‬
‫یکی از شروط ‪ false‬باشد مقدار ‪z ، false‬‬
‫خواهد شد ‪.‬‬
‫مقدار ‪ Z‬در صورتی ‪ true‬است که یکی از دو شرط‬
‫دو طرف عملگر مقدارشان ‪ true‬باشد‪ .‬اگر هر دو‬

‫)‪z = (x > 2) || (y < 10‬‬ ‫‪Or‬‬ ‫||‬
‫شرط مقدارشان ‪ false‬باشد مقدار ‪z ، false‬‬
‫خواهد شد ‪.‬‬
‫مقدار ‪ Z‬در صورتی ‪ true‬است که مقدار شرط‬
‫‪false‬است که مقدار‬ ‫‪false‬باشد و در صورتی‬ ‫)‪z = !(x > 2‬‬ ‫‪Not‬‬ ‫!‬
‫شرط ‪ true‬باشد ‪.‬‬
‫به عنوان مثال جمله )‪z = (x > 2) && (y < 10‬را به این صورت بخوانید ‪“ :‬در صورتی مقدار ‪ z‬برابر ‪ true‬است که مقدار‬
‫‪ x‬بزرگتر از ‪ 7‬و مقدار ‪ y‬کوچکتر از ‪ 91‬باشد در غیر اینصورت ‪ false‬است”‪ .‬این جمله بدین معناست که برای اینکه مقدار کل‬
‫دستور ‪ true‬باشد باید مقدار همه شروط ‪ true‬باشد‪ .‬عملگر منطقی )||( ‪OR‬تأثیر متفاوتی نسبت به عملگر منطقی ‪AND‬‬
‫)&&(دارد‪ .‬نتیجه عملگر منطقی ‪ OR‬برابر ‪ true‬است اگر فقط مقدار یکی از شروط ‪true‬باشد‪ .‬و اگر مقدار هیچ یک از شروط‬
‫ را با هم ترکیب کرده و در یک عبارت به کار برد‬OR ‫ و‬AND ‫ میتوان عملگرهای منطقی‬.‫ خواهد شد‬false ‫نباشد نتیجه‬true
:‫مانند‬
if ((x == 1) && ((y > 3) || z < 10)) )

{
//do something here
}
(y > 3) || (z ‫ در اینجا ابتدا عبارت‬.‫در اینجا استفاده از پرانتز مهم است چون از آن در گروه بندی شرطها استفاده میکنیم‬
‫( مقایسه‬x == 1) ‫ با نتیجه‬AND ‫( به علت تقدم عملگرها)سپس نتیجه آن بوسیله عملگر‬.‫ <مورد بررسی قرار میگیرد‬10)
:‫ حال بیایید نحوه استفاده از عملگرهای منطقی در برنامه را مورد بررسی قرار دهیم‬.‫میشود‬
#include <iostream>
#include <String>
int main()
{
int age;
string gender;
cout << "Enter your age: ";

cin >> age;
cout << "Enter your gender (male/female): ";

cin >> gender;
if (age > 12 && age < 20)

{
if (gender == "male")
{
cout << "You are a teenage boy." << endl;
}
else
{
cout << "You are a teenage girl." << endl;
}
}
else
{
cout << "You are still too young." << endl;
}
}
Enter your age: 18

Enter your gender (male/female): female
You are a teenage girl.
Enter you age: 10
Enter your gender (male/female): male
You are not a teenager.
‫برنامه باال نحوه استفاده از عملگر منطقی ‪ AND‬را نشان میدهد (خط ‪ .)91‬وقتی به دستور ‪ if‬میرسید (خط ‪ )91‬برنامه سن شما‬
‫را چک میکند‪.‬اگر سن شما بزرگتر از ‪ 97‬و کوچکتر از ‪ 71‬باشد (سنتان بین ‪ 97‬و‪ 71‬باشد) یعنی مقدار هر دو ‪ true‬باشد سپس‬
‫کدهای داخل بلوک ‪ if‬اجرا میشوند‪.‬اگر نتیجه یکی از شروط ‪false‬باشد کدهای داخل بلوک ‪ else‬اجرا میشود‪ .‬عملگر‬
‫‪ AND‬عملوند سمت چپ را مرود بررسی قرار میدهد‪.‬اگر مقدار آن ‪ false‬باشد دیگر عملوند سمت راست را بررسی نمیکند و‬
‫مقدار‪ false‬را بر میگرداند‪ .‬بر عکس عملگر || عملوند سمت چپ را مورد بررسی قرار میدهد و اگر مقدار آن ‪ true‬باشد سپس‬
‫عملوند سمت راست را نادیده میگیرد و مقدار ‪ true‬را بر میگرداند‪.‬‬
‫)‪if (x == 2 & y == 3‬‬

‫{‬
‫‪//Some code here‬‬
‫}‬
‫)‪if (x == 2 | y == 3‬‬
‫{‬
‫‪//Some code here‬‬
‫}‬
‫نکته مهم اینجاست که شما میتوانید از عملگرهای & و | به عنوان عملگر بیتی استفاده کنید‪ .‬تفاوت جزئی این عملگرها وقتی‬
‫که به عنوان عملگر بیتی به کار میروند این است که دو عملوند را بدون در نظر گرفتن مقدار عملوند سمت چپ مورد بررسی قرار‬
‫میدهند ‪ .‬به عنوان مثال حتی اگر مقدار عملوند سمت چپ ‪ false‬باشد عملوند سمت چپ به وسیله عملگر بیتی )&( ‪AND‬‬
‫ارزیابی میشود‪ .‬اگر شرطها را در برنامه ترکیب کنید استفاده از عملگرهای منطقی )&&( ‪ AND‬و )||( ‪OR‬به جای عملگرهای بیتی‬
‫)&(‪ AND‬و )|( ‪ OR‬بهتر خواهد بود‪ .‬یکی دیگر از عملگرهای منطقی عملگر )!( ‪NOT‬است که نتیجه یک عبارت را خنثی یا منفی‬
‫میکند‪.‬به مثال زیر توجه کنید‪:‬‬
‫))‪if (!(x == 2‬‬

‫{‬
‫;"‪cout << "x is not equal to 2.‬‬
‫}‬
‫اگر نتیجه عبارت ‪ x == 2‬برابر ‪ false‬باشد عملگر ! آن را ‪ True‬میکند‪.‬‬
‫دستور ‪Switch‬‬
‫در ‪ C++‬ساختاری به نام ‪ switch‬وجود دارد که به شما اجازه میدهد که با توجه به مقدار ثابت یک متغیر چندین انتخاب داشته‬
‫باشید‪ .‬دستور ‪switch‬معادل دستور ‪ if‬تو در تو است با این تفاوت که در دستور ‪ switch‬متغیر فقط مقادیر ثابتی از اعداد ‪،‬‬
‫رشتهها و یا کاراکترها را قبول میکند ‪.‬مقادیر ثابت مقادیری هستند که قابل تغیر نیستند‪ .‬در زیر نحوه استفاده از دستور ‪switch‬‬
‫)‪switch (testVar‬‬
‫{‬
‫‪case compareVal1:‬‬
‫‪code to execute‬‬ ‫;‪if testVar == compareVa11‬‬
‫;‪break‬‬
‫‪case compareVa12:‬‬
‫‪code to execute‬‬ ‫;‪if testVar == compareVa12‬‬
‫;‪break‬‬
‫‪.‬‬
‫‪.‬‬
‫‪.‬‬
‫‪case compareVa1N:‬‬
‫‪code to execute‬‬ ‫;‪if testVer == compareVa1N‬‬
‫;‪break‬‬
‫‪default:‬‬
‫‪code to execute‬‬ ‫;‪if none of the values above match the testVar‬‬
‫;‪break‬‬
‫}‬
‫ابتدا یک مقدار در متغیر ‪ switch‬که در مثال باال ‪ testVar‬است قرار میدهید‪.‬این مقدار با هر یک از عبارتهای ‪ case‬داخل‬
‫بلوک ‪ switch‬مقایسه میشود ‪.‬اگر مقدار متغیر با هر یک از مقادیر موجود در دستورات ‪ case‬برابر بود کد مربوط به آن‪case‬‬
‫اجرا خواهد شد‪ .‬به این نکته توجه کنید که حتی اگر تعداد خط کدهای داخل دستور ‪ case‬از یکی بیشتر باشد نباید از آکوالد‬
‫استفاده کنیم‪ .‬آخر هر دستور ‪ case‬با کلمه کلیدی ‪ break‬تشخیص داده میشود که باعث میشود برنامه از دستور ‪switch‬‬
‫خارج شده ودستورات بعد از آن اجرا شوند‪ .‬اگر این کلمه کلیدی از قلم بیوفتد برنامه با خطا مواجه میشود‪ .‬دستور ‪ switch‬یک‬
‫‪default‬دارد‪ .‬این دستور در صورتی اجرا میشود که مقدار متغیر با هیچ یک از مقادیر دستورات ‪ case‬برابر نباشد‪.‬‬ ‫بخش‬
‫دستور ‪ default‬اختیاری است و اگر از بدنه ‪ switch‬حذف شود هیچ اتفاقی نمیافتد‪ .‬مکان این دستور هم مهم نیست اما بر‬
‫طبق تعریف آن را در پایان دستورات مینویسند‪ .‬به مثالی در مورد دستور ‪switch‬توجه کنید‪:‬‬
‫>‪#include <String‬‬
‫{‬
‫;‪int choice‬‬
‫‪cout‬‬ ‫<<‬ ‫;‪"What's your favorite pet?" << endl‬‬

‫‪cout‬‬ ‫<<‬ ‫;‪"[1] Dog" << endl‬‬
‫‪cout‬‬ ‫<<‬ ‫;‪"[2] Cat" << endl‬‬
‫‪cout‬‬ ‫<<‬ ‫;‪"[3] Rabbit" << endl‬‬
‫‪cout‬‬ ‫<<‬ ‫;‪"[4] Turtle" << endl‬‬
‫‪cout‬‬ ‫<<‬ ‫;‪"[5] Fish" << endl‬‬
‫‪cout‬‬ ‫<<‬ ‫;‪"[6] Not in the choices" << endl‬‬
cout << "Enter your choice: " << endl;
cin >> choice;
switch (choice)
{
case 1:
cout << "Your favorite pet is Dog." << endl;
break;
case 2:
cout << "Your favorite pet is Cat." << endl;
break;
case 3:
cout << "Your favorite pet is Rabbit." << endl;
break;
case 4:
cout << "Your favorite pet is Turtle." << endl;
break;
case 5:
cout << "Your favorite pet is Fish." << endl;
break;
case 6:
cout << "Your favorite pet is not in the choices." << endl;
break;
default:
cout << "You don't have a favorite pet." << endl;
break;
}
}
What's your favorite pet?

[1] Dog
[2] Cat
[3] Rabbit
[4] Turtle
[5] Fish
[6] Not in the choices

Your favorite pet is Cat.
What's your favorite pet?
[1] Dog
[2] Cat
[3] Rabbit
[4] Turtle
[5] Fish
[6] Not in the choices

You don't have a favorite pet.
‫ شما عدد را‬.‫ به اسم هر حیوان یک عدد نسبت داده شده است‬.‫برنامه باال به شما اجازه انتخاب حیوان مورد عالقهتان را میدهد‬
‫ مقایسه میشود و با هر کدام از آن مقادیر که برابر بود پیغام مناسب‬case ‫ با مقادیر‬switch ‫وارد میکنید و این عدد در دستور‬
‫ یکی دیگر از ویژگیهای‬.‫ اجرا میشود‬default ‫ ها برابر نبود دستور‬case ‫ اگر هم با هیچ کدام از مقادیر‬.‫نما یش داده خواهد شد‬
‫دستور ‪ switch‬این است که شما میتوانید از دو یا چند ‪ case‬برای نشان داده یک مجموعه کد استفاده کنید‪ .‬در مثال زیر اگر‬
‫مقدار ‪ number‬عدد ‪2 ،9‬یا ‪ 1‬باشد یک کد اجرا میشود‪ .‬توجه کنید که ‪ case‬ها باید پشت سر هم نوشته شوند‪.‬‬
‫)‪switch (number‬‬
‫{‬
‫‪case 1:‬‬
‫‪case 2:‬‬
‫‪case 3:‬‬
‫;‪cout << "This code is shared by three values." << endl‬‬
‫;‪break‬‬
‫}‬
‫همانطور که قبالً ذکر شد دستور ‪ switch‬معادل دستور ‪ if‬تو در تو است‪ .‬برنامه باال را به صورت زیر نیز میتوان نوشت‪:‬‬
‫)‪if (choice == 1‬‬

‫‪cout << "Your favorite‬‬ ‫;‪pet is Dog." << endl‬‬
‫)‪else if (choice == 2‬‬
‫‪cout << "Your favorite‬‬ ‫;‪pet is Cat." << endl‬‬
‫‪cout << "Your favorite‬‬ ‫;‪pet is Rabbit." << endl‬‬
‫‪cout << "Your favorite‬‬ ‫;‪pet is Turtle." << endl‬‬
‫‪cout << "Your favorite‬‬ ‫;‪pet is Fish." << endl‬‬
‫‪cout << "Your favorite‬‬ ‫;‪pet is not in the choices." << endl‬‬
‫‪else‬‬
‫;‪cout << "You don't have a favorite pet." << endl‬‬
‫ً‬
‫دقیقا نتیجه ای مانند دستور ‪ switch‬دارد‪ .‬دستور ‪ default‬معادل دستور ‪ else‬میباشد‪ .‬حال از بین این دو دستور‬ ‫کد باال‬
‫(‪ switch‬و ‪ )if else‬کدامیک را انتخاب کنیم‪ .‬از دستور ‪ switch‬موقعی استفاده میکنیم که مقداری که میخواهیم با دیگر‬
‫مقادیر مقایسه شود ثابت باشد‪ .‬مثالً در مثال زیر هیچگاه از ‪ switch‬استفاده نکنید‪.‬‬

‫;‪int x = 5‬‬
‫)‪switch (myNumber‬‬
‫{‬
‫‪case x:‬‬
‫‪cout << "Error, you can't use variables as a value to be compared in a case‬‬
‫;"‪statment.‬‬
‫;‪break‬‬
‫}‬
‫مشاهده میکنید که با اینکه مقدار ‪ x‬عدد ‪ 5‬است و به طور واضح با متغیر ‪ myNumber‬مقایسه شده است برنامه خطا میدهد‬
‫چون ‪ x‬یک ثابت نیست بلکه یک متغیر است یا به زبان ساده تر ‪،‬قابلیت تغییر را دارد‪ .‬اگر بخواهید از ‪ x‬استفاده کنید و برنامه‬
‫خطا ندهد باید از کلمه کلیدی ‪ const‬به صورت زیر استفاده کنید‪.‬‬

‫;‪const int x = 5‬‬
‫{‬
‫‪case x:‬‬
‫;‪cout << "Error has been fixed!" << endl‬‬
‫;‪break‬‬
‫}‬
‫از کلمه کلیدی ‪ const‬برای ایجاد ثابتها استفاده میشود‪.‬توجه کنید که بعد از تعریف یک ثابت نمیتوان مقدار آن را در طول‬
‫ً‬
‫حتما مقداردهی کنید‪ .‬دستور ‪ switch‬یک مقدار را با مقادیر ‪ case‬ها‬ ‫برنامه تغییر داد‪ .‬به یاد داشته باشید که باید ثابتها را‬
‫مقایسه میکند و شما الزم نیست که به شکل زیر مقادیر را با هم مقایسه کنید‪:‬‬
‫{‬
‫‪case x > myNumber:‬‬
‫‪cout << "switch staments can't test if a value is less than or greater than the other‬‬
‫;"‪value.‬‬
‫;‪break‬‬
‫}‬
‫تکرار‬
‫ساختارهای تکرار به شما اجازه میدهند که یک یا چند دستور کد را تا زمانی که یک شرط برقرار است تکرار کنید‪.‬بدون ساختارهای‬
‫تکرار شما مجبورید همان تعداد کدها را بنویسید که بسیار خسته کننده است‪.‬مثالً شما مجبورید ‪ 91‬بار جمله ”‪“Hello World.‬‬
‫را تایپ کنید مانند مثال زیر‪:‬‬
‫‪cout‬‬ ‫<<‬ ‫‪"Hello‬‬ ‫"‪World.‬‬ ‫<<‬ ‫;‪endl‬‬

‫البته شما میتوانید با کپی کردن این تعداد کد را راحت بنویسید ولی این کار در کل کیفیت کدنویسی را پایین میآورد‪ .‬راه بهتر‬
‫برای نوشتن کدهای باال استفاده از حلقهها است‪ .‬حلقهها در ‪ C++‬عبارتاند از‪:‬‬
‫‪while‬‬ ‫‪‬‬
‫‪do while‬‬ ‫‪‬‬

‫‪for‬‬ ‫‪‬‬
‫حلقه ‪While‬‬
‫ابتداییترین ساختار تکرار در ‪ C++‬حلقه ‪ While‬است‪.‬ابتدا یک شرط را مورد بررسی قرار میدهد و تا زمانیکه شرط برقرار باشد‬
‫کدهای درون بلوک اجرا میشوند‪ .‬ساختار حلقه ‪While‬به صورت زیر است‪:‬‬
‫)‪while(condition‬‬
‫{‬
‫;‪code to loop‬‬
‫}‬
‫میبینید که ساختار ‪ While‬مانند ساختار ‪ if‬بسیار ساده است‪ .‬ابتدا یک شرط را که نتیجه آن یک مقدار بولی است مینویسیم‬
‫اگر نتیجه درست یا ‪true‬باشد سپس کدهای داخل بلوک ‪ While‬اجرا میشوند‪ .‬اگر شرط غلط یا ‪ false‬باشد وقتی که برنامه به‬
‫حلقه ‪ While‬برسد هیچکدام از کدها را اجرا نمیکند‪ .‬برای متوقف شدن حلقه باید مقادیر داخل حلقه ‪ While‬اصالح شوند‪ .‬به یک‬
‫متغیر شمارنده در داخل بدنه حلقه نیاز داریم‪ .‬این شمارنده برای آزمایش شرط مورد استفاده قرار میگیرد و ادامه یا توقف حلقه به‬
‫نوعی به آن وابسته است‪ .‬این شمارنده را در داخل بدنه باید کاهش یا افزایش دهیم‪ .‬در برنامه زیر نحوه استفاده از حلقه ‪While‬‬
‫{‬
‫;‪int counter = 1‬‬
‫)‪while (counter <= 10‬‬

‫{‬
‫;‪cout << "Hello World!" << endl‬‬
‫;‪counter++‬‬
‫}‬
‫}‬
‫‪Hello‬‬ ‫!‪World‬‬
‫برنامه باال ‪ 91‬بار پیغام !‪ Hello World‬را چاپ میکند‪ .‬اگر از حلقه در مثال باال استفاده نمیکردیم مجبور بودیم تمام ‪ 91‬خط را‬
‫تایپ کنیم‪ .‬اجازه دهید که نگاهی به کدهای برنامه فوق بیندازیم‪ .‬ابتدا در خط ‪ 9‬یک متغیر تعریف و از آن به عنوان شمارنده حلقه‬
‫استفاده شده است‪.‬سپس به آن مقدار ‪ 9‬را اختصاص میدهیم چون اگر مقدار نداشته باشد نمیتوان در شرط از آن استفاده کرد‪.‬‬
‫در خط ‪ 1‬حلقه ‪ While‬را وارد میکنیم‪ .‬در حلقه ‪ While‬ابتدا مقدار اولیه شمارنده با ‪ 91‬مقایسه میشود که آیا از ‪ 91‬کمتر است یا با‬
‫آن برابر است‪ .‬نتیجه هر بار مقایسه ورود به بدنه حلقه ‪ While‬و چاپ پیغام است‪ .‬همانطور که مشاهده میکنید بعد از هر بار‬
‫مقایسه مقدار شمارنده یک واحد اضافه میشود (خط ‪ .)97‬حلقه تا زمانی تکرار میشود که مقدار شمارنده از ‪ 91‬کمتر باشد‪.‬‬
‫اگر مقدار شمارنده یک بماند و آن را افزایش ندهیم و یا مقدار شرط هرگز ‪false‬نشود یک حلقه بینهایت به وجود میآید‪ .‬به‬
‫این نکته توجه کنید که در شرط باال به جای عالمت < از =< استفاده شده است‪ .‬اگر از عالمت <استفاده میکردیم کد ما ‪ 1‬بار تکرار‬
‫میشد چون مقدار اولیه ‪ 9‬است و هنگامی که شرط به ‪ 91‬برسد ‪false‬میشود چون ‪ 10<10‬نیست‪ .‬اگر میخواهید یک حلقه بی‬
‫نهایت ایجاد کن ید که هیچگاه متوقف نشود باید یک شرط ایجاد کنید که همواره درست )‪ (true‬باشد‪.‬‬
‫)‪while(true‬‬
‫{‬
‫‪//code to loop‬‬
‫}‬
‫این تکنیک در برخی موارد کارایی دارد و آن زمانی است که شما بخواهید با استفاده از دستورات ‪ break‬و ‪ return‬که در آینده‬
‫توضیح خواهیم داد از حلقه خارج شوید‪.‬‬
‫حلقه ‪do while‬‬
‫حلقه ‪ do while‬یکی دیگر از ساختارهای تکرار است‪ .‬این حلقه بسیار شبیه حلقه ‪ while‬است با این تفاوت که در این حلقه‬
‫ابتدا کد اجرا می شودو سپس شرط مورد بررسی قرار میگیرد‪ .‬ساختار حلقه ‪ do while‬به صورت زیر است‪:‬‬
‫‪do‬‬
‫{‬
‫;‪code to repeat‬‬
‫;)‪} while (condition‬‬
‫همانطور که مشاهده میکنید شرط در آخر ساختار قرار دارد‪ .‬این بدین معنی است که کدهای داخل بدنه حداقل یکبار اجرا میشوند‪.‬‬
‫برخالف حلقه ‪ while‬که اگر شرط نادرست باشد دستورات داخل بدنه اجرا نمیشوند‪ .‬برای اثبات این موضوع به کدهای زیر توجه‬
‫کنید‪:‬‬

‫‪do‬‬
‫{‬
‫;)‪} while (number > 10‬‬
‫با اجرای کد باال‪ ،‬اول دستورات بلوک ‪ do‬اجرا میشوند و بعد مقدار ‪ number‬با عدد ‪ 91‬مقایسه میشود‪ .‬در نتیجه حتی اگر شرط‬
‫نادرست باشد باز هم قسمت ‪do‬حداقل یک بار اجرا میشوند‪.‬‬

‫)‪while (number > 10‬‬
‫{‬
‫}‬
‫اما در کد باال چون اول مقدار ‪ number‬ابتدا مورد مقایسه قرار میگیرد‪ ،‬اگر شرط درست نباشد دیگر کدی اجرا نمیشود‪ .‬یکی از‬
‫موارد برتری استفاده از حلقه ‪ do while‬نسبت به حلقه ‪ while‬زمانی است که شما بخواهید اطالعاتی از کاربر دریافت کنید‪.‬‬
‫در دو کد زیر‪ ،‬یک عملیات یکسان توسط دو حلقه ‪ while‬و ‪ do while‬پیاده سازی شده است‪:‬‬
‫‪//while version‬‬
‫;‪cout << "Enter a number greater than 10: " << endl‬‬
‫;‪cin >> number‬‬
‫)‪while (number < 10‬‬

‫{‬
‫}‬
‫‪//do while version‬‬
‫‪do‬‬
‫{‬
‫;)‪} while (number < 10‬‬
‫مشاهده میکنید که از کدهای کمتری در بدنه ‪ do while‬نسبت به ‪ while‬استفاده شده است‪.‬‬

‫حلقه ‪for‬‬
‫یکی دیگر از ساختارهای تکرار حلقه ‪ for‬است‪ .‬این حلقه عملی شبیه به حلقه ‪ while‬انجام میدهد و فقط دارای چند خصوصیت‬
‫اضافی است‪ .‬ساختار حلقه ‪ for‬به صورت زیر است‪:‬‬
‫)‪for(initialization; condition; operation‬‬

‫{‬
‫;‪code to repeat‬‬
‫}‬
‫مقدار دهی اولیه )‪ (initialization‬اولین مقداری است که به شمارنده حلقه میدهیم‪.‬شمارنده فقط در داخل حلقه ‪for‬‬
‫قابل دسترسی است‪.‬‬
‫شرط )‪ (condition‬در اینجا مقدار شمارنده را با یک مقدار دیگر مقایسه میکند و تعیین میکند که حلقه ادامه یابد یا نه‪.‬‬
‫عملگر )‪ (operation‬که مقدار اولیه متغیر را کاهش یا افزایش میدهد‪.‬‬
‫در زیر یک مثال از حلقه ‪ for‬آمده است‪:‬‬
‫{‬
‫)‪for (int i = 1; i <= 10; i++‬‬
‫{‬
‫;‪cout << "Number " << i << endl‬‬
‫}‬
‫}‬
‫‪Number‬‬ ‫‪1‬‬
‫‪Number‬‬ ‫‪2‬‬
‫‪Number‬‬ ‫‪3‬‬
‫‪Number‬‬ ‫‪4‬‬
‫‪Number‬‬ ‫‪5‬‬
‫‪Number‬‬ ‫‪6‬‬
‫‪Number‬‬ ‫‪7‬‬
‫‪Number‬‬ ‫‪8‬‬
‫‪Number‬‬ ‫‪9‬‬
‫‪Number‬‬ ‫‪10‬‬
‫برنامه باال اعداد ‪ 9‬تا ‪ 91‬را با استفاده از حلقه ‪ for‬میشمارد‪.‬ابتدا یک متغیر به عنوان شمارنده تعریف میکنیم و آن را با مقدار ‪9‬‬
‫مقدار دهی اولیه میکنیم‪ .‬سپس با استفاده از شرط آن را با مقدار ‪ 91‬مقایسه میکنیم که آیا کمتر است یا مساوی؟ توجه کنید که‬
‫ً‬
‫فورا اجرا نمیشود‪ .‬کد اجرا میشود و ابتدا رشته ‪ Number‬و سپس مقدار جاری ‪ i‬یعنی ‪ 9‬را چاپ‬ ‫قسمت سوم حلقه )‪(i++‬‬
‫میکند‪ .‬آنگاه یک واحد به مقدار ‪ i‬اضافه شده و مقدار ‪ i‬برابر ‪ 7‬میشود و بار دیگر ‪ i‬با عدد ‪ 91‬مقایسه میشود و این حلقه تا‬
‫زمانی که مقدار شرط ‪ true‬شود ادامه مییابد ‪ .‬حال اگر بخواهید معکوس برنامه باال را پیاده سازی کنید یعنی اعداد از بزرگ به‬
‫کوچک چاپ شوند باید به صورت زیر عمل کنید‪:‬‬
‫)‪for (int i = 10; i > 0; i--‬‬

‫{‬
‫‪//code omitted‬‬
‫}‬
‫کد باال اعداد را از ‪ 91‬به ‪ 9‬چاپ میکند (از بزرگ به کوچک)‪ .‬مقدار اولیه شمارنده را ‪ 91‬میدهیم و با استفاده از عملگر کاهش (‪)--‬‬
‫برنامه ای که شمارش معکوس را انجام میدهد ایجاد میکنیم‪ .‬میتوان قسمت شرط و عملگر را به صورتهای دیگر نیز تغییر داد‪.‬‬
‫به عنوان مثال میتوان از عملگرهای منطقی در قسمت شرط و از عملگرهای تخصیصی در قسمت عملگر افزایش یا کاهش استفاده‬
‫کرد‪ .‬همچنین میتوانید از چندین متغیر در ساختار حلقه ‪ for‬استفاده کنید‪.‬‬
‫)‪for (int i = 1, y = 2; i < 10 && y > 20; i++, y -= 2‬‬

‫{‬
‫‪//some code here‬‬
‫}‬
‫به این نکته توجه کنید که اگر از چندین متغیر شمارنده یا عملگر در حلقه ‪for‬استفاده میکنید باید آنها را با استفاده از کاما از‬
‫هم جدا کنید‪.‬‬
‫حلقههای تو در تو )‪(Nested Loops‬‬
‫‪ C++‬به شما اجازه میدهد که از حلقهها به صورت تو در تو استفاده کنید‪ .‬اگر یک حلقه در داخل حلقه دیگر قرار بگیرد‪ ،‬به آن حلقه‬
‫تو در تو گفته میشود‪ .‬در این نوع حلقهها ‪ ،‬به ازای اجرای یک بار حلقه بیرونی‪ ،‬حلقه داخلی به طور کامل اجرا میشود‪ .‬در زیر نحوه‬
‫ایجاد حلقه تو در تو آمده است‪:‬‬
‫)‪for (init; condition; increment‬‬

‫{‬
‫)‪for (init; condition; increment‬‬
‫{‬
‫;)‪//statement(s‬‬
‫}‬
‫}‬
‫)‪while (condition‬‬
‫{‬
‫)‪while (condition‬‬
‫{‬
‫}‬
‫}‬
‫‪do‬‬
‫{‬
‫‪do‬‬
‫{‬
‫نکته ای که در مورد حلقههای تو در تو وجود دارد این اسن که میتوان از یک نوع حلقه در داخل نوع دیگر استفاده کرد‪ .‬مثالً‬
‫میتوان از حلقه ‪ for‬در داخل حلقه ‪ while‬استفاده نمود‪ .‬در مثال زیر نحوه استفاده از این حلقهها ذکر شده است‪ .‬فرض کنید‬
‫که میخواهید یک مستطیل با ‪ 1‬سطر و ‪ 5‬ستون ایجاد کنید‪:‬‬

‫‪3‬‬
‫‪4‬‬ ‫)(‪int main‬‬
‫‪5‬‬ ‫{‬
‫‪6‬‬ ‫)‪for (int i = 1; i <= 4; i++‬‬
‫‪7‬‬ ‫{‬
‫‪8‬‬ ‫)‪for (int j = 1; j <= 5; j++‬‬
‫‪9‬‬ ‫{‬
‫‪10‬‬ ‫;" * " << ‪cout‬‬
‫‪11‬‬ ‫}‬
‫‪12‬‬ ‫;‪cout << endl‬‬
‫‪13‬‬ ‫}‬
‫‪14‬‬
‫‪15‬‬ ‫}‬
‫*‬ ‫*‬ ‫*‬ ‫*‬ ‫*‬

‫*‬ ‫*‬ ‫*‬ ‫*‬ ‫*‬
‫*‬ ‫*‬ ‫*‬ ‫*‬ ‫*‬
‫*‬ ‫*‬ ‫*‬ ‫*‬ ‫*‬
‫در کد باال به ازای یک بار اجرای حلقه ‪ for‬اول (خط ‪ ،)1‬حلقه ‪ for‬دوم (‪ )8-99‬به طور کامل اجرا میشود‪ .‬یعنی وقتی مقدار ‪i‬‬
‫برابر عدد ‪ 9‬میشود‪ ،‬عالمت * توسط حلقه دوم ‪ 5‬بار چاپ میشود‪ ،‬وقتی ‪ i‬برابر ‪ 7‬میشود‪ ،‬دوباره عالمت * پنج بار چاپ میشود‬
‫و … ‪ .‬در کل منظور از دو حلقه ‪ for‬این است که در ‪ 4‬سطر عالمت * در ‪ 5‬ستون چاپ شود یا ‪ 4‬سطر ایجاد شود و در هر سطر ‪5‬‬
‫بار عالمت * چاپ شود‪ .‬خط ‪ 97‬هم برای ایجاد خط جدید است‪ .‬یعنی وقتی حلقه داخلی به طور کامل اجرا شد‪ ،‬یک خط جدید‬
‫ایجاد میشود و عالمتهای * در خطوط جدید چاپ میشوند‪.‬‬
‫خارج شدن از حلقه با استفاده از ‪ break‬و ‪continue‬‬
‫گاهی اوقات با وجود درست بودن شرط میخواهیم حلقه متوقف شود‪ .‬سؤال اینجاست که چطور این کار را انجام دهید؟ با استفاده‬
‫از کلمه کلیدی ‪break‬حلقه را متوقف کرده و با استفاده از کلمه کلیدی ‪ continue‬میتوان بخشی از حلقه را رد کرد و به مرحله‬
‫بعد رفت‪ .‬برنامه زیر نحوه استفاده از ‪ continue‬و ‪ break‬را نشان میدهد‪:‬‬
‫{‬
‫;‪cout << "Demonstrating the use of break" << endl‬‬
‫)‪for (int x = 1; x < 10; x++‬‬

‫{‬
‫)‪if (x == 5‬‬
‫;‪break‬‬
‫;‪cout << "Number " << x << endl‬‬

‫}‬
‫;‪cout << endl‬‬
‫;‪cout << "Demonstrating the use of continue." << endl‬‬
‫)‪for (int x = 1; x < 10; x++‬‬

‫{‬
‫)‪if (x == 5‬‬
‫;‪continue‬‬
‫;‪cout << "Number " << x << endl‬‬

‫}‬
‫}‬
‫‪Demonstrating the use of break.‬‬
‫‪Number‬‬ ‫‪1‬‬
‫‪Number‬‬ ‫‪2‬‬
‫‪Number‬‬ ‫‪3‬‬
‫‪Number‬‬ ‫‪4‬‬
‫‪Demonstrating the use of continue.‬‬
‫‪Number 1‬‬
‫‪Number 2‬‬
‫‪Number‬‬ ‫‪3‬‬
‫‪Number‬‬ ‫‪4‬‬
‫‪Number‬‬ ‫‪6‬‬
‫‪Number‬‬ ‫‪7‬‬
‫‪Number‬‬ ‫‪8‬‬
‫‪Number‬‬ ‫‪9‬‬
‫در این برنامه از حلقه ‪ for‬برای نشان دادن کاربرد دو کلمه کلیدی فوق استفاده شده است اگر به جای ‪for‬از حلقههای ‪while‬‬
‫و ‪do…while‬استفاده میشد نتیجه یکسانی به دست میآمد‪ .‬همانطور که در شرط برنامه (خط ‪ )99‬آمده است وقتی که مقدار ‪x‬‬
‫به عدد ‪ 5‬رسید سپس دستور ‪break‬اجرا شود(خط ‪)97‬‬
‫حلقه بالفاصله متوقف میشود حتی اگر شرط ‪ x < 10‬برقرار باشد‪.‬از طرف دیگر در خط ‪ 74‬حلقه ‪for‬فقط برای یک تکرار خاص‬
‫متوقف شده و سپس ادامه مییابد‪(.‬وقتی مقدار ‪ x‬برابر ‪5‬شود حلقه از ‪ 5‬رد شده و مقدار ‪ 5‬را چاپ نمیکند و بقیه مقادیر چاپ‬
‫میشوند)‪.‬‬
‫آرایهها‬
‫آرایه نوعی متغیر است که لیستی از آدرسهای مجموعه ای از دادههای هم نوع را در خود ذخیره میکند‪.‬تعریف چندین متغیر از‬
‫یک نوع برای هدفی یکسان بسیار خسته کننده است‪.‬مثالً اگر بخواهید صد متغیر از نوع اعداد صحیح تعریف کرده و از آنها‬
‫ً‬
‫طمئنا تعریف این همه متغیر بسیار کسالت آور و خسته کننده است‪.‬اما با استفاده از آرایه میتوان همه آنها را در‬‫استفاده کنید‪ .‬م‬
‫یک خط تعریف کرد‪ .‬در زیر راهی ساده برای تعریف یک آرایه نشان داده شده است‪:‬‬
‫;]‪datatype arrayName[length‬‬
‫‪ Datatype‬نوع دادههایی را نشان میدهد که آرایه در خود ذخیره میکند‪.‬کروشه که بعد از نوع داده قرار میگیرد و نشان دهنده‬
‫استفاده از آرایه است ‪. lenght‬یا طول آرایه که به کامپایلر میگوید شما قصد دارید چه تعداد داده یا مقدار را در آرایه ذخیره‬
‫کنید‪ arrayName .‬که نام آرایه را نشان میدهد‪.‬هنگام نامگذاری آرایه بهتر است که نام آرایه نشان دهنده نوع آرایه باشد‪.‬به‬
‫عنوان مثال برای نامگذاری آرایه ای که اعداد را در خود ذخیره میکند از کلمه ‪ numbers‬استفاده کنید‪.‬برای تعریف یک آرایه که ‪5‬‬
‫مقدار از نوع اعداد صحیح در خود ذخیره میکند باید به صورت زیر عمل کنیم‪:‬‬
‫;]‪int numbers[5‬‬
‫در این مثال ‪ 5‬آدرس از فضای حافظه کامپیوتر شما برای ذخیره ‪ 5‬مقدار رزرو میشود ‪ .‬حال چطور مقادیرمان را در هر یک از این‬
‫آدرسها ذخیره کنیم؟ برای دسترسی و اصالح مقادیر آرایه از اندیس یا مکان آنها استفاده میشود‪.‬‬
‫]‪numbers[0‬‬ ‫=‬ ‫;‪1‬‬

‫]‪numbers[1‬‬ ‫=‬ ‫;‪2‬‬
‫]‪numbers[2‬‬ ‫=‬ ‫;‪3‬‬
‫]‪numbers[3‬‬ ‫=‬ ‫;‪4‬‬
‫]‪numbers[4‬‬ ‫=‬ ‫;‪5‬‬
‫اندیس یک آرایه از صفر شروع شده و به یک واحد کمتر از طول آرایه ختم میشود‪.‬به عنوان مثال شما یک آرایه ‪ 5‬عضوی‬
‫دارید‪،‬اندیس آرایه از ‪ 1‬تا ‪ 4‬میباشد چون طول آرایه ‪ 5‬است پس ‪ 5-9‬برابر است با ‪.4‬این بدان معناست که اندیس ‪ 1‬نشان دهنده‬
‫اولین عضو آرایه است و اندیس ‪ 9‬نشان دهنده دومین عضو و الی آخر‪ .‬برای درک بهتر مثال باال به شکل زیر توجه کنید‪:‬‬
‫به هر یک از اجزاء آرایه و اندیسهای داخل کروشه توجه کنید‪ .‬کسانی که تازه شروع به برنامه نویسی کردهاند معموال ً در گذاشتن‬
‫اندیس دچار اشتباه میشوند و مثالً ممکن است در مثال باال اندیسها را از ‪ 9‬شروع کنند‪ .‬یکی دیگر از راههای تعریف سریع و مقدار‬
‫دهی یک آرایه به صورت زیر است‪:‬‬
‫;} ‪datatype arrayName[length] = { val1, val2, ... valN‬‬
‫ً‬
‫فورا بعد از تعریف اندازه آرایه مقادیر را در داخل آکوالد قرار دهید‪ .‬به یاد داشته باشید که هر کدام از‬ ‫ر این روش شما میتوانید‬
‫مقادیر را با استفاده از کاما از هم جدا کنید‪ .‬همچنین تعداد مقادیر داخل آکوالد باید با اندازه آرایه تعریف شده برابر باشد‪ .‬به مثال‬
‫زیر توجه کنید‪:‬‬
‫;} ‪int numbers[5] = { 1, 2, 3, 4, 5‬‬
‫این مثال با مثال قبل هیچ تفاوتی ندارد و تعداد خطهای کدنویسی را کاهش میدهد‪.‬شما میتوانید با استفاده از اندیس به مقدار‬
‫هر یک از اجزاء آرایه دسترسی یابید و آنها را به دلخواه تغییر دهید‪.‬تعداد اجزاء آرایه در مثال باال ‪ 5‬است و ما ‪ 5‬مقدار را در آن‬
‫قرار میدهیم‪ .‬اگر تعداد مقادیری که در آرایه قرار میدهیم کمتر یا بیشتر از طول آرایه باشد با خطا مواجه میشویم‪.‬یک راه بسیار‬
‫ساده تر برای تعریف آرایه به صورت زیر است‪:‬‬
‫;} ‪int numbers[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10‬‬
‫به سادگی و بدون احتیاج ذکر طول میتوان مقادیر را در داخل آکوالد قرار داد‪ .‬کامپایلر به صورت اتوماتیک با شمارش مقادیر طول‬
‫آرایه را تشخیص میدهد‪.‬‬

‫دستیابی به مقادیر آرایه با استفاده از حلقه‪for‬‬
‫در زیر مثالی در مورد استفاده از آرایهها آمده است‪ .‬در این برنامه ‪ 5‬مقدار از کاربر گرفته شده و میانگین آنها حساب میشود‪:‬‬
‫{‬
‫;]‪int numbers[5‬‬
‫;‪int total = 0‬‬

‫;‪double average‬‬
‫)‪for (int i = 0; i < size(numbers); i++‬‬

‫{‬
‫;" ‪cout << "Enter a number:‬‬
‫;]‪cin >> numbers[i‬‬
‫}‬
‫)‪for (int i = 0; i < size(numbers); i++‬‬

‫{‬
‫;]‪total += numbers[i‬‬
‫}‬
‫;)‪average = total / (double)size(numbers‬‬
‫;‪cout << "Average = " << average << endl‬‬

‫}‬
‫‪Enter a‬‬ ‫‪number:‬‬ ‫‪90‬‬

‫‪Average‬‬ ‫‪= 86‬‬
‫در خط ‪ 1‬یک آرایه تعریف شده است که میتواند ‪ 5‬عدد صحیح را در خود ذخیره کند‪.‬خطوط ‪ 8‬و ‪ 1‬متغیرهایی تعریف شدهاند که‬
‫از آنها برای محاسبه میانگین استفاده میشود‪.‬توجه کنید که مقدار اولیه ‪ total‬صفر است تا از بروز خطا هنگام اضافه شدن‬
‫مقدار به آن جلوگیری شود‪.‬در خطوط ‪ 99‬تا ‪ 95‬حلقه ‪ for‬برای تکرار و گرفتن ورودی از کاربر تعریف شده است‪.‬از متد )(‪size‬‬
‫برای تشخیص تعداد اجزای آرایه استفاده میشود‪.‬اگر چه میتوانستیم به سادگی در حلقه ‪ for‬مقدار ‪ 5‬را برای شرط قرار دهیم‬
‫ولی استفاده از خاصیت طول آرایه کار راحت تری است و میتوانیم طول آرایه را تغییر دهیم و شرط حلقه ‪ for‬با تغییر جدید‬
‫هماهنگ میشود‪ .‬در خط ‪ 94‬ورودی دریافت شده از کاربر در آرایه ذخیره میشود‪.‬اندیس استفاده شده در ‪( number‬خط ‪)94‬‬
‫مقدار ‪ i‬جاری در حلقه است‪.‬برای مثال در ابتدای حلقه مقدار ‪ i‬صفر است بنابراین وقتی در خط ‪ 94‬اولین داده از کاربر گرفته‬
‫میشود اندیس آن برابر صفر میشود‪ .‬در تکرار بعدی ‪ i‬یک واحد اضافه میشود و در نتیجه در خط ‪ 94‬و بعد از ورود دومین داده‬
‫توسط کاربر اندیس آن برابر یک میشود‪ .‬این حالت تا زمانی که شرط در حلقه ‪ for‬برقرار است ادامه مییابد‪ .‬در خطوط ‪ 99-71‬از‬
‫حلقه ‪ for‬دیگر برای دسترسی به مقدار هر یک از دادههای آرایه استفاده شده است‪.‬در این حلقه نیز مانند حلقه قبل از مقدار‬
‫متغیر شمارنده به عنوان اندیس استفاده میکنیم‪.‬‬
‫هر یک از اجزای عددی آرایه به متغیر ‪ total‬اضافه میشوند‪ .‬بعد از پایان حلقه میتوانیم میانگین اعداد را حساب کنیم (خط‬
‫‪ .)77‬مقدار ‪ total‬را بر تعداد اجزای آرایه ( تعداد عددها) تقسیم میکنیم‪.‬برای دسترسی به تعداد اجزای آرایه میتوان از متد‬
‫‪()size‬استفاده کرد‪.‬توجه کنید که در اینجا ما خروجی متد ‪ ()size‬را به نوع ‪ double‬تبدیل کردهایم بنابراین نتیجه عبارت‬
‫یک مقدار از نوع ‪ double‬خواهد شد و دارای بخش کسری میباشد‪ .‬حال اگر عملوندهای تقسیم را به نوع ‪ double‬تبدیل‬
‫نکنیم نتیجه تقسیم یک عدد از نوع صحیح خواهد شد و دارای بخش کسری نیست‪ .‬خط ‪ 74‬مقدار میانگین را در صفحه نمایش‬
‫چاپ میکند‪ .‬طول آرایه بعد از مقدار دهی نمیتواند تغیر کند‪ .‬به عنوان مثال اگر یک آرایه را که شامل ‪ 5‬جز است مقدار دهی کنید‬
‫دیگر نمیتوانید آن را مثالً به ‪ 91‬جز تغییر اندازه دهید‪.‬البته تعداد خاصی از کالسها مانند آرایهها عمل میکنند و توانایی تغییر‬
‫تعداد اجزای تشکیل دهنده خود را دارند‪.‬آرایهها در برخی شرایط بسیار پر کاربرد هستند و تسلط شما بر این مفهوم و اینکه چطور‬
‫از آنها استفاده کنید بسیار مهم است‪.‬‬
‫آرایههای چند بعدی‬
‫آرایههای چند بعدی آرایههایی هستند که برای دسترسی به هر یک از عناصر آنها باید از چندین اندیس استفاده کنیم‪.‬یک آرایه‬
‫چند بعدی را میتوان مانند یک جدول با تعدای ستون و ردیف تصور کنید‪ .‬با افزایش اندیسها اندازه ابعاد آرایه نیز افزایش مییابد‬
‫و آرایههای چند بعدی با بیش از دو اندیس به وجود میآیند‪ .‬نحوه ایجاد یک آرایه با دو بعد به صورت زیر است‪:‬‬
‫;]‪datatype arrayName[lengthX][lengthY‬‬
‫و یک آرایه سه بعدی به صورت زیر ایجاد میشود‪:‬‬
‫;]‪datatype arrayName[lengthX][lengthY][lengthZ‬‬
‫میتوان یک آرایه با تعداد زیادی بعد ایجاد کرد به شرطی که هر بعد دارای طول مشخصی باشد‪ .‬به دلیل اینکه آرایههای سه بعدی‬
‫یا آرایههای با بیشتر از دو بعد بسیار کمتر مورد استفاده قرار میگیرند اجازه بدهید که در این درس بر روی آرایههای دو بعدی تمرکز‬
‫کنیم‪ .‬در تعریف این نوع آرایه ابتدا نوع آرایه یعنی اینکه آرایه چه نوعی از انواع داده را در خود ذخیره میکند را مشخص میکنیم‪.‬‬
‫سپس نام آرایه و در نهایت دو جفت کروشه قرار میدهیم ‪ .‬در یک آرایه دو بعدی برای دسترسی به هر یک از عناصر به دو مقدار‬
‫نیاز داریم یکی مقدار ‪ X‬و دیگری مقدار ‪ Y‬که مقدار ‪ x‬نشان دهنده ردیف و مقدار ‪ Y‬نشان دهنده ستون آرایه است البته اگر ما‬
‫آرایه دو بعدی را به صورت جدول در نظر بگیریم‪.‬یک آرایه سه بعدی را میتوان به صورت یک مکعب تصور کرد که دارای سه بعد‬
‫است و ‪ x‬طول‪Y ،‬عرض و ‪ z‬ارتفاع آن است‪ .‬یک مثال از آرایه دو بعدی در زیر آمده است‪:‬‬
‫;]‪int numbers[3][5‬‬
‫کد باال به کامپایلر میگوید که فضای کافی به عناصر آرایه اختصاص بده (در این مثال ‪ 95‬خانه)‪ .‬در شکل زیر مکان هر عنصر در یک‬
‫آرایه دو بعدی نشان داده شده است‪.‬‬
‫مقدار ‪ 1‬را به ‪ x‬اختصاص میدهیم چون ‪ 1‬سطر و مقدار ‪ 5‬را به ‪ Y‬چون ‪ 5‬ستون داریم اختصاص میدهیم‪ .‬چطور یک آرایه چند‬
‫بعدی را مقدار دهی کنیم؟ چند راه برای مقدار دهی به آرایهها وجود دارد‪.‬‬
‫‪datatype arrayName[x][y] = { { r0c0, r0c1, ... r0cX },‬‬

‫‪{ r1c0, r1c1, ... r1cX },‬‬
‫‪.‬‬
‫‪.‬‬
‫‪.‬‬
‫} ‪{ rYc0, rYc1, ... rYcX‬‬
‫;}‬
‫ً‬
‫حتما باید ذکر شوند‪:‬‬ ‫البته میتوان تعداد سطرها را هم ننوشت ولی تعداد ستونها‬
‫‪datatype arrayName[][y] = { { r0c0, r0c1, ... r0cX },‬‬

‫‪{ r1c0, r1c1, ... r1cX },‬‬
‫‪.‬‬
‫‪.‬‬
‫‪.‬‬
‫} ‪{ rYc0, rYc1, ... rYcX‬‬
‫;}‬
‫‪int numbers[][5] = { { 1, 2, 3, 4, 5 },‬‬

‫‪{ 6, 7, 8, 9, 10 },‬‬
‫} ‪{ 11, 12, 13, 14, 15‬‬
‫;}‬
‫و یا میتوان مقدار دهی به عناصر را به صورت دستی انجام داد مانند‪:‬‬
‫]‪array[0][0‬‬ ‫=‬ ‫;‪value‬‬

‫]‪array[0][1‬‬ ‫=‬ ‫;‪value‬‬
‫]‪array[0][2‬‬ ‫=‬ ‫;‪value‬‬
‫]‪array[1][0‬‬ ‫=‬ ‫;‪value‬‬
‫]‪array[1][1‬‬ ‫=‬ ‫;‪value‬‬
‫]‪array[1][2‬‬ ‫=‬ ‫;‪value‬‬
‫]‪array[2][0‬‬ ‫=‬ ‫;‪value‬‬
‫]‪array[2][1‬‬ ‫=‬ ‫;‪value‬‬
‫]‪array[2][2‬‬ ‫=‬ ‫;‪value‬‬
‫همانطور که مشاهده میکنید برای دسترسی به هر یک از عناصر در یک آرایه دو بعدی به سادگی میتوان از اندیسهای ‪ X‬و ‪Y‬‬
‫و یک جفت کروشه مانند مثال استفاده کرد‪.‬‬
‫گردش در میان عناصر آرایههای چند بعدی‬
‫گردش در میان عناصر آرایههای چند بعدی نیاز به کمی دقت دارد‪ .‬برنامه زیر نشان میدهد که چطور از حلقه ‪ for‬برای خواندن‬
‫همه مقادیر آرایه و تعیین انتهای ردیفها استفاده کنید‪.‬‬

‫‪3‬‬
‫‪4‬‬ ‫)(‪int main‬‬
‫‪5‬‬ ‫{‬
‫‪6‬‬ ‫{ = ]‪int numbers[3][5‬‬
‫‪7‬‬ ‫‪{ 1 , 2 , 3 , 4 , 5 },‬‬
‫‪8‬‬ ‫‪{ 6 , 7 , 8 , 9 , 10 },‬‬
‫‪9‬‬ ‫} ‪{ 11, 12, 13, 14, 15‬‬
‫‪10‬‬ ‫;}‬
‫‪11‬‬
‫‪12‬‬ ‫)‪for (int row = 0; row < size(numbers); row++‬‬
‫‪13‬‬ ‫{‬
‫‪14‬‬ ‫)‪for (int col = 0; col < size(numbers[0]); col++‬‬
‫‪15‬‬ ‫{‬
‫‪16‬‬ ‫;" " << ]‪cout << numbers[row][col‬‬
‫‪17‬‬ ‫}‬
‫‪18‬‬
‫‪19‬‬ ‫‪//Go to the next line‬‬
‫‪20‬‬ ‫;‪cout << endl‬‬
‫‪21‬‬ ‫}‬
‫‪22‬‬ ‫}‬
‫‪1 2 3 4 5‬‬
‫‪6 7 8 9 10‬‬
‫‪11 12 13 14 15‬‬
‫همانطور که در مثال باال نشان داده شده است با استفاده از یک حلقه ‪ for‬نمیتوان به مقادیر دسترسی یافت بلکه به یک حلقه‬
‫‪ for‬تو در تو نیاز داریم‪ ،‬زیرا آرایه دو بعدی به صورت یک جدول شامل سطر و ستون است ‪ ،‬پس الزم است که از یک حلقه ‪for‬‬
‫برای گردش در میان سطرها و از حلقه ‪ for‬دیگر برای گردش در میان ستونهای این جدول (آرایه) استفاده کنیم‪.‬‬
‫اولین حلقه ‪( for‬خط ‪ )97‬برای گردش در میان ردیفهای آرایه به کار میرود ‪.‬این حلقه تا زمانی ادامه مییابد که مقدار ردیف‬
‫کمتر از طول اولین بعد باشد (زیرا اندیس ابعاد آرایه از صفر شروع میشود‪ .‬در مثال باال مقدار اولین بعد برابر ‪ 1‬است)‪ .‬در این مثال‬
‫از متد )(‪ size‬استفاده کردهایم‪.‬این متد طول آرایه را در یک بعد خاص نشان میدهد‪ .‬به عنوان مثال برای به دست آوردن طول‬
‫اولین یا همان تعداد سطرها کافیست که نام آرایه را به این متد ارسال میکنیم‪.‬‬
‫در داخل اولین حلقه ‪ for‬حلقه ‪ for‬دیگری تعریف شده است (خط ‪ .)94‬در این حلقه یک شمارنده برای شمارش تعداد ستونهای‬
‫)‪(col‬هر ردیف تعریف شده است و در شرط داخل آن بار دیگر از متد )(‪ size‬استفاده شده است‪ ،‬ولی این بار مقدار‬
‫]‪ numbers[0‬را به آن ارسال میکنیم تا طول بعد دوم آرایه را به دست آوریم ‪.‬پس به عنوان مثال وقتی که مقدار ردیف )‪(row‬‬
‫صفر باشد‪ ،‬حلقه دوم از ]‪ [0][0‬تا [‪ ]4[]0‬اجرا میشود ‪ .‬سپس مقدار هر عنصر از آرایه را با استفاده از حلقه نشان میدهیم‪ ،‬اگر‬
‫مقدار ردیف )‪(row‬برابر ‪ 1‬و مقدار ستون )‪ (col‬برابر ‪ 1‬باشد مقدار عنصری که در ستون ‪ 9‬و ردیف ‪ (numbers[0][0]) 9‬قرار‬
‫دارد نشان داده خواهد شد که در مثال باال عدد ‪ 9‬است‪.‬‬
‫ً‬
‫فورا دستورات بعد از آن اجرا خواهند شد‪ ،‬که در اینجا دستور ;‪cout << endl‬که‬ ‫بعد از اینکه دومین حلقه تکرار به پایان رسید‪،‬‬
‫به برنامه اطالع میدهد که به خط بعد برود‪ .‬سپس حلقه با اضافه کردن یک واحد به مقدار ‪ row‬این فرایند را دوباره تکرار میکند‪.‬‬
‫سپس دومین حلقه ‪ for‬اجرا شده و مقادیر دومین ردیف نمایش داده میشود‪ .‬این فرایند تا زمانی اجرا میشود که مقدار ‪row‬‬
‫کمتر از طول اولین بعد باشد‪ .‬حال بیایید آنچه را از قبل یاد گرفتهایم در یک برنامه به کار بریم‪.‬این برنامه نمره چهار درس مربوط به‬
‫سه دانش آموز را از ما میگیرد و معدل سه دانش آموز را حساب میکند‪.‬‬

‫‪2‬‬
‫‪4‬‬
‫‪5‬‬ ‫)(‪int main‬‬
‫‪6‬‬ ‫{‬
‫‪7‬‬ ‫;]‪double studentGrades[3][4‬‬
‫‪8‬‬ ‫;‪double total‬‬
‫‪9‬‬
‫‪10‬‬ ‫)‪for (int student = 0; student < size(studentGrades); student++‬‬
‫‪11‬‬ ‫{‬
‫‪12‬‬ ‫;‪total = 0‬‬

‫‪13‬‬
‫‪14‬‬ ‫;‪cout << "Enter grades for Student " << (student + 1) << endl‬‬
‫‪15‬‬
‫‪16‬‬ ‫)‪for (int grade = 0; grade < size(studentGrades[0]); grade++‬‬
‫‪17‬‬ ‫{‬
‫‪18‬‬ ‫; " ‪cout << "Enter Grade #" << (grade + 1) << " :‬‬
‫‪19‬‬ ‫;]‪cin >> studentGrades[student][grade‬‬
‫‪20‬‬ ‫;]‪total += studentGrades[student][grade‬‬
‫‪21‬‬ ‫}‬
‫‪22‬‬
‫‪23‬‬ ‫;‪cout << "Average is " << (total / size(studentGrades[0])) << endl‬‬
‫‪24‬‬ ‫;‪cout << endl‬‬
‫‪25‬‬ ‫}‬
‫‪26‬‬ ‫}‬
‫‪Enter grades for Student 1‬‬

‫‪Enter Grade #1: 92‬‬
‫‪Average is 90.75‬‬


‫در برنامه باال یک آرایه چند بعدی از نوع ‪ double‬تعریف شده است (خط ‪ .)9‬همچنین یک متغیر به نام ‪ total‬تعریف میکنیم‬
‫که جمع نمرات وارد شده برای دانش آموز در آن قرار میگیرد‪ .‬حال وارد حلقه ‪ for‬تو در تو میشویم (خط ‪ )91‬در اولین حلقه‬
‫‪ for‬یک متغیر به نام ‪ student‬تعریف کردهایم که مقادیر اولین بعد آرایه ( که همان تعداد دانش آموزان است ) در آن قرار‬
‫میگیرد‪ .‬از متد متد )(‪ size‬هم برای تشخیص تعداد دانش آموزان استفاده شده است‪ .‬وارد بدنه حلقه ‪ for‬میشویم‪.‬در خط‬
‫‪ 97‬مقدار متغیر ‪ total‬را برابر صفر قرار میدهیم‪ .‬سپس برنامه یک پیغام را نشان میدهد و از شما میخواهد که نمرات دانش‬
‫آموز را وارد کنید ‪ (student + 1).‬عدد ‪ 9‬را به ‪ student‬اضافه کردهایم تا به جای نمایش ‪ ،Student 0‬با ‪Student 1‬‬
‫شروع شود‪ ،‬تا طبیعی تر به نظر برسد ‪.‬‬

‫سپس به دومین حلقه ‪ for‬در خط ‪ 91‬میرسیم ‪ .‬وظیفه این حلقه گردش در میان دومین بعد که همان نمرات دانش آموز است‬
‫میباشد‪ .‬برنامه چهار نمره مربوط به دانش آموز را میگیرد‪ .‬هر وقت که برنامه یک نمره را از کاربر دریافت میکند‪ ،‬نمره به متغیر‬
‫‪total‬اضافه میشود‪ .‬وقتی همه نمرهها وارد شدند‪ ،‬متغیر ‪total‬هم جمع همه نمرات را نشان میدهد‪ .‬در خطوط ‪ 71-74‬معدل‬
‫(جمع) بر تعداد نمرات به دست میآید‪ .‬از‬ ‫‪total‬‬ ‫دانش آموز نشان داده میشود‪ .‬معدل از تقسیم کردن‬
‫)]‪size(studentGrades[0‬هم برای به دست آوردن تعداد نمرات استفاده میشود‪.‬‬
‫متد‬
‫متدها به شما اجازه میدهند که یک رفتار یا وظیفه را تعریف کنید و مجموعه ای از کدها هستند که در هر جای برنامه میتوان از‬
‫آنها استفاده کرد‪.‬متدها دارای آرگومانهایی هستند که وظیفه متد را مشخص میکنند ‪.‬نمیتوان یک متد را در داخل متد دیگر‬
‫تعریف کرد‪ .‬وقتی که شما در برنامه یک متد را صدا میزنید برنامه به قسمت تعریف متد رفته و کدهای آن را اجرا میکند‪ .‬در ‪C++‬‬
‫متدی وجود دارد که نقطه آغاز هر برنامه است و بدون آن برنامهها نمیدانند با ید از کجا شروع شوند‪ ،‬این متد )(‪ main‬نام دارد‪.‬‬
‫پارامترها همان چیزهایی هستند که متد منتظر دریافت آنها است‪.‬‬
‫آرگومانها مقادیری هستند که به پارامترها ارسال میشوند ‪.‬‬
‫گاهی اوقات دو کلمه پارامتر و آرگومان به یک منظور به کار میروند‪ .‬سادهترین ساختار یک متد به صورت زیر است‪:‬‬
‫)‪returnType MethodName(Parameter List‬‬

‫{‬
‫}‬
‫به برنامه ساده زیر توجه کنید‪.‬در این برنامه از یک متد برای چاپ یک پیغام در صفحه نمایش استفاده شده است‪:‬‬

‫‪3‬‬
‫‪4‬‬ ‫)(‪void PrintMessage‬‬
‫‪5‬‬ ‫{‬
‫‪7‬‬ ‫}‬
‫‪8‬‬
‫‪9‬‬ ‫)(‪int main‬‬
‫‪10‬‬ ‫{‬
‫‪11‬‬ ‫;)(‪PrintMessage‬‬
‫‪12‬‬ ‫}‬
‫در خطوط ‪ 4-9‬یک متد تعریف کردهایم ‪ .‬مکان تعریف آن در داخل کالس مهم نیست‪ .‬به عنوان مثال میتوانید آن را زیر متد‬
‫)(‪ main‬تعریف کنید‪ .‬میتوان این متد را در داخل متد دیگر صدا زد (فراخوانی کرد)‪ .‬متد دیگر ما در اینجا متد )(‪ main‬است که‬
‫میتوانیم در داخل آن نام متدی که برای چاپ یک پیغام تعریف کردهایم (یعنی متد )(‪ )PrintMessage‬را صدا بزنیم‪.‬‬
‫در تعریف متد باال کلمه کلیدی ‪ void‬آمده است که نشان د هنده آن است که متد مقدار برگشتی ندارد‪ .‬در درس آینده در مورد‬
‫مقدار برگشتی از یک متد و استفاده از آن برای اهداف مختلف توضیح داده خواهد شد‪ .‬نام متد ما )(‪ PrintMessage‬است‪.‬‬
‫به این نکته توجه کنید که در نامگذاری متد از روش پاسکال (حرف اول هر کلمه بزرگ نوشته میشود) استفاده کردهایم‪ .‬این روش‬
‫نامگذاری قراردادی است و میتوان از این روش استفاده نکرد‪ ،‬اما پیشنهاد میشود که از این روش برای تشخیص متدها استفاده‬
‫کنید‪ .‬بهتر است در نامگذاری متدها از کلماتی استفاده شود که کار متد را مشخص میکند مثالً نامهایی مانند ‪ GoToBed‬یا‬
‫‪ .OpenDoor‬همچنین به عنوان مثال اگر مقدار برگشتی متد یک مقدار بولی باشد میتوانید اسم متد خود را به صورت یک کلمه‬
‫سوالی انتخاب کنید مانند ‪ IsLeapyear‬یا …‪ IsTeenager‬ولی از گذاشتن عالمت سؤال در آخر اسم متد خودداری کنید‪ .‬دو‬
‫پرانتزی که بعد از نام میآید نشان ده نده آن است که نام متعلق به یک متد است‪ .‬در این مثال در داخل پرانتزها هیچ چیزی‬
‫میدهیم‪.‬‬ ‫توضیح‬ ‫بیشتر‬ ‫متدها‬ ‫مورد‬ ‫در‬ ‫آینده‬ ‫درسهای‬ ‫ندارد‪.‬در‬ ‫پارامتری‬ ‫چون‬ ‫نشده‬ ‫نوشته‬
‫بعد از پرانتزها دو آکوالد قرار میدهیم که بدنه متد را تشکیل میدهد و کدهایی را که میخواهیم اجرا شوند را در داخل این‬
‫آکوالدها مینویسیم‪ .‬در داخل متد )(‪ main‬متدی را که در خط ‪ 99‬ایجاد کردهایم را صدا میزنیم‪ .‬برای صدا زدن یک متد کافیست‬
‫نام آن را نوشته و بعد از نام پرانتزها را قرار دهیم‪.‬‬
‫اگر متد دارای پارامتر باشد باید شما آراگومانها را به ترتیب در داخل پرانتزها قرار دهید‪ .‬در این مورد نیز در درسهای آینده توضیح‬
‫بیشتری میدهیم‪ .‬با صدا زدن یک متد کدهای داخل بدنه آن اجرا میشوند‪ .‬برای اجرای متد )(‪ PrintMessage‬برنامه از متد‬
‫)(‪ main‬به محل تعریف متد )(‪ PrintMessage‬میرود‪ .‬مثالً وقتی ما متد )(‪ PrintMessage‬را در خط ‪ 99‬صدا میزنیم برنامه‬
‫از خط ‪ 99‬به خط ‪ ، 4‬یعنی جایی که متد تعریف شده میرود‪ .‬اکنون ما یک متد در برنامه ‪ class‬داریم و همه متدهای این برنامه‬
‫میتوانند آن را صدا بزنند‪.‬‬
‫مقدار برگشتی از یک متد‬
‫متدها میتوانند مقدار برگشتی از هر نوع داده ای داشته باشند‪ .‬این مقادیر میتوانند در محاسبات یا به دست آوردن یک داده مورد‬
‫استفاده قرار بگیرند‪ .‬در زندگی روزمره فرض کنید که کارمند شما یک متد است و شما او را صدا میزنید و از او میخواهید که کار‬
‫یک سند را به پایان برساند‪ .‬سپس از او میخواهید که بعد از اتمام کارش سند را به شما تحویل دهد ‪.‬سند همان مقدار برگشتی‬
‫متد است‪ .‬نکته مهم در مورد یک متد‪ ،‬مقدار برگشتی و نحوه استفاده شما از آن است‪ .‬برگشت یک مقدار از یک متد آسان است‪.‬‬
‫کافیست در تعریف متد به روش زیر عمل کنید‪:‬‬
‫)(‪returnType MethodName‬‬
‫{‬
‫;‪return value‬‬
‫}‬
‫‪returnType‬در اینجا نوع داده ای مقدار برگشتی را مشخص میکند (‪ .)bool،int‬در داخل بدنه متد کلمه کلیدی ‪ return‬و‬
‫بعد از آن یک مقدار یا عبارتی که نتیجه آن یک مقدار است را مینویسیم‪ .‬نوع این مقدار برگشتی باید از انواع ساده بوده و در‬
‫هنگام نامگذاری متد و قبل از نام متد ذکر شود ‪.‬اگر متد ما مقدار برگشتی نداشته باشد باید از کلمه ‪ void‬قبل از نام متد استفاده‬
‫کنیم‪ .‬مثال زیر یک متد که دارای مقدار برگشتی است را نشان میدهد‪.‬‬

‫‪3‬‬
‫‪4‬‬ ‫)(‪int CalculateSum‬‬
‫‪5‬‬ ‫{‬
‫‪6‬‬ ‫;‪int firstNumber = 10‬‬
‫‪7‬‬ ‫;‪int secondNumber = 5‬‬
‫‪8‬‬
‫‪9‬‬ ‫;‪int sum = firstNumber + secondNumber‬‬
‫‪10‬‬
‫‪11‬‬ ‫;‪return sum‬‬
‫‪12‬‬ ‫}‬
‫‪13‬‬
‫‪14‬‬ ‫)(‪int main‬‬
‫‪15‬‬ ‫{‬
‫‪16‬‬ ‫;)(‪int result = CalculateSum‬‬
‫‪17‬‬
‫‪18‬‬ ‫;‪cout << "Sum is " << result‬‬
‫‪19‬‬ ‫}‬
‫همانطور که در خط ‪ 4‬مثال فوق مشاهده میکنید هنگام تعریف متد از کلمه ‪ int‬به جای ‪ void‬استفاده کردهایم که نشان دهنده‬
‫آن است که متد ما دارای مقدار برگشتی از نوع اعداد صحیح است‪ .‬در خطوط ‪ 1‬و ‪ 9‬دو متغیر تعریف و مقدار دهی شدهاند‪.‬‬
‫توجه کنید که این متغیرها‪ ،‬متغیرهای محلی هستند‪ .‬و این بدان معنی است که این متغیرها در سایر متدها مانند متد )(‪main‬‬
‫قابل دسترسی نیستند و فقط در متدی که در آن تعریف شدهاند قابل استفاده هستند‪ .‬در خط ‪ 91‬جمع دو متغیر در متغیر ‪ sum‬قرار‬
‫میگیرد‪ .‬در خط ‪ 99‬مقدار برگشتی ‪ sum‬توسط دستور ‪ return‬فراخوانی میشود‪ .‬در داخل متد )(‪ main‬یک متغیربه نام‬
‫‪ result‬در خط ‪ 91‬تعریف میکنیم و متد )(‪ CalculateSum‬را فراخوانی میکنیم‪.‬‬

‫متد )(‪ CalculateSum‬مقدار ‪ 95‬را بر میگرداند که در داخل متغیر ‪ result‬ذخیره میشود‪ .‬در خط ‪ 98‬مقدار ذخیره شده در‬
‫متغیر ‪ result‬چاپ میشود ‪ .‬متدی که در این مثال ذکر شد متد کاربردی و مفیدی نیست‪.‬با وجودیکه کدهای زیادی در متد باال‬
‫نوشته شده ولی همیشه مقدار برگشتی ‪ 95‬است‪ ،‬در حالیکه میتوانستیم به راحتی یک متغیر تعریف کرده و مقدار ‪ 95‬را به آن‬
‫اختصاص دهیم‪ .‬این متد در صورتی کارامد است که پارامترهایی به آن اضافه شود که در درسهای آینده توضیح خواهیم داد‪.‬‬
‫هنگامی که میخواهیم در داخل یک متد از دستور ‪ if‬یا ‪switch‬استفاده کنیم باید تمام کدها دارای مقدار برگشتی باشند‪ .‬برای‬
‫درک بهتر این مطلب به مثال زیر توجه کنید‪:‬‬

‫‪3‬‬
‫‪4‬‬ ‫)(‪int GetNumber‬‬
‫‪5‬‬ ‫{‬
‫‪6‬‬ ‫;‪int number‬‬
‫‪7‬‬
‫‪8‬‬ ‫;" ‪cout << "Enter a number greater than 10:‬‬
‫‪9‬‬ ‫;‪cin >> number‬‬
‫‪10‬‬
‫‪11‬‬ ‫)‪if (number > 10‬‬
‫‪12‬‬ ‫{‬
‫‪13‬‬ ‫;‪return number‬‬
‫‪14‬‬ ‫}‬
‫‪15‬‬ ‫‪else‬‬
‫‪16‬‬ ‫{‬
‫‪17‬‬ ‫;‪return 0‬‬
‫‪18‬‬ ‫}‬
‫‪19‬‬ ‫}‬
‫‪20‬‬
‫‪21‬‬ ‫)(‪int main‬‬
‫‪22‬‬ ‫{‬
‫‪23‬‬ ‫;)(‪int result = GetNumber‬‬
‫‪24‬‬
‫‪25‬‬ ‫;‪cout << "Result is " << result‬‬
‫‪26‬‬ ‫}‬
‫‪Enter a number greater than 10: 11‬‬

‫‪Result = 11‬‬
‫‪Enter a number greater than 10: 9‬‬

‫‪Result = 0‬‬
‫در خطوط ‪ 91-4‬یک متد با نام )(‪ GetNumber‬تعریف شده است که از کاربر یک عدد بزرگتر از ‪ 91‬را میخواهد‪ .‬اگر عدد وارد شده‬
‫توسط کاربر درست نباشد متد مقدار صفر را بر میگرداند‪ .‬و اگر قسمت ‪ else‬دستور ‪ if‬و یا دستور ‪ return‬را از آن حذف‬
‫کنیم در هنگام اجرای برنامه با پیغام خطا مواجه میشویم‪.‬‬
‫چون اگر شرط دستور ‪ if‬نادرست باشد (کاربر مقداری کمتر از ‪ 91‬را وارد کند) برنامه به قسمت ‪ else‬میرود تا مقدار صفر را بر‬
‫گرداند و چون قسمت ‪ else‬حذف شده است برنامه با خطا مواجه میشود و همچنین اگر دستور ‪ return‬حذف شود چون برنامه‬
‫نیاز به مقدار برگشتی دارد پیغام خطا میدهد‪ .‬و آخرین مطلبی که در این درس میخواهیم به شما آموزش دهیم این است که شما‬
‫میتوانید از یک متد که مقدار برگشتی ندارد خارج شوید‪ .‬حتی اگر از نوع داده ای ‪ void‬در یک متد استفاده میکنید باز هم‬
‫میتوانید کلمه کلیدی ‪ return‬را در آن به کار ببرید‪ .‬استفاده از ‪ return‬باعث خروج از بدنه متد و اجرای کدهای بعد از آن‬
‫میشود‪.‬‬

‫‪3‬‬
‫‪4‬‬ ‫)(‪void TestReturnExit‬‬
‫‪5‬‬ ‫{‬
‫‪6‬‬ ‫;‪cout << "Line 1 inside the method TestReturnExit()" << endl‬‬
‫‪8‬‬
‫‪9‬‬ ‫;‪return‬‬
‫‪10‬‬
‫‪11‬‬ ‫‪//The following lines will not execute‬‬
‫‪14‬‬ ‫}‬
‫‪15‬‬
‫‪16‬‬ ‫)(‪int main‬‬
‫‪17‬‬ ‫{‬
‫‪18‬‬ ‫;)(‪TestReturnExit‬‬
‫‪19‬‬
‫‪21‬‬ ‫}‬
‫)(‪Line 1 inside the method TestReturnExit‬‬

‫)(‪Line 2 inside the method TestReturnExit‬‬
‫در برنامه باال نحوه خروج از متد با استفاده از کلمه کلیدی ‪return‬و نادیده گرفتن همه کدهای بعد از این کلمه کلیدی نشان داده‬
‫شده است‪ .‬در پایان برنامه متد تعریف شده ))(‪ (TestReturnExit‬در داخل متد )(‪ main‬فراخوانی و اجرا میشود‪.‬‬
‫پارامترها و آرگومانها‬
‫پارامترها دادههای خامی هستند که متد آنها را پردازش میکند و سپس اطالعاتی را که به دنبال آن هستید در اختیار شما قرار‬
‫میدهد ‪ .‬فرض کنید پارامترها مانند اطالعاتی هستند که شما به یک کارمند میدهید که بر طبق آنها کارش را به پایان برساند‪.‬‬
‫یک متد میتواند هر تعداد پارامتر داشته باشد‪ .‬هر پارامتر میتواند از انواع مختلف داده باشد‪ .‬در زیر یک متد با ‪ N‬پارامتر نشان‬
‫داده شده است‪:‬‬
‫)‪returnType MethodName(datatype param1, datatype param2, ... datatype paramN‬‬

‫{‬
‫}‬
‫پارامترها بعد از نام متد و بین پرانتزها قرار میگیرند‪ .‬بر اساس کاری که متد انجام میدهد میتوان تعداد پارامترهای زیادی به متد‬
‫اضافه کرد‪ .‬بعد از فراخوانی یک متد باید آرگومانهای آن را نیز تأمین کنید‪ .‬آرگومانها مقادیری هستند که به پارامترها اختصاص‬
‫داده میشوند‪ .‬ترتیب ارسال آرگومانها به پارامترها مهم است‪ .‬عدم رعایت ترتیب در ارسال آرگومانها باعث به وجود آمدن خطای‬
‫منطقی و خطای زمان اجرا میشود‪ .‬اجازه بدهید که یک مثال بزنیم‪:‬‬

‫‪2‬‬
‫‪4‬‬
‫‪5‬‬ ‫)‪int CalculateSum(int number1, int number2‬‬
‫‪6‬‬ ‫{‬
‫‪7‬‬ ‫;‪return number1 + number2‬‬
‫‪8‬‬ ‫}‬
‫‪9‬‬
‫‪10‬‬ ‫)(‪int main‬‬
‫‪11‬‬ ‫{‬
‫‪12‬‬ ‫;‪int num1, num2‬‬
‫‪13‬‬
‫‪14‬‬ ‫;" ‪cout << "Enter the first number:‬‬
‫‪15‬‬ ‫;‪cin >> num1‬‬
‫‪16‬‬ ‫;" ‪cout << "Enter the second number:‬‬
‫‪17‬‬ ‫;‪cin >> num2‬‬
‫‪18‬‬
‫‪19‬‬ ‫;)‪cout << "Sum = " << CalculateSum(num1, num2‬‬
‫‪20‬‬ ‫}‬
‫‪Enter the first number: 10‬‬

‫‪Enter the second number: 5‬‬
‫‪Sum = 15‬‬
‫در برنامه باال یک متد به نام )(‪( CalculateSum‬خطوط ‪ )5-8‬تعریف شده است که وظیفه آن جمع مقدار دو عدد است‪ .‬چون‬
‫این متد مقدار دو عدد صحیح را با هم جمع میکند پس نوع برگشتی ما نیز باید ‪ int‬باشد‪ .‬متد دارای دو پارامتر است که اعداد‬
‫را به آنها ارسال میکنیم‪ .‬به نوع داده ای پارامترها توجه کنید ‪.‬هر دو پارامتر یعنی ‪ number1‬و ‪ number2‬مقادیری از نوع‬
‫اعداد صحیح )‪ (int‬دریافت میکنند‪ .‬در بدنه متد دستور ‪ return‬نتیجه جمع دو عدد را بر میگرداند‪ .‬در داخل متد ‪Main‬‬
‫برنامه از کاربر دو مقدار را درخواست میکند و آنها را داخل متغیرها قرار میدهد‪ .‬حال متد را که آرگومانهای آن را آماده کردهایم‬
‫فراخوانی میکنیم‪ .‬مقدار ‪ num1‬به پارامتر اول و مقدار ‪ num2‬به پارامتر دوم ارسال میشود ‪ .‬حال اگر مکان دو مقدار را هنگام‬
‫ارسال به متد تغییر دهیم (یعنی مقدار ‪ num2‬به پارامتر اول و مقدار ‪ num1‬به پارامتر دوم ارسال شود) هیچ تغییری در نتیجه متد‬
‫ندارد چون جمع خاصیت جابه جایی دارد‪.‬‬

‫ً‬
‫دقیقا با ترتیب قرار گیری پارامترها تعریف شده در‬ ‫فقط به یاد داشته باشید که باید ترتیب ارسال آرگومانها هنگام فراخوانی متد‬
‫متد مطابقت داشته باشد‪ .‬بعد از ارسال مقادیر ‪ 91‬و ‪ 5‬به پارامترها ‪ ،‬پارامترها آنها را دریافت میکنند‪ .‬به این نکته نیز توجه کنید‬
‫که نام پارامترها طبق قرارداد به شیوه کوهان شتری یا ‪( camelCasing‬حرف اول دومین کلمه بزرگ نوشته میشود) نوشته‬
‫میشود‪ .‬در داخل بدنه متد (خط ‪ )9‬دو مقدار با هم جمع میشوند و نتیجه به متد فراخوان (متدی که متد )(‪CalculateSum‬‬
‫را فراخوانی میکند) ارسال میشود‪ .‬در درس آینده از یک متغیر برای ذخیره نتیجه محاسبات استفاده میکنیم ولی در اینجا مشاهده‬
‫میکنید که میتوان به سادگی نتیجه جمع را نشان داد (خط ‪ .)9‬در داخل متد )(‪ main‬از ما دو عدد که قرار است با هم جمع‬
‫شوند درخواست میشود‪.‬‬
‫در خط ‪ 91‬متد )(‪ CalculateSum‬را فراخوانی میکنیم و دو مقدار صحیح به آن ارسال میکنیم‪ .‬دو عدد صحیح در داخل متد با‬
‫هم جمع شده و نتیجه آنها برگردانده میشود‪ .‬مقدار برگشت داده شده از متد به وسیله متد ‪ cout‬نمایش داده میشود (خط‬
‫‪ .) 91‬در برنامه زیر یک متد تعریف شده است که دارای دو پارامتر از دو نوع داده ای مختلف است‪:‬‬

‫‪4‬‬
‫‪5‬‬ ‫)‪void ShowMessageAndNumber(string message, int number‬‬
‫‪6‬‬ ‫{‬
‫‪7‬‬ ‫;‪cout << message << endl‬‬
‫‪8‬‬ ‫;‪cout << "Number = " << number‬‬
‫‪9‬‬ ‫}‬
‫‪10‬‬
‫‪11‬‬ ‫)(‪int main‬‬
‫‪12‬‬ ‫{‬
‫‪13‬‬ ‫;)‪ShowMessageAndNumber("Hello World!", 100‬‬
‫‪14‬‬ ‫}‬
‫‪Number = 100‬‬
‫در مثال باال یک متدی تعریف شده است که اولین پارامتر آن مقداری از نوع رشته و دومین پارامتر آن مقداری از نوع ‪ int‬دریافت‬
‫میکند‪ .‬متد به سادگی دو مقداری که به آن ارسال شده است را نشان میدهد‪ .‬در خط ‪ 91‬متد را اول با یک رشته و سپس یک عدد‬
‫خاص فراخوانی میکنیم ‪ .‬حال اگر متد به صورت زیر فراخوانی میشد‪:‬‬
‫;)"!‪ShowMessageAndNumber(100, "Welcome to Gimme C++‬‬
‫در برنامه خطا به وجود میآمد چون عدد ‪ 911‬به پارامتری از نوع رشته و رشته !‪ Hello World‬به پارامتری از نوع اعداد صحیح‬
‫ارسال میشد‪.‬این نشان میدهد که ترتیب ارسال آرگومانها به پارامترها هنگام فراخوانی متد مهم است‪ .‬به مثال ‪ 9‬توجه کنید در‬
‫آن مثال دو عدد از نوع ‪ int‬به پارامترها ارسال کردیم که ترتیب ارسال آنها چون هردو پارامتر از یک نوع بودند مهم نبود‪ .‬ولی‬
‫اگر پارامترهای متد دارای اهداف خاصی باشند ترتیب ارسال آرگومانها مهم است‪.‬‬
‫)‪void ShowPersonStats(int age, int height‬‬

‫{‬
‫;‪cout << "Age = " << age‬‬
‫;‪cout << "Height = " << height‬‬
‫}‬
‫‪//Using the proper order of arguments‬‬

‫;)‪ShowPersonStats(20, 160‬‬
‫‪//Acceptable, but produces odd results‬‬

‫;)‪ShowPersonStats(160, 20‬‬
‫در مثال باال نشان داده شده است که حتی اگر متد دو آرگومان با یک نوع داده ای قبول کند باز هم بهتر است ترتیب بر اساس‬
‫تعریف پارامترها رعایت شود‪ .‬به عنوان مثال در اولین فراخوانی متد باال اشکالی به چشم نمیآید چون سن شخص ‪ 71‬و قد او ‪911‬‬
‫سانتی متر است‪ .‬اگر آرگومانها را به ترتیب ارسال نکنیم سن شخص ‪ 911‬و قد او ‪ 71‬سانتی متر میشود که به واقعیت نزدیک‬
‫نیست‪ .‬دانستن مبانی مقادیر برگشتی و ارسال آرگومانها باعث میشود که شما متدهای کارامد تری تعریف کنید‪ .‬تکه کد زیر‬
‫نشان میدهد که شما حتی میتوانید مقدار برگشتی از یک متد را به عنوان آرگومان به متد دیگر ارسال کنید‪.‬‬
‫)(‪int MyMethod‬‬
‫{‬
‫;‪return 5‬‬
‫}‬
‫)‪void AnotherMethod(int number‬‬

‫{‬
‫;‪cout << number‬‬
‫}‬
‫‪// Codes skipped for demonstration‬‬
‫;))(‪AnotherMethod(MyMethod‬‬
‫چون مقدار برگشتی متد )(‪ MyMethod‬عدد ‪ 5‬است و به عنوان آرگومان به متد )(‪ AnotherMethod‬ارسال میشود خروجی‬
‫کد باال هم عدد ‪ 5‬است‪.‬‬
‫ارسال آرگومانها به روش ارجاع‬
‫آرگومانها را میتوان به کمک ارجاع ارسال کرد‪ .‬این بدان معناست که شما آدرس متغیری را ارسال میکنید نه مقدار آن را‪ .‬ارسال‬
‫با ارجاع زمانی مفید است که شما بخو اهید یک آرگومان که دارای مقدار بزرگی است ( مانند یک آبجکت) را ارسال کنید‪ .‬در این‬
‫ در زیر‬.‫حالت وقتی که آرگومان ارسال شده را در داخل متد اصالح میکنیم مقدار اصلی آرگومان در خارج از متد هم تغییر میکند‬
‫ برای ارسال یک‬.‫دستورالعمل پایه ای تعریف پارامترها که در آنها به جای مقدا ر از آدرس استفاده شده است نشان داده شده است‬
:‫متغیر با ارجاع کافیست که قبل از نام پارامتر یک عالمت &قرار دهید‬
returnType MethodName(datatype &param1)

{
code to execute;
}
:‫اجازه دهید که تفاوت بین ارسال با ارجاع و ارسال با مقدار آرگومان را با یک مثال توضیح دهیم‬
1 #include <iostream>
2 using namespace std;
3
4 void ModifyNumberVal(int number)
5 {
6 number += 10;
7 cout << "Value of number inside method is " << number << endl;
8 }
9
10 void ModifyNumberRef(int &number)
11 {
12 number += 10;
13 cout << "Value of number inside method is " << number << endl;
14 }
15
16 int main()
17 {
18 int num = 5;
19
20 cout << "num = " << num << endl;
21
22 cout << "Passing num by value to method ModifyNumberVal() ..." << endl;
23 ModifyNumberVal(num);
24 cout << "Value of num after exiting the method is " << num << endl;
25
26 cout << "Passing num by ref to method ModifyNumberRef() ..." << endl;
27 ModifyNumberRef(num);
28 cout << "Value of num after exiting the method is " << num << endl;
29 }
num = 5
Passing num by value to method ModifyNumberVal() ...
Value of number inside method is 15
Value of num after exiting the method is 5
Passing num by ref to method ModifyNumberRef() ...
Value of number inside method is 15
Value of num after exiting the method is 15
‫ به مقداری است که به آنها‬91 ‫در برنامه باال دو متد که دارای یک هدف یکسان هستند تعریف شدهاند و آن اضافه کردن عدد‬
‫ وقتی که متد را‬.‫) دارد‬int ‫ ) دارای یک پارامتر است که نیاز به یک مقدار آرگومان (از نوع‬5-1 ‫ اولین متد (خطوط‬.‫ارسال میشود‬
‫صدا میزنیم و آرگومانی به آن اختصاص میدهیم (خط ‪،)74‬کپی آرگومان به پارامتر متد ارسال میشود‪ .‬بنابراین مقدار اصلی متغیر‬
‫خارج از متد هیچ ارتباطی به پارامتر متد ندارد‪ .‬سپس مقدار ‪ 91‬را به متغیر پارامتر )‪(number‬اضافه کرده و نتیجه را چاپ میکنیم‪.‬‬
‫برای اثبات اینکه متغیر ‪ num‬هیچ تغییری نکرده است مقدار آن را یکبار دیگر چاپ کرده و مشاهده میکنیم که تغییری نکرده است‪.‬‬
‫دومین متد (خطوط ‪ )99-95‬نیاز به یک مقدار با ارجاع دارد‪ .‬در این حالت به جای اینکه یک کپی از مقدار به عنوان آرگومان به ان‬
‫ارسال شود آدرس متغیر به آن ارسال میشود ‪ .‬حال پارامتر به مقدار اصلی متغیر که زمان فراخوانی متد به آن ارسال میشود‬
‫دسترسی دارد‪ .‬وقتی که ما مقدار متغیر پارامتری که شامل آدرس متغیر اصلی است را تغییر میدهیم (خط ‪ )91‬در واقع مقدار متغیر‬
‫اصلی در خارج از متد را تغییر دادهایم ‪ .‬در نهایت مقدار اصلی متغیر را وقتی که از متد خارج شدیم را نمایش میدهیم و مشاهده‬
‫ً‬
‫واقعا تغییر کرده است‪.‬‬ ‫میشود که مقدار آن‬
‫ارسال آرایه به عنوان آرگومان‬
‫میتوان آرایهها را به عنوان آرگومان به متد ارسال کرد ‪.‬ابتدا شما باید پارامترهای متد را طوری تعریف کنید که آرایه دریافت‬
‫کنند ‪.‬به مثال زیر توجه کنید‪.‬‬

‫‪3‬‬
‫‪4‬‬ ‫)][‪void TestArray(int numbers‬‬
‫‪5‬‬ ‫{‬
‫‪6‬‬ ‫)‪for (int i = 0; i <= sizeof(numbers) ; i++‬‬
‫‪7‬‬ ‫{‬
‫‪8‬‬ ‫;‪cout << numbers[i] << endl‬‬
‫‪9‬‬ ‫}‬
‫‪10‬‬ ‫}‬
‫‪11‬‬
‫‪12‬‬ ‫)(‪int main‬‬
‫‪13‬‬ ‫{‬
‫‪14‬‬ ‫;} ‪int array[] = { 1, 2, 3, 4, 5‬‬
‫‪15‬‬
‫‪16‬‬ ‫;)‪TestArray(array‬‬
‫‪17‬‬ ‫}‬
‫‪1‬‬
‫‪2‬‬
‫‪3‬‬
‫‪4‬‬
‫‪5‬‬
‫مشاهده کردید که به سادگی میتوان با گذاشتن کروشه بعد از نام پارامتر یک متد ایجاد کرد که پارامتر آن‪ ،‬آرایه دریافت میکند‪.‬‬
‫وقتی متد در خط ‪ 91‬فراخوانی میشود‪ ،‬آرایه را فقط با استفاده از نام آن و بدون استفاده از اندیس ارسال میکنیم‪ .‬پس آرایهها هم‬
‫به روش ارجاع به متدها ارسال میشوند‪ .‬در خطوط ‪ 1-1‬از حلقه ‪ for‬برای دسترسی به اجزای اصلی آرایه که به عوان آرگومان به‬
‫متد ارسال کردهایم استفاده میکنیم‪ .‬در زیر نحوه ارسال یک آرایه به روش ارجاع نشان داده شده است‪.‬‬

‫‪3‬‬
‫‪4‬‬ ‫)][‪void IncrementElements(int numbers‬‬
‫‪5‬‬ ‫{‬
‫‪6‬‬ ‫)‪for (int i = 0; i <= sizeof(numbers); i++‬‬
‫‪7‬‬ ‫{‬
‫‪8‬‬ ‫;‪numbers[i]++‬‬
‫‪9‬‬ ‫}‬
‫‪10‬‬ ‫}‬
‫‪11‬‬
‫‪12‬‬ ‫)(‪int main‬‬
‫‪13‬‬ ‫{‬
‫‪14‬‬ ‫;} ‪int array[] = { 1, 2, 3, 4, 5‬‬
‫‪15‬‬
‫‪16‬‬ ‫;)‪IncrementElements(array‬‬
‫‪17‬‬
‫‪18‬‬ ‫)‪for (int i = 0; i < size(array); i++‬‬
‫‪19‬‬ ‫{‬
‫‪20‬‬ ‫;‪cout << array[i] << endl‬‬
‫‪21‬‬ ‫}‬
‫‪22‬‬ ‫}‬
‫‪2‬‬
‫‪3‬‬
‫‪4‬‬
‫‪5‬‬
‫‪6‬‬
‫برنامه باال یک متد را نشان میدهد که یک آرایه را دریافت میکند و به هر یک از عناصر آن یک واحد اضافه میکند‪ .‬در داخل متد‬
‫ما مقادیر هر یک از اجزای آرایه را افزایش دادهایم‪ .‬سپس از متد خارج شده و نتیجه را نشان میدهیم‪ .‬مشاهده میکنید که هر‬
‫یک از مقادیر اصلی متد هم اصالح شدهاند‪ .‬میتوان دو یا چ ند آرایه را به عنوان آرگومان به متد ارسال کرد‪:‬‬
‫)][‪void MyMethod(int param1[], int param2‬‬

‫{‬
‫‪//code here‬‬
‫}‬
‫محدوده متغیر‬
‫متغیرها در ‪ C++‬دارای محدوده هستند‪ .‬محدوده یک متغیر به شما میگوید که در کجای برنامه میتوان از متغیر استفاده کرد و‬
‫یا متغیر قابل د سترسی است‪ .‬به عنوان مثال متغیری که در داخل یک متد تعریف میشود فقط در داخل بدنه متد قابل دسترسی‬
‫است‪ .‬میتوان دو متغیر با نام یکسان در دو متد مختلف تعریف کرد‪ .‬برنامه زیر این ادعا را اثبات میکند‪:‬‬
‫)(‪void DemonstrateScope‬‬
‫{‬
‫= )(‪cout << "number inside method DemonstrateScope‬‬ ‫;‪" << number << endl‬‬
‫}‬
‫{‬
‫;)(‪DemonstrateScope‬‬
‫;‪cout << "number inside the Main method = " << number << endl‬‬
‫}‬
‫‪number inside method DemonstrateScope() = 5‬‬

‫‪number inside the Main method = 10‬‬
‫مشاهده میکنید که حتی اگر ما دو متغیر با نام یکسان تعریف کنیم که دارای محدودههای متفاوتی هستند‪ ،‬میتوان به هر کدام‬
‫از آنها مقادیر مختلفی اختصاص داد‪ .‬متغیر تعریف شده در داخل متد )(‪ main‬هیچ ارتباطی به متغیر داخل متد‬
‫)(‪ DemonstrateScope‬ندارد‪ .‬وقتی به مبحث کالسها رسیدیم در این باره بیشتر توضیح خواهیم داد‪.‬‬
‫پارامترهای اختیاری‬
‫پارامترهای اختیاری همانگونه که از اسمشان پیداست اختیاری هستند و میتوان به آنها آرگومان ارسال کرد یا نه‪ .‬این پارامترها‬
‫دارا ی مقادیر پیشفرضی هستند‪.‬اگر به اینگونه پارامترها آرگومانی ارسال نشود از مقادیر پیشفرض استفاده میکنند‪ .‬به مثال زیر‬
‫توجه کنید‪:‬‬

‫‪4‬‬
‫‪5‬‬ ‫)"!‪void PrintMessage(string message = "Welcome to Visual C# Tutorials‬‬

‫‪6‬‬ ‫{‬
‫‪7‬‬ ‫;‪cout << message << endl‬‬
‫‪8‬‬ ‫}‬
‫‪9‬‬
‫‪10‬‬ ‫)(‪int main‬‬
‫‪11‬‬ ‫{‬
‫‪12‬‬ ‫;)(‪PrintMessage‬‬
‫‪13‬‬
‫‪14‬‬ ‫;)"!‪PrintMessage("Learn C# Today‬‬
‫‪15‬‬ ‫}‬
‫!‪Welcome to Visual C# Tutorials‬‬

‫!‪Learn C# Today‬‬
‫متد( )(‪ PrintMessage‬خطوط ‪ )5-8‬یک پارامتر اختیاری دارد‪ .‬برای تعریف یک پارامتر اختیاری میتوان به آسانی و با استفاده‬
‫از عالمت = یک مقدار را به یک پارامتر اختصاص داد (مثال باال خط ‪ .)5‬دو بار متد را فراخوانی میکنیم ‪.‬در اولین فراخوانی (خط‬
‫‪ )97‬ما آرگومانی به متد ارسال نمیکنیم بنابراین متد از مقدار پیشفرض )!‪ (Welcome to Visual C# Tutorials‬استفاده‬
‫میکند‪ .‬در دومین فراخوانی(خط ‪ )94‬یک پیغام (آرگومان) به متد ارسال میکنیم که جایگزین مقدار پیشفرض پارامتر میشود‪ .‬ا گر‬
‫از چندین پارامتر در متد استفاده میکنید همه پارامترهای اختیاری باید در آخر بقیه پارامترها ذکر شوند‪ .‬به مثالهای زیر توجه‬
‫کنید‪.‬‬
‫‪void SomeMethod(int opt1 = 10, int opt2 = 20, int req1, int req2) //ERROR‬‬
‫‪void SomeMethod(int req1, int opt1 = 10, int req2, int opt2 = 20) //ERROR‬‬
‫‪void SomeMethod(int req1, int req2, int opt1 = 10, int opt2 = 20) //Correct‬‬
‫وقتی متدهای با چندین پارامتر اختیاری فراخوانی میشوند باید به پارامترهایی که از لحاظ مکانی در آخر بقیه پارامترها نیستند‬
‫مقدار اختصاص داد‪ .‬به یاد داشته باشید که نمیتوان برای نادیده گرفتن یک پارامتر به صورت زیر عمل کرد‪:‬‬
‫)‪void SomeMethod(int required1, int optional1 = 10, int optional2 = 20‬‬

‫{‬
‫‪//Some Code‬‬
‫}‬
‫‪// ... Code omitted for demonstration‬‬
‫‪SomeMethod(10, , 100); //Error‬‬

‫سربارگذاری متدها‬
‫سربارگذاری متدها )‪ (Method Overloading‬به شما اجازه میدهد که دو متد با نام یکسان تعریف کنید که دارای امضا و تعداد‬
‫پارامترهای مختلف هستند‪.‬برنامه از روی آرگومانهایی که شما به متد ارسال میکنید به صورت خودکار تشخیص میدهد که کدام‬
‫متد را فراخوانی کردهاید یا کدام متد مد نظر شماست‪ .‬امضای یک متد نشان دهنده ترتیب و نوع پارامترهای آن است‪ .‬به مثال‬
‫زیر توجه کنید‪:‬‬
‫)‪void MyMethod(int x, double y, string z‬‬
‫که امضای متد باال‬
‫)‪MyMethod(int, double, string‬‬
‫به این نکته توجه کنید که نوع برگشتی و نام پارامترها شامل امضای متد نمیشوند‪ .‬در مثال زیر نمونه ای از سربارگذاری متدها‬
‫آمده است‪.‬‬

‫‪3‬‬
‫‪4‬‬ ‫)‪void ShowMessage(double number‬‬
‫‪5‬‬ ‫{‬
‫‪6‬‬ ‫;‪cout << "Double version of the method was called." << endl‬‬
‫‪7‬‬ ‫}‬
‫‪8‬‬
‫‪9‬‬ ‫)‪void ShowMessage(int number‬‬
‫‪10‬‬ ‫{‬
‫‪11‬‬ ‫;‪cout << "Integer version of the method was called." << endl‬‬
‫‪12‬‬ ‫}‬
‫‪13‬‬
‫‪14‬‬ ‫)(‪int main‬‬
‫‪15‬‬ ‫{‬
‫‪16‬‬ ‫;)‪ShowMessage(9.99‬‬
‫‪17‬‬ ‫;)‪ShowMessage(9‬‬
‫‪18‬‬ ‫}‬
‫‪Double version of the method was called.‬‬

‫‪Integer version of the method was called.‬‬
‫در برنامه باال دو متد با نام مشابه تعریف شدهاند‪ .‬اگر سربارگذاری متد توسط ‪ C++‬پشتیبانی نمیشد برنامه زمان زیادی برای‬
‫انتخاب یک متد از بین متدهایی که فراخوانی میشوند الزم داشت‪ .‬رازی در نوع پارامترهای متد نهفته است‪ .‬کامپایلر بین دو یا‬
‫چند متد همنام در صورتی فرق میگذارد که پارامترهای متفاوتی داشته باشند‪ .‬وقتی یک متد را فراخوانی میکنیم ‪ ،‬متد نوع‬
‫آرگومانها را تشخیص میدهد‪.‬‬

‫در فراخوانی اول (خط ‪ )91‬ما یک مقدار ‪ double‬را به متد )(‪ ShowMessage‬ارسال کردهایم در نتیجه متد )(‪ShowMessage‬‬
‫(خطوط ‪ )4-9‬که دارای پارامتری از نوع ‪double‬اجرا میشود‪ .‬در بار دوم که متد فراخوانی میشود (خط ‪ )99‬ما یک مقدار ‪int‬‬
‫را به متد )(‪ ShowMessage‬ارسال میکنیم متد )(‪( ShowMessage‬خطوط ‪ )1-97‬که دارای پارامتری از نوع ‪ int‬است اجرا‬
‫میشود ‪ .‬معنای اصلی سربارگذاری متد همین است که توضیح داده شد‪ .‬هدف اصلی از سربارگذاری متدها این است که بتوان‬
‫چندین متد که وظیفه یکسانی انجام میدهند را تعریف کرد‪.‬‬
‫بازگشت )‪(Recursion‬‬
‫بازگشت)‪ ، (Recursion‬فرایندی است که در آن متد مدام خود را فراخوانی میکند تا زمانی که به یک مقدار مورد نظر برسد‪.‬‬
‫بازگشت یک مبحث پیچیده در برنامه نویسی است و تسلط به آن کار را حتی نیست‪ .‬به این نکته هم توجه کنید که بازگشت باید‬
‫در یک نقطه متوقف شود وگرنه برای بی نهایت بار‪ ،‬متد‪ ،‬خود را فراخوانی میکند‪ .‬در این درس یک مثال ساده از بازگشت را برای‬
‫شما توضیح میدهیم‪ .‬فاکتوریل یک عدد صحیح مثبت )!‪ (n‬شامل حاصل ضرب همه اعداد مثبت صحیح کوچکتر یا مساوی‬
‫آن میباشد‪ .‬به فاکتوریل عدد ‪ 5‬توجه کنید‪.‬‬
‫‪5! = 5 * 4 * 3 * 2 * 1 = 120‬‬
‫بنا براین برای ساخت یک متد بازگشتی باید به فکر توقف آن هم باشیم‪ .‬بر اساس توضیح بازگشت ‪ ،‬فاکتوریل فقط برای اعداد مثبت‬
‫صحیح است‪ .‬کوچکترین عدد صحیح مثبت ‪ 9‬است‪ .‬در نتیجه از این مقدار برای متوقف کردن بازگشت استفاده میکنیم‪.‬‬
‫)‪long Factorial(int number‬‬

‫{‬
‫)‪if (number == 1‬‬
‫;‪return 1‬‬
‫;)‪return number * Factorial(number - 1‬‬

‫}‬
‫{‬
‫;)‪cout << Factorial(5‬‬
‫}‬
‫‪120‬‬
‫متد مقدار بزرگی را بر میگرداند چون محاسبه فاکتوریل میتواند خیلی بزرگ باشد‪ .‬متد یک آرگومان که یک عدد است و میتواند‬
‫در محاسبه مورد استفاده قرار گیرد را میپذیرد‪ .‬در داخل متد یک دستور ‪ if‬مینویسیم و در خط ‪7‬می گوییم که اگر آرگومان‬
‫ارسال شده برابر ‪ 9‬باشد سپس مقدار ‪ 9‬را برگردان در غیر اینصورت به خط بعد برو‪ .‬این شرط باعث توقف تکرارها نیز میشود‪.‬‬
‫در خط ‪ 1‬مقدار جاری متغیر ‪ number‬در عددی یک واحد کمتر از خودش )‪ (number – 1‬ضرب میشود‪.‬در این خط متد‬
‫‪Factorial‬خود را فراخوانی میکند و آرگومان آن در این خط همان ‪ number – 1‬است‪ .‬مثالً اگر مقدار جاری ‪number 10‬‬
‫باشد یعنی اگر ما بخواهیم فاکتوریل عدد ‪ 91‬را به دست بیاوریم آرگومان متد ‪Factorial‬در اولین ضرب ‪ 1‬خواهد بود‪ .‬فرایند‬
‫ضرب تا زمانی ادامه مییابد که آرگومان ارسال شده با عدد ‪ 9‬برابر نشود‪ .‬شکل زیر فاکتوریل عدد ‪ 5‬را نشان میدهد‪.‬‬
‫کد باال را به وسیله یک حلقه ‪ for‬نیز میتوان نوشت ‪.‬‬
‫;‪factorial = 1‬‬
‫)‪for(int counter = number; counter >= 1; counter--‬‬

‫;‪factorial *= counter‬‬
‫این کد از کد معادل بازگشتی آن آسان تر است‪ .‬از بازگشت در زمینههای خاصی در علوم کامپیوتر استفاده میشود‪ .‬استفاده از‬
‫بازگشت حافظه زیادی اشغال میکند پس اگر سرعت برای شما مهم است از آن استفاده نکنید‪.‬‬
‫برای مشاهده سایر مطالب به سایت زیر مراجعه فرمایید ‪:‬‬
‫‪www.w3-farsi.com‬‬

CPP Book Sade

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

CPP Book Sade

Uploaded by

Copyright:

Available Formats

‫‪www.SourceSara.

‫منبع کتاب ‪w3-farsi.com :‬‬

‫مؤلف ‪ :‬یونس ابراهیمی‬

‫به زبان ساده‬

‫‪w3-farsi.com‬منبع کتاب ‪ :‬سایت‬

‫مؤلف ‪ :‬یونس ابراهیمی‬

‫راههای ارتباط با نویسنده‬

‫سایت ‪w3-farsi.com :‬‬

‫جیمیل ‪younes.ebrahimi.1391@gmail.com :‬‬

‫نصب و پیکربندی‪9................................................................................................................................. MinGW‬‬

‫ساخت یک برنامه ساده ‪61 ....................................................................................................................................‬‬

‫انواع ساده ‪02 ....................................................................................................................................................‬‬

‫استفاده از متغیرها ‪01 ..........................................................................................................................................‬‬

‫ثابت ‪22 ...........................................................................................................................................................‬‬

‫عبارات و عملگرها ‪26 ................................................................................................................................................‬‬

‫عملگرهای تخصیصی ‪23 ......................................................................................................................................‬‬

‫عملگرهای مقایسه ای ‪21 .....................................................................................................................................‬‬

‫عملگرهای منطقی ‪28 ..........................................................................................................................................‬‬

‫تقدم عملگرها ‪23 ................................................................................................................................................‬‬

‫گرفتن ورودی از کاربر ‪24 ............................................................................................................................................‬‬

‫ساختارهای تصمیم ‪28 ..............................................................................................................................................‬‬

‫دستور‪29 ....................................................................................................................................................... if‬‬

‫دستور‪32 ............................................................................................................................................. if…else‬‬

‫عملگر شرطی ‪32 .................................................................................................................................................‬‬

‫دستور ‪ if‬چندگانه ‪33............................................................................................................................................‬‬

‫دستور ‪ if‬تو در تو ‪34 ...........................................................................................................................................‬‬

‫استفاده از عملگرهای منطقی ‪39 ..............................................................................................................................‬‬

‫دستور‪16 .............................................................................................................................................. Switch‬‬

‫تکرار ‪13 ...............................................................................................................................................................‬‬

‫حلقه‪11 ................................................................................................................................................. While‬‬

‫حلقه‪19 ...................................................................................................................................................... for‬‬

‫حلقههای تو در تو)‪42 .................................................................................................................. (Nested Loops‬‬

‫خارج شدن از حلقه با استفاده از ‪ break‬و‪40 ................................................................................................ continue‬‬

‫آرایهها ‪42 ............................................................................................................................................................‬‬

‫آرایههای چند بعدی ‪41.........................................................................................................................................‬‬

‫مقدار برگشتی از یک متد ‪80 ...................................................................................................................................‬‬

‫پارامترها و آرگومانها ‪83 .....................................................................................................................................‬‬

‫ارسال آرگومانها به روش ارجاع ‪88 .........................................................................................................................‬‬

‫ارسال آرایه به عنوان آرگومان ‪92...............................................................................................................................‬‬

‫محدوده متغیر ‪90 ...............................................................................................................................................‬‬

‫پارامترهای اختیار ی ‪90 .........................................................................................................................................‬‬

‫سربارگذار ی متدها ‪92 ...........................................................................................................................................‬‬

‫بازگشت)‪93 ................................................................................................................................... (Recursion‬‬

‫)‪626 .............................................................................................................................................. (Enumeration‬‬

‫پیش پردازنده ها ‪626 ................................................................................................................................................‬‬

‫اشاره گرها ‪622 .......................................................................................................................................................‬‬

‫ساختارها ‪622 .........................................................................................................................................................‬‬

‫برنامه نویسی شیء گرا ‪623 ........................................................................................................................................‬‬

‫‪ w3-farsi.com‬تخصصی ترین سایت آموزش سی شارپ‬ ‫‪4‬‬

‫) ‪621 ................................................................................................................. (Object Oriented Programming‬‬

‫کالس ‪621 .............................................................................................................................................................‬‬

‫سازنده ها)‪628 ................................................................................................................................ (Constructors‬‬

‫مخرب ها)‪666 ................................................................................................................................... (Destructors‬‬

‫فیلدهای فقط – خواندنی ‪662......................................................................................................................................‬‬

‫سطح دسترسی ‪661 .................................................................................................................................................‬‬

‫کپسوله کردن ‪668 ....................................................................................................................................................‬‬

‫)‪602 ........................................................................................................................................... (Encapsulation‬‬

‫خواص)‪600 ....................................................................................................................................... (Properties‬‬

‫فضای نام ‪602 ........................................................................................................................................................‬‬

‫سطح دسترسی ‪626 .................................................................................................................................................‬‬

‫اعضای‪623 ................................................................................................................................................. Static‬‬

‫کالس‪624 .................................................................................................................................................. Static‬‬

‫سربارگذار ی عملگرها ‪629 ..........................................................................................................................................‬‬