انواع داده ها در C++ :
در C++ شش نوع داده وجود دارد. منظور از داده، متغیری است که در قالب متن یا عدد در طول برنامه مورد استفاده قرار می گیرد.
داده های موجود در C++ عبارتند از :
char, int, float, double, void, bool ,string
نوع char برای ذخیره داده های کاراکتری مانند : ‘a’ , ‘z’ , ‘W’ بکار می رود.
از نوع int برای ذخیره اعداد صحیح مانند 128، 5، 4508 استفاده می شود.
نوع float برای ذخیره اعداد اعشاری مثل 12.5، 7805.11 بکار می رود.
نوع double برای اعداد اعشاری بزرگتر از float استفاده می شود.
از boolean برای ذخیره مقادیر منطقی استفاده می شود ( درستی یا نادرستی ).
نوع void هیچ مقداری را نمی گیرد
نوع دیگری از داده وجود دارد که برای استفاده از رشته ها مورد استفاده قرار میگیرد که string گفته میشود اما در برخی از نسخه های کامپایلر زبان برنامه نویسی C++ پشتیبانی نمی شود، لذا مجبور به استفاده از آرایه ای از کاراکترها برای این منظور خواهیم بود .
متغیرها
در طول برنامه نویسی، کاربران با متون و اعداد زیادی کار می کنند، به همین دلیل آنها را در متغیرها ذخیره می کنند. در واقع متغیر ها نامهایی برای کلمات ذخیره شده در حافظه سیستم هستند.
برای استفاده از یک متغیر ابتدا باید آن را در برنامه تعریف نماییم که روش تعریف متغیر بصورت زیر است :
;نام متغیر نوع متغیر
int count ;
در قطعه کد بالا می بینیم که هر متغیر باید دارای نام منحصر بفردی باشد که برای نامگذاری متغیر ها باید توجه داشته باشیم که :
• برای نامگذاری متغیرها از ترکیبی از حروف a تا z یا A تا Z ، ارقام و خط ربط ( _ ) استفاده می شود.
• اولین کاراکتر نام نباید از ارقام باشد.
• نام می تواند هر طولی داشته باشد اما فقط 31 کاراکتر ابتدایی استفاده می شوند.
اسامی غیر مجاز اسامی مجاز

---

count3 3count
count .count
co_unt co.unt
مقدار دادن به متغیر ها
بعد از تعریف یک متغیر باید مقداری را به آن نسبت دهیم که به یکی از چهار روش زیر می توان اینکار را انجام داد :
• هنگام تعریف متغیر
int x = 4; // initial value = 4
char char1 = 'a' , char2 = char3 = 'y'; // initial values = 'a' and 'y'
bool b = true; // initial value = true
• بعد از تعریف و با عمل انتساب ( = ).
int y;
y = 12; // initial value = 12
• با استفاده از قالب سازنده.
float float_1 (2); // initial value = 2
• دستورات ورودی که در فصل مربوط به ورودی / خروجی گفته خواهد شد.
float a, b;
cin >> a >> b;
ثوابت و عملگرها در C++ - (Constants)
ثوابت مقادیری در برنامه هستند که مقدارشون در طول برنامه قابل تغییر نیست و اگر که بخوایم مقدار ثوابت رو تغییر بدیم با خطایی از طرف کامپایلر مواجه می شیم.
برای تعریف ثوابت در c++ دو الگو وجود دارد :
• 1. با استفاده از دستور #define
#define <name> <value>

// For example :
#include <iostream>
#define P 3.14
int main()
{
cout >> P;
return 0 ;
}
3.14
به محل استفاده از این دستور دقت کنید که در کجای برنامه مورد استفاده قرار گرفته است (بعد از فایلهای سرآیند) .
نکته ای که باید در اینجا توجه نمود و در مثال بالا هم مشخص بود این است که در پایان دستور #define از ; (سمی کالن) استفاده نمی کنیم.
• 2. با استفاده از کلمه کلیدی const :
const <مقدار> = <نام ثابت> <نوع داده>;

// For example :
#include <iostream>
int main()
{
const float P = 3.14 ;
cout >> P;
return 0 ;
}
3.14
می بینیم که محل این دستور درون خود تابع main هست اما دستور #define در بیرون از تابع main و در بالای برنامه.
عملگر ها (Operators)
برای انجام عملیات بر روی داده ها از عملگرها استفاده می کنیم. عملگرها نمادهایی هستند که عملیاتی مانند جمع،ضرب، کوچکتری و از این قبیل را روی داده ها انجام می دهند که عبارتند از :
• انتساب ( Assignment ) ( = )
از این عملگر برای نسبت دادن یک مقدار به یک داده استفاده می شود .
#include <iostream>
int main()
{
int a, b ; // a:?, b:?
a = 10 ; // a:10, b:?
b = 4 ; // a:10, b:4
a = b ; // a:4, b:4
b = 7 ; // a:4, b:7
cout >> "a:" ;
cout >> a ;
cout>> "b:" ;
cout >> b ;
return 0 ;
}
a:4 b:7
نحوه عملکرد این عملگرد به این شکله که مقدار سمت راست تساوی را در سمت چپ قرار میدهد.
• عملگرهای محاسباتی ( Arithmetic Operators ) ( + , - , * , / , % )
پنج عملگر محاسباتی موجود در C++ عبارتند از :
+ جمع
- تفریق
* ضرب
/ تقسیم
% باقیمانده تقسیم
با 4 عملگرد اول آشنا هستید اما آخرین که خوانده می شود ( مـد "با واو تلفظ کنید" ) عملوند سمت چپ را بر عملوند سمت راست تقسیم کرده و باقیمانده آنرا بدست می آورد .
#include <iostream>
int main()
{
int a = 11;
int b = 3;
int c = a % b;
cout >> "c:" ;
cout >> c ;
return 0 ;
}
c: 2
• عملگرهای ترکیبی ( Compund Operators ) ( =+ , =- , =* , =/ )
عبارت برابر است با
a += b a=a+b
a -= b a=a-b
a *= b+1 a=a*(b+1)
a /= b a=a/b
در واقع جواب این نوع از عملگرها برابر حاصل عمل عملگر، بر خود عبارت سمت چپ و عبارت سمت راست تساوی است . علت اینگونه نوشتار هم مختصرنویسی است.
عملگرهای ترکیبی دیگری نیز وجود دارند که در ادامه در موردشان بحث می کنیم مثل : => و =<
#include <iostream>
int main()
{
int a ,b = 3; // a=?, b=3
a = b; // a=3, b=3
a += 2; // a=a+2=3+2=5
cout >> a;
return 0 ;
}
5
• عملگرهای افزایش کاهش ( Increase , Decrease ) ( ++ , -- )
این عملگرها یک واحد به عملوند خود اضافه می کنند و عمل اونها به اینکه در سمت چپ یا راست عملوند خود قرار بگیرند متفاوت است .
#include <iostream>
int main()
{
int a = 2, b = 3; // a=2, b=3
a += b++; // a+=(b+1) ---> a=a+(b+1) ---> a=2+4=6
cout >> "a:";
cout >> a;
return 0;
}
a:6
اگر عملگر سمت راست یا چپ عملوند خود باشه در هر دو صورت یک واحد به عملوند اضافه می شود . اما تفاوت این دوحالت در عبارات محاسباتی خود را نشان می دهد . عبارات محاسباتی ترکیبی از متغیرها، ثوابت و عملگرها هستند مثل 4*5-5/10 و 6-x/y
int A , B = 3; // A=?, B=3
A = ++B; // A=(++ ---> A=(B+1) , B=B+1 ---> A=4, B=4

A=4 ,B=4
در مثال بالا چون افزایش قبل B قرار دارد ابتدا یک واحد به B اضافه شده، پس در همینجا B می شود 4 و در پایان مقدار فوق در A قرار می گیرد .
int A , B = 3; // A=?, B=3
A = B++; // A=(B++) ---> A=B, B=B+1 ---> A=3, B=4

A=3 ,B=4
اما در مثال بالا چون افزایش بعد از B قرار دارد اول مقدار B که 3 هست در A ریخته میشود و بعد یک واحد به B اضافه میشود .
• عملگرهای رابطه ای و تساوی (Relational and equality operators) ( = = , =! , > , < , =< , => )
از این نوع عملگرها برای مقایسه دو عبارت استفاده میشود که کاربرد اونها بیشتر در عبارات شرطی است که بعدا در موردشون بحث می کنیم . فعلا اینو بدونید که این عملگرها در صورت درست بودن مقایسه، مقدار درستی و در غیر این صورت مقدار نادرستی را برمی گردانند .
int a = 10 , b = 7; //a=10, b=7
(a == b) ; //a=10 and not equal to b so return false
(a >= b) ; //a=10 greater than b so return false
(a > b) ; //a=10 greater than b so return true
عملگرهای دیگه ای هم وجود دارند که در آینده و با برخورد به اونها در موردشون صحبت می کنیم تا مبحث کسل کننده و طولانی نشود .
Basic input/output - I/O - دستورات ورودی خروجی در برنامه نویسی C++
هدف از ساخت کامپیوتر و ایجاد برنامه نویسی دادن اطلاعات به ماشین و دریافت جواب بوده که به این روال، جریان ورودی خروجی گفته میشود . برای استفاده از این جریانات ما حداقل به 2 فایل کتابخانه ای در C++ نیاز داریم و دستوراتی برای استفاده از این کتابخانه ها که با ارائه یک مثال، استفاده از این دستورات را نشان می دهم .

1
2
3
4
5
6
7
8
9
10
11 #include <iostream.h>
#include <conio.h>
int main()
{
int a; //a=?
cin >> a; //a=value of user input
cout << "a:"; //Prints a: on screen
cout << a; //Prints value of a
getch();
return 0;
}
a:120
برای استفاده از کلمات کلیدی cin و cout لازمه که از کتابخانه iostream.h در برنامه خود استفاده کنیم.
دستور cout باعث چاپ اطلاعات در مانیتور می شود به این صورت که اگر بعد از این دستور، عبارت مورد نظر رو تو " " قرار بدیم عینا همون عبارت تو مانیتور نشان داده می شود و معمولا جایی که کاربر قصد نشان دادن عین یک عبارت را در خروجی دارد مورد استفاده قرار می کیرد و اگه بخواهیم مقدار یک متغیر یا ثابتی را نمایش بدهیم باید نام را نوشته و از " " استفاده نکنیم .
دستور cin باعث می شود که از کاربر یا برنامه دیگه ای یک مقدار یا متنی را بگیریم . در واقع کامپایلر با رسیدن به این دستور منتظر ورود اطلاعات از طرف کاربر شده تا زمانی که کاربر Enter را فشار بده و مقدار ورودی کاربر را در متغیری که در جلوش اعلان شده بریزه و همونطور که قبلا اشاره شد موجب مقدار دهی به متغیر مربوطه میشود .
در برنامه بالا تابعی بنام getch() هست که برای استفاده از اون باید از کتابخانه conio.h استفاده کنیم که باعث میشود بعد از اجرای برنامه و رسیدن کامپایلر به این خط، برنامه متوقف شده و منتظر این باشه که کاربر یک کلید از کیبورد را فشار دهد . با این دستور می توانیم خروجی برنامه را ببینیم چون اگر این تابع نباشد در کسری از ثانیه برنامه اجرا و بلافاصله بسته میشود و دیگر ما قادر به دیدن خروجی نخواهیم بود . ( امتحان کنید! )
در مثال بالا فرض بر اینه که کاربر مقدار 120 را وارد کرده است.
گاهی اوقات لازمه که ما چند مقدار را با استفاده از دستور cin به برنامه بدهیم، در اینصورت به ازاء هر مقدار از یک << استفاده می کنیم و همینطور برای دستور cout ازیک >> .
int a, b; //a=?, b=?
cin >> a >> b;
cout << a << b;
همونطور که در برنامه های قبلی دیدیم با نوشتن چند دستور چاپ، تمامی اطلاعات در یک خط نوشته شد . در خروجی برای اینکه از خط کنونی به خط بعدی برویم به یکی از صورتهای زیر عمل می کنیم :
cout << a << endl;
عبارت endl به کامپایلر پایان خط جاری را نشان می دهد و در صورت وجود خروجی دیگه ای در برنامه، نمایش خروجی را از خط بعدی ادامه میدهد .
cout << a << "\n";
عبارت \n نیز مثل endl خروجی را به خط بعدی هدایت می کند .

1
2
3
4
5
6
7
8
9
10
11
12
13 #include <iostream.h>
#include <conio.h>
int main()
{
int a, b; //a=?,b=?
cout << "Please inter value of a:";
cin >> a; //a=value of user input
cout << "Please inter value of b:";
cin >> b; //b=value of user input
cout << "a:" << a << "\n"; //Prints a:(value of a) on screen and go to next line
cout << "b:" << b; //Prints b:(value of a) on screen
return 0;
}
Please inter value of a:
Please inter value of b:
a:120
b:87
باید بگم فرض بر این است که مقادیر 120 و 87 توسط کاربر وارد شده است . نکته ای که اینجا قابل توجه است اینه که دستور cin خودش باعث میشود که کامپایلر با گرفتن مقدار بطور خودکار به خط بعدی برود و دیگه اینجا نیازی به قید \n یا endl نیست .
عبارات محاسباتی و تقدم عملگرها در برنامه نویسی C++ (Precedence of operators) :
همانطور که قبلا اشاره شد عبارات محاسباتی شامل عملیات یک یا چند عملگر بر روی یک یا چند عملوند هستند. لذا به مبحث تقدم عملگرها در برنامه نویسی C++ می پردازیم تا بدانیم که در برخورد با یک عبارت محاسباتی طولانی به چه صورت باید رفتار کنیم.
a = b+10*(9%4);
a = b+10*9%4;
در بالا دو عبارت محاسباتی شبیه به هم اما با ساختاری متفاوت را مشاهده می کنیم. این دو عبارت جوابی متفاوت نسبت به یکدیگر دارند و تنها دلیل این تفاوت وجود یا عدم وجود پرانتز در هر کدام از این دو می باشد.
بطور کلی در عبارات محاسباتی قوانینی وجود دارد که اولویت عملگری را بر سایر عملگرها مشخص می کند. یعنی در برخورد با یک عبارت محاسباتی، عملگرهای با تقدم بالاتر، زودتر محاسبه شده تا به آخرین عملگر در عبارت برسیم.
جدول زیر تقدم عملگرها را با اولویت از بالا به پایین به ما نمایش میدهد.
1 ()
2 ! ~ ++ -- sizeof
3 * / %
4 + -
5 << >>
6 < <= > >=
7 == !=
8 &
9 ^
10 |
11 &&
12 ||
13 ?
14 = += -= *= /= %=
15 ,
همینطور که در جدول بالا مشخص شد بالاترین تقدم عملگرها را پرانتز و پایین ترین تقدم را کاما دارا می باشند.
در جدول بالا ردیف هایی با چند عملگر وجود دارند. این بدین معنی است که از تقدم یکسانی برابر هستند، بنابر این اگر در عبارات محاسباتی به چند عملگر با تقدم یکسان برخورد کردیم تقدم بالاتر به عملگری میرسد که در سمت چپ دیگر عملگرها قرار دارد.
برای درک مطلب به بررسی مثالی می پردازیم :
a = 20-3*4+19%(3*(2+1));
20-3*4+19%(3*3)
ابتدا عبارت داخل پرانتز به دلیل بالاترین تقدم بررسی می شود. اینجا ما دو پرانتز تودرتو داریم پس از پرانتز داخلی شروع می کنیم.
20-3*4+19%9
با محاسبه مقدار اولین پرانتز، دوباره عبارت داخل آنرا بدلیل وجود پرانتز دوم و تقدم آن نسبت به دیگر عملگرها محاسبه می کنیم.
20-12+19%9
حالا از بین عملگرهای موجود * و % از تقدم بالاتری برخوردارند. بدلیل یکسان بودن تقدم این دو از چپ شروع کرده و با رسیدن به هر کدام از این دو عملگر مقدار عبارت را محاسبه میکنیم که در این مثال ابتدا * محاسبه می شود.
20-12+1
سپس نوبت به % میرسد.
8+1
اکنون عملگرهای + و – در عبارت باقی می مانند که بدلیل یکسانی تقدم اولین عملگر از چپ یعنی – ابتدا محاسبه می گردد.
9
و در پایان عملگر + محاسبه شده که در نهایت به جواب 9 می رسیم.
ساختارهای کنترلی در برنامه نویسی C++ (Control Structures)
بطور کلی، در هر برنامه نویسی اجرای دستورات از اولین سطر شروع شده و به ترتیب تا آخرین سطر ادامه میابد.
اما گاهی وقتها لازم است که یک دستور چندین بار تکرار شود و یا اینکه تحت شرایط خاصی اجرا گردد و یا از اجرای آن جلوگیری شود.
ساختارهای کنترلی به برنامه نویس این اجازه را می دهند که بر روی دستورات کنترل داشته باشد و آنها را تکرار، اجرا و متوقف سازد. در این فصل به بررسی این ساختارها می پردازیم که به دو دسته تقسیم می شوند :
• ساختارهای کنترل
• ساختارهای تصمیم
ساختارهای کنترل :
• for
• while
در برنامه نویسی C++ از ساختار حلقه for برای تکرار یک سری از دستورات استفاده می شود و شکل کلی ایجاد حلقه تکرار بصورت زیر است :
for( مقدار اولیه حلقه ; شرط حلقه ; گام حرکت )
{
Line Command 1;
Line Command 2;
Line Command n;
}

مثال) با استفاده از حلقه تکرار for کدی بنویسید که اعداد 1 تا 10 را چاپ کند.

1
2
3
4 for ( int i = 1; i <= 10; i++ )
{
cout << i << " ";
}
1 2 3 4 5 6 7 8 9 10
در کد بالا متغیر i از نوع int تعریف شده و شرط خاتمه حلقه for تا زمانی است که i کوچکتر یا مساوی 10 باشد. گام حرکت حلقه یک است و با هر بار تکرار حلقه یک واحد به متغیر اضافه خواهد شد. متغیر i در پایان حلقه و با خروج از آن یک واحد اضافه خواهد شد. زمانیکه i برابر با 11 می شود برنامه با رسیدن به شرط حلقه و عدم برقرار بودن شرط، از حلقه خارج می شود. برای چاپ اعداد باید در درون خود حلقه، دستور خروجی را نوشت.
در برنامه نویسی، برای تست دستورات روشی به نام Trace وجود دارد که در این مورد از دستورات بسیار مفید است:
عملیات i<=10 i
چاپ 1 yes 1
چاپ 2 yes 2
چاپ 3 yes 3
چاپ 4 yes 4
چاپ 5 yes 5
چاپ 6 yes 6
چاپ 7 yes 7
چاپ 8 yes 8
چاپ 9 yes 9
چاپ 10 yes 10
خروج از حلقه no 11
شما با ترسیم چنین جدولی بر روی کاغذ و ردگیری گام به گام حلقه قادر به نوشتن حلقه های پیچیده تر در C++ خواهید بود، با کمی تمرین به راحتی به این مهم خواهید رسید.
مثال) با استفاده از حلقه تکرار for کدی بنویسید که در آن کاربر جمله ای را وارد کرده و در انتهای جمله Enter را فشار دهد و برنامه تعداد حروف جمله را نمایش دهد:

1
2
3
4
5 int count;
cout << "Enter a statement with enter in end:" << endl;
for ( count = 0; cin.get()!='\r' ; count++ );
cout << "Lenght of statement is: " << count;
getch();
Enter a statement with enter in end:
I like C++ programming!
Lenght of statement is: 23
در برنامه بالا چند نکته مهم وجود دارد که به بررسی آنها می پردازیم:
الف) به شرط حلقه توجه کنید. تابع cin.get() برای تشخیص ورود Enter بکار می رود. تابع دانه دانه حروف ورودی را بررسی می کند و به محض Enter کردن کاربر از حلقه خارج می شود.
شرط حلقه به این معنی است که : تا زمانیکه حرف وارد شده کاربر مخالف Enter (\r) است حلقه را ادامه بده و به count هر بار یک واحد اضافه کن.
ب) برای حلقه هیچ بلوکی از دستورات وجود ندارد و در انتهای آن هم از سمی کالن استفاده کردیم. در واقع با اینکار ما فقط خواستیم که تعداد حروف جمله را شمارش کنیم.
حلقه های تودرتو
گاهی اوقات لازم است که در یک حلقه، یک یا چند حلقه دیگر هم استفاده نمود.
معروفترین مثال برنامه نویسی در مورد حلقه های تودرتو، نمایش جدول ضرب اعداد است:

1
2
3
4
5
6
7
8 int i,j;

for ( i = 0; i<=10 ; i++ )
{
for ( j = 0; j<=10 ; j++ )
cout << i*j << "\t";
cout << endl;
}
1 2 3 4 5 6 7 8 9 10
2 4 6 8 10 12 14 16 18 20
3 6 9 12 15 18 21 24 27 30
4 8 12 16 20 24 28 32 36 40
5 10 15 20 25 30 35 40 45 50
6 12 18 24 30 36 42 48 54 60
7 14 21 28 35 42 49 56 63 70
8 16 24 32 40 48 56 64 72 80
9 18 27 36 45 54 63 72 81 90
10 20 30 40 50 60 70 80 90 100
در ابتدا، برنامه وارد حلقه اول شده و شرط را بررسی می کند و با درستی آن به اجرای دستورات حلقه می پردازد. اینجا برای حلقه آکولاد وجود دارد پس تمامی دستورات درون بلوک به ترتیب اجرا می شوند.
سطر بعدی هم یک حلقه است یعنی حلقه جاری به ازای تعداد تکرار حلقه اول باید تکرار شود و در هر تکرار از حلقه بالا به تعداد تکرار خود نیز تکرار می شود، شرط آن بررسی شده و با درستی شرط به انجام دستورات حلقه می پردازد. به دلیل عدم وجود آکولاد برای این حلقه، تنها سطر بعدی دستور حلقه داخلی است و تا نقیض شدن شرط حلقه آن سطر اجرا می شود. در این مثال 10 بار حلقه درونی تکرار می شود و با هر بار تکرار فاصله ای بعد از نمایش عدد مورد نظر هم قرار می دهد.
سپس برنامه با اجرای دستور بعدی به خط جدید می رود. از حلقه اول 9 بار تکرار دیگر مانده، پس این رویه تکرار شده تا برنامه کامل گردد. در آخر وقتی i برابر با 11 می شود از حلقه بیرونی خارج شده و برنامه به پایان می رسد.
مثال مهم) قصد داریم با استفاده از حلقه های تکرار تودرتو شکل زیر را ایجاد نماییم :
*****
****
***
**
*
روش کلی کار به این صورت است که به ازای تعداد سطرها به یک حلقه تکرار for بیرونی و به ازای تعداد ستونها به یک حلقه for درونی نیاز داریم. چون از ابتدا به انتها از تعداد ستاره ها کم می شود پس باید حلقه های خود را کاهشی بنویسیم :

1
2
3
4
5
6 for ( int i = 5; i>0 ; i-- )
{
for ( int j = i; j>0 ; j-- )
cout << "*";
cout << "\n";
}
با شروع حلقه for اول، برنامه وارد بلوکی می شود که دارای حلقه for دیگری است و دو دستور cout، که اولین دستور مربوط به حلقه درونی است و دومی مربوط به حلقه بیرونی.
متغیر i از 5 شروع شده با هر بار اجرای حلقه یک واحد کاهش میابد. به این دلیل متغیر j را برابر با متغیر i گرفته ایم چون با کاهش i آنهم باید کاهش یابد یعنی در هر بار چرخش حلقه بیرونی (هر سطر ).
در ابتدا i برابر با 5 است و شرط حلقه هم درست است پس وارد دستورات حلقه for بیرونی می شود و به حلقه for درونی برخورد می کند که j برابر با i یعنی 5 است و شرطش هم درست است پس 5 بار ستاره چاپ می کند و با نقیض شدن شرط حلقه (وقتی که j برابر صفر می شود ) از حلقه درونی خارج می شود و ادامه دستورات حلقه for بیرونی را انجام میدهد یعنی یک سطر پایین می رود .
این بار یک واحد از i کم شده و برابر با 4 می شود که باز هم شرط حلقه بیرونی درست است و دستورات آنرا دوباره اجرا می کند. در درون حلقه for درونی j برابر با i یعنی 4 شده و شرطش هم درست است پس اینبار چهار ستاره چاپ می کند و به همان ترتیب قبل دستورات ادامه میابد تا شکل بالا حاصل می شود .
مثال) می خواهیم شکل زیر را با استفاده از دستور حلقه تکرار for تودرتو در برنامه نویسی C++ رسم نماییم :
*
***
*****
*******
*********
***********
*************
***********
*********
*******
*****
***
*
برای رسم این شکل ما ابتدا شکل را به 2 قسمت تقسیم کرده و برای رسم هر قسمت از دستور حلقه تکرار for تودرتو استفاده می کنیم :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33 for ( int i = 6; i>0 ; i-- )
{
for ( int j = i; j>0 ; j-- )
cout << " ";

for ( j = i; j<6 ; j++ )
cout << "*";

for ( j = i; j<=6 ; j++ )
cout << "*";

for ( int j = i; j>0 ; j-- )
cout << " ";

cout << "\n";
}

for ( i = 6; i>=0 ; i-- )
{
for ( j = i; j<6 ; j++ )
cout << " ";

for ( j = i; j>0 ; j-- )
cout << "*";

for ( j = i; j>=0 ; j-- )
cout << "*";

for ( int j = i; j<6 ; j-- )
cout << " ";

cout << "\n";
}
عزیزان اگر کمی دقت کنید و با حوصله کد بالا را بررسی نمایید حتما مطلب را یاد گرفته و با کمی تمرین براحتی می توانند در C++ دستورات حلقه تکرار for تو در توی پیچیده را براحتی حل نمایید .
ساختارهای کنترلی - حلقه while - بخش دوم
در این فصل از آموزش برنامه نویسی C++ قصد داریم به بررسی ساختار حلقه while() بپردازیم که وظیفه ای شبیه به حلقه for() را برعهده دارد.
while ( عبارت شرطی )
{
Line Command 1;
Line Command 2;
Line Command n;
}
از این ساختار برای ایجاد حلقه های تکرار استفاده می شود و تا زمانیکه عبارت شرطی داخل پرانتز while() درست باشد دستورات مربوطه اجرا خواهند شد و به محض نادرستی شرط، کنترل دستورات از حلقه خارج خواهد شد.

1
2
3
4
5
6
7
8
9
10
11 int n;

cout << "Enter the starting number that bigger than zero : " ;
cin >> n ;

while ( n > 0 )
{
cout << n << ", " ;
}

cout << "Fire! \n" ;
Enter the starting number that bigger than zero : 8
8, 7, 6, 5, 4, 3, 2, 1, Fire!
کد برنامه نویسی بالا، عددی را از کاربر گرفته و با استفاده از حلقه while شمارش معکوس آنرا در خروجی نمایش می دهد.
در برنامه C++ بالا، اگر عدد صفر یا کمتر از آنرا وارد کنیم شرط حلقه while نادرست بوده و دستورات درون حلقه اجرا نخواهد شد و فقط عبارت Fire! چاپ می شود.
شکل دیگری از این دستور وجود دارد که شبیه به while() بوده و به آن حلقه do while گفته می شود، با این تفاوت که اگر شرط درون آن نادرست باشد دستورات درون حلقه حداقل یکبار اجرا می شوند و اگر شرط درست باشد، حلقه تا زمان نادرستی شرط ادامه خواهد یافت و ساختار آن بدینگونه است :
do
{
Line Command 1;
Line Command 2;
Line Command n;
}
while ( عبارت شرطی )
{
Line Command 1;
Line Command 2;
Line Command n;
}
در ساختار do while() ابتدا دستورات do اجرا شده و بعد شرط درون while() بررسی می شود و در صورت درستی شرط، اجرای دستورات do ادامه پیدا خواهد کرد.
نکته ) دوستان توجه داشته باشند که اگر دستورات مربوط به for, while, do, … فقط یک دستور باشد نیازی به قرار دادن دستور درون آکولاد نیست و تکرار فقط بر روی تنها سطر دستور ادامه خواهد داشت و تا زمانیکه شرط برقرار باشد فقط و فقط آن سطر تکرار و اجرا می شود و تا زمان پایان به خط بعدی نخواهد رفت اما اگر دستورات بیش از یکی باشد لازم است که آنها را در آکولاد قرار دهیم و این قانون کلی در برنامه نویسی است.

1
2
3
4
5
6
7
8 int n;

do
{
cout << "Enter number (0 to end): " ;
cin >> n ;
cout << "You entered: " << n << "\n" ;
} while ( n != 0 )
Enter number (0 to end): 1298
You entered: 1298
Enter number (0 to end): 35
You entered: 35
Enter number (0 to end): 0
You entered: 0
اگر عدد ورودی در کد بالا در ابتدا صفر باشد دستورات یکبار اجرا می شود.
ساختارهای تصمیم در برنامه نویسی C++
در برنامه هرگاه بخواهیم در شرایط ویژه ای برخی از دستورات اجرا شوند و برخی دیگر اجرا نشوند از ساختارهای تصمیم استفاده می کنیم.
• ساختار if :
با استفاده از ساختار if، شرطی را کنترل می کنیم. اگر شرط جلوی if درست باشد دستورات آن اجرا خواهد شد، در غیر اینصورت دستورات درون else اجرا خواهند شد .
توجه کنید که فقط و فقط یا دستورات if اجرا می شود و یا دستورات else و هرگز این دو با هم اجرا نمی شوند.
if ( عبارت شرطی )
{
Line Command 1;
Line Command 2;
Line Command n;
}
در ادامه به بررسی حالات مختلفی در بکارگیری دستور if در C++ می پردازیم :

1
2
3
4 int num = 5;

if ( num == 10 )
cout << "num is equal 10" ;
در کد برنامه نویسی بالا می بینیم که num برابر 5 است، بنابراین شرط if نادرست است و دستور مربوط به آن چاپ نمی شود.

1
2
3
4
5
6
7 int num = 10;

if ( num == 10 )
{
cout << "num is :" ;
cout << num ;
}
num is :10

در کد برنامه نویسی بالا چون دستورات مربوط به if از یک سطر بیشتر است آنها را در بلوک آکولاد قرار دادیم. می بینیم که این بار مقدار num برابر با شرط است، در نتیجه دستورات مربوط به if اجرا می شوند.
نکته مهم اینجاست که برای بررسی تساوی از == استفاده کردیم و دلیل آن این است که این عملگر یک عملگر رابطه ای است و در بررسی شروط باید از عملگرهای رابطه ای استفاده کنیم .

1
2
3
4
5
6
7
8
9
10
11
12 int num = 5;

if ( num == 10 )
{
cout << "num is :" ;
cout << num ;
}
else
{
cout << "num is not 10 % is :" ;
cout << num ;
}
num is not 10 and is :5
در کد برنامه نویسی بالا چون num برابر با 10 نیست پس دستورات درون else اجرا می شود .

مطالب قبلی دربرگیرنده 2 حالت از بررسی شرط if بودند، اما گاهی اوقات لازم است که ما حالات بیشتری را بررسی نماییم که در اینصورت از else if بهره می گیریم .

1
2
3
4
5
6 if ( num > 0 )
cout << "num is positive ";
else if ( num < 0)
cout << "num is negative ";
else
cout << "num is 0 ";

• ساختار switch :
از این ساختار زمانی استفاده می شود که تعداد حالات تصمیم گیری زیاد باشد و همان عملکرد else if را دارد با این تفاوت که کار با آن راحتتر است، به ساختار زیر توجه کنید :
switch ( عبارت شرطی )
{
case مقدار 1 :
command block 1;
break;

case مقدار 2 :
command block 2;
break;
.
.
.
default
command block n

}
به بررسی مثالی در C++ می پردازیم :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15 int x = 2 ;

switch ( x )
{
case 1:
cout << X is : "One" ;
break;

case 2:
cout << X is : "Two" ;
break;

default :
cout << X is : "is not One or Two" ;
}
X is : Two
در کد برنامه نویسی بالا متغیر x از نوع عدد صحیح تعریف شده است و مقدار اولیه 2 گرفته است. می خواهیم اگر 1 یا 2 باشد مقدار حروفی عدد را در خروجی نمایش دهیم و در غیر اینصورت خروجی نشان دهد که x نه 1 است نه 2 .
برای این منظور متغیر x را در جلوی switch میاوریم تا به برنامه بگوییم که قصد بررسی x را داریم، سپس در مقابل هر case مقادیر مورد انتظار خود را می نویسیم. در نهایت متغیر در یکی از case ها قرار می گیرد و دستورات مربوط به آن اجرا می شود و با رسیدن به عبارت break برنامه از switch خارج می شود .
عبارت default مواردی که خارج از موارد مورد انتظار ماست را در بر می گیرد و همان کار else در if را انجام خواهد داد .

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30 int garde = 15 ;

switch ( grade )
{
case 20:
case 19:
cout << "A" ;
break;

case 18:
case 17:
cout << "B" ;
break;

case 16:
case 15:
case 14:
cout << "C" ;
break;

case 13:
case 12:
case 11:
case 10:
cout << "D" ;
break;

default :
cout << "Reprobate " ;
}
C
کد برنامه نویسی بالا معدل دانش آموزی را گرفته و با توجه به معدل به او رتبه می دهد. توجه کنید که بعضی از case های موجود خالی از دستورند و علت آن اینست که دستورات برای تمامی آنها مشترک است، مثلا اگر معدل 20 یا 19 باشد رتبه دانش آموزش A خواهد بود و به همین ترتیب تا آخر .
با توجه به اینکه معدل دانش آموز در این مثال 15 است پس به او رتبه C نسبت داده شده و در خروجی چاپ می شود .
• عملگر ؟
در برنامه نویسی C++ ساختار تصمیم دیگری وجود دارد که به صورت زیر نوشته می شود :
variable = ( condition ) ? true : false;

1
2 int X = 10;
int Y = (X < 9) ? 100 : 200;
منظور از دستور بالا اینست که اگر X کوچکتر از 9 است Y را برابر با 100 بگیر، در غیر اینصورت آنرا برابر 200 قرار بده. در واقع ساختار تصمیم عملگر ؟ برابر با ساختار تصمیم if else است .

1
2
3
4
5
6 int X = 10;

if (X < 9)
int Y = 100;
else
Y = 200;
پس اگر عبارت قبل از ؟ درست باشد، دستور بعد از آن فقط اجرا شده و اگر شرط نادرست باشد عبارت بعد از : اجرا می شود .
Function | توابع در C++
در این فصل ما به بحث در مورد یکی از مفاهیم مهم و اساسی در برنامه نویسی به نام توابع می پردازیم. در واقع در فصول قبل، ما مقداری از الزامات و مقدمات برنامه نویسی را یاد گرفتیم و تا کنون برنامه خاصی ننوشتیم .
وقتی خطوط برنامه ما زیاد می شود درک، پیگیری، خطایابی و دیگر اعمال بر روی برنامه دشوار خواهد شد. توابع ابزاری هستند که به ما در بهبود برنامه کمک می کنند و برنامه نویسی ساخت یافته را ارائه می دهند، بدین معنا که برنامه اصلی به قسمتهای منطقی و مستقل کوچکتری تقسیم می شود که توابع نام دارند .
برای بکارگیری توابع به سه جزء نیازمندیم: تعریف تابع، اعلان تابع، فراخوانی تابع
• تعریف تابع :

برای استفاده از یک تابع در برنامه نویسی در مرحله اول باید تابع خود را تعریف نماییم تا مشخص کنیم که چه کاری را باید انجام دهد. در شکل بالا ساختار اصلی تعریف یک تابع در برنامه نویسی C++ را مشاهده می کنید . تعریف تابع در خارج از تابع main صورت می گیرد و هیچ تابعی را نمی توان در درون تابع دیگری تعریف نمود .
یک تابع وظیفه ای شبیه به یک ماشین دارد که یک سری ورودی را می گیرد و با انجام عملیات برروی ورودیهای دریافتی، خروجی یا خروجی هایی را تحویل می دهد .
در اولین قدم باید مشخص کنیم که این تابع چه خروجی را به ما می دهد ( در اصطلاح برنامه نویسی بر می گرداند ) و فقط به ذکر نوع خروجی بسنده می کنیم، یعنی اگر عدد صحیح برگرداند از int ، اگر کاراکتر برگرداند از char و به همین ترتیب برای دیگر انواع و اگر هیچ مقداری را برنگرداند از void استفاده می کنیم .
یک تابع باید دارای یک نام باشد تا در طول برنامه مورد استفاده قرار گیرد. هر نامی را می توان برای توابع انتخاب نمود که از قانون نامگذاری متغیرها تبعیت می کند، اما سعی کنید که از نامهایی مرتبط با عمل تابع استفاده نمایید .
همینطور باید ورودیهای تابع را نیز مشخص کنیم که در اصطلاح برنامه نویسی به این ورودیها، پارامترهای تابع گفته می شود. اگر تابع بیش از یک پارامتر داشته باشد باید آنها را با استفاده از کاما از یکدیگر جدا نماییم و اگر تابع پارامتری نداشت از کلمه void استفاده می کنیم. بخاطر داشته باشید که قبل از نام هر پارامتر باید نوع آنرا مشخص نماییم و بدانیم که کامپایلر هیچ متغیری بدون نوع را قبول نکرده و در صورت برخورد با این مورد از برنامه خطا می گیرد و در نتیجه برنامه را اجرا نخواهد کرد .
و در نهایت دستورات تابع را در بلوکی از آکولاد قرار می دهیم که به این دستورات بدنه تابع گفته می شود و در واقع عملکرد تابع را تعریف می کند .
void sample ( int x, int y )
{
.
.
.
}
• اعلان یا الگوی تابع :
در برنامه نویسی برای اینکه به کامپایلر وجود تابع یا توابعی را اطلاع دهیم باید آنرا اعلان کنیم که اینکار را قبل از تابع main و بعد از فایلهای سرآیند برنامه انجام خواهیم داد .
#include <iostream.h>
#include <conio.h>

void sample ( int a, int b );

int main()
{
.
.
.
}
در اعلان (الگو) توابع باید نوع برگشتی، تمامی پارامترها بهمراه نوعشان و نام تابع را بیان نماییم. نام، نوع برگشتی و نوع پارامترها باید کاملا مطابق با موارد متناظر در تعریف تابع باشند، اما لازم نیست که نام پارامترها شبیه به نامهای تعریف تابع باشد .
• فراخوانی تابع :
در نهایت باید در درون برنامه خود، تابع را صدا بزنیم که به اینکار فراخوانی توابع گفته می شود .
int main()
{
sample (a, b);
}
در فراخوانی توابع باید نام تابع و نام پارامترها را بیان کنیم که در اینجا به نام پارامترها، آرگومانهای تابع گفته می شود و دیگر نباید نوع آرگومانها را ذکر کنیم. در مورد نوع برگشتی تابع دو حالت وجو دارد. اول اینکه اگر بدون نوع برگشتی باشد لازم نیست از void استفاده کنیم و دوم اینکه اگر تابع دارای نوع برگشتی باشد باید آنرا برابر با مقدار متغیر از همان نوع قرار دهیم تا مقدار برگشتی را در متغیر مذکور ریخته و در جای مناسب از آن استفاده نماییم که در آینده به این مورد می پردازیم .
در شکل زیر شمای کلی تابع در برنامه نویسی را می بینید :

در کد زیر به بررسی یک مثال ساده از توابع می پردازیم :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16 #include <iostream.h>
#include <conio.h>

void print(void); // اعلان تابع

int main()
{
print(); // فراخوانی تابع
getch();
return 0;
}

void print( void ) // تعریف تابع
{
cout << "This is my first function!" ;
}
در بالای تابع main تابع را اعلان می کنیم طوری که نوع بازگشتی و پارامترها با نوعشان و نام تابع را ذکر می کنیم، سپس در خارج از تابع main تابع خود را تعریف کرده که برای اینکار هم باید تمامی انواع ورودی و خروجی بهمراه نامشان و همچنین نام تابع را بنویسیم و دستورات را در آن قرار دهیم و در نهایت در تابع main تابع خود را بدون ذکر انواع فراخوانی نماییم .
کد فوق تابعی را با نام print تعریف می کند که بدون خروجی و ورودی است که در بالای برنامه هم به همین ترتیب اعلان شده است و در فراخوانی آن، چون نوعی ندارد ما آنها را خالی می گذاریم .
کامپایلر اجرای برنامه را از تابع main شروع می کند و در خط بعدی به تابع print برمی خورد که فراخوانی شده است لذا در اینجا از تابع main خارج شده و وارد تابع print می شود. انواع ورودی و خروجی و نامشان را چک کرده و در صورت نبود خطا دستورات را انجام داده تا به انتهای تابع می رسد. در اینجا کامپایلر باز به تابع main برمیگردد و ادامه دستورات را اجرا می کند و در نهایت برنامه خاتمه میابد .
مثال) کدی به زبان C++ با استفاده از توابع بنویسید که 2 عدد را در درون تابع main دریافت کند و بعنوان آرگومان به تابعی بفرستد، تابع آنها را با هم جمع کند و نتیجه را به تابع main برگرداند و سپس نتیجه چاپ شود .

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26 #include <iostream.h>
#include <conio.h>

float sum(float, float); // = float sum(float num1, float num2);

int main()
{
float num1, num2 ,numSum;

cout << "Enter first number :" ;
cin >> num1;
cout << "Enter second number :" ;
cin >> num2;

numSum = sum(num1, num2);
cout << numSum;

getch();
return 0;
}

float sum(float f1, float f2) // float sum(float num1, float num2);
{
float fSum = f1 + f2;
return fSum;
}
Comment هایی را که در کد بالا می بینید به این معنی است که می شود اینگونه هم نوشت. همانطور که میبینید در تابع main دو عدد را دریافت می کنیم و در فراخوانی تابع آنها را بعنوان آرگومانهای تابع ذکر می کنیم. چون تابع sum مقداری از نوع float را برمی گرداند لازم است که تابع را برابر با همان مقدار برگشتی قرار دهیم تا حاصل جمع اعداد در numSum ذخیره کنیم . اولین comment به این معنی است که می شود در اعلان یک تابع اسم پارامترها را نوشت یا ننوشت اما ذکر انواع ضروری است و دومین comment به این معنی است که نام پارامترها در اعلان و در تعریف توابع هم می تواند یکسان باشد و هم نباشد، نکته مهم نوع و تعداد و ترتیب یکسان آنها می باشد .
در حالت کلی به دو روش می توان پارامترها را به توابع ارسال نمود :
• ارسال از طریق مقدار Arguments passed by value
• ارسال از طریق آدرس Arguments passed by reference
روش ارسال پارامترها به تابع از طریق آدرس را در فصول مربوط به اشاره گرها Pointers خواهیم آموخت، اما ارسال پارامترها به تابع از طریق مقدار همان است که در بالا گفته شد .
در روش ارسال از طریق مقدار، یک کپی از آن پارامتر در حافظه کامپیوتر قرار می گیرد و تغییرات برروی آن متغیر در تعریف تابع به هیچ عنوان در مقدار آن در خارج از تابع تاثیری نخواهد داشت اما در روش ارسال از طریق آدرس، تغییرات در متغیر در آدرس موجود کپی شده و تغییرات مربوط به پارامتر در خارج از تابع هم وابسته به تغییرات متغیر در درون تابع می باشد .

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20 #include <iostream.h>
#include <conio.h>

int sqr(int x); // ارسال پارامتر از طریق مقدار

int main()
{
int num = 10;

cout << "square = " << sqr(num) << "and number = " << num;

getch();
return 0;
}

int sqr(int x) // ارسال پارامتر از طریق مقدار
{
x = x * x;
return x;
}
square = 100 and number = 10
همان طور که در برنامه C++ بالا می بینیم پارانتر x از طریق مقدار به تابع sqr ارسال شده، در درون تابع مقدار پارامتر به توان 2 می رسد و به عدد 100 تغییر میابد اما مقدار num در تابع اصلی همان 10 است و تغییری نمی کند .
دقت بکنید که ما فراخوانی تابع خود را در درون تابع cout انجام داده ایم و در اینحالت نیازی به تعریف یک متغیر برای ذخیره مقدار برگشتی تابع فوق نیست .
توابع inline در برنامه نویسی C++ :
یکی از مسائل مهمی که در برنامه نویسی به هر زبانی قابل توجه است اینه که تا جایی که میشود سرعت اجرای برنامه را بالا برد و زمان اجرای دستورات به حداقل برسد. پیاده سازی برنامه به کمک توابع، مقداری به زمان اجرای برنامه اضافه می کند هرچند که این زمان بسیار کم و در حد میلی ثانیه است اما باری را بر روی برنامه قرار می دهد و علت این تاخیر زمانی این است که در فراخوانی و اعلان توابع، کامپایلر کپی از تابع مو رد نظر را در حافظه قرار می دهد و در فراخوانی تابع به آدرس مذکور مراجعه می کند و در عین حال آدرس موقعیت توقف دستورات در تابع main را نیز ذخیره می کند که پس از پایان تابع به آدرس قبل برگردد و ادامه دستورات را اجرا کند، در نتیجه این آدرس دهی ها و نقل و انتقالات بین آنها بار زمانی را در برنامه ایجاد می کند که در صورت زیاد بودن توابع در برنامه و تعداد فراخوانیهای لازم زمان قابل توجهی خواهد شد .
برای رفع این مورد و بهینه سازی کدنویسی می توان از توابع inline در برنامه نویسی استفاده کرد. در واقع کامپایلر در برخورد با این توابع تعریف تابع را در حافظه کپی نمی کند بلکه با فراخوانی تابع در برنامه، کپی از آنرا در خود برنامه قرار می دهد که مورد آدرس دهی از میان خواهد رفت. بهتر است در جایی که تعریف تابع کم است و از تابع بیش از 2 یا 3 بار در طول برنامه استفاده نمی کنیم از این روش بهره بگیریم و بدانیم که inline از کلمات کلیدی در زبان C++ است. به نحوه تعریف یک تابع inline در برنامه نویسی C++ دقت کنید :
inline type name(parameters)

---

> اعلان و تعریف تابع
{
...
}
برنامه زیر را با هم می بینیم :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 #include <iostream.h>
#include <conio.h>

inline int max(int a, int b) // اعلان و تعریف تابع بصورت یکجا
{
return a > b ? a : b;
}

int main()
{
clrscr();

cout << "maximum of 100 & 101 is : " << max(100, 101);

getch();
return 0;
}
maximum of 100 & 101 is : 101
در مورد تابع inline این نکته را باید دانست که تعریف تابع، در درون اعلان همان تابع انجام می شود .
تابع دیگری را می بینیم با نام clrscr که این تابع یک توابع از پیش ساخته شده زبان C++ هست و در فایل سرآیند conio قرار دارد و وظیفه آن پاک کردن صفحه نمایش است .
حوزه (ناحیه) تعریف و کار با متغیر ها در برنامه نویسی C++ :
بحث حوزه کاری متغیر ها و طول عمر آن در توابع و کلاس ها که در ادامه خواهد آمد بررسی می شود. ما در هر ناحیه ای که متغیر را تعریف می کنیم فقط در آن ناحیه می توانیم از آن متغیر استفاده کنیم و با خروج از آن ناحیه و ورود به ناحیه دیگر یا پایان برنامه، آن متغیر از بین خواهد رفت .
پیشتر گفته شد که متغیر ها نامی برای کلمات حافظه هستند که داده ها را در خود نگهداری می کنند. زمانیکه متغیری را تعریف می کنیم در حافظه محلی را به آن اختصاص می دهیم و در استفاده از آن، کامپایلر با استفاده از آدرس ذخیره شده آن متغیر به آن محل از حافظه رفته و یک کپی از مقدار محتویات داده ای متغیر را برای خود ایجاد می کند و از آن کپی در طول عمر متغیر و در برنامه استفاده می کند .
طول عمر یک متغیر با اتمام حوزه آن از بین رفته و کامپایلر آن کپی را دور می ریزد. منظور از حوزه متغیر همان تابع یا کلاس جاری است .

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 #include <iostream.h>
#include <conio.h>

void scope(int);

void main()
{
int x = 10;
cout << "first value of A=" << x << "\n";
scope(x);
cout << "third value of A=" << x;

getch();
}
void scope(int a)
{
a++;
cout << "second value of A=" << a << "\n";
}
first value of A=10
second value of A=11
third value of A=10
با اجرای برنامه بالا کامپایلر از سطر 6 برنامه را آغاز می کند. در سطر 8 متغیری از نوع int بنام x را تعریف کردیم پس در حافظه محلی بنام x با مقدار اولیه 10 ذخیره می شود. در سطر 9 و با برخورد کامپایلر با متغیر x کپی از آن ایجاد شده و مقدار آن یعنی 10 چاپ می شود. در سطر 11 کامپایلر به فراخوانی تابع scope می رسد پس ادامه برنامه را در سطر 15 ادامه می دهد. تابع scope دارای پارامتری به نام a است که همان متغیر x در تابع main می باشد چون در فراخوانی تابع scop ما x را به تابع ارسال نمودیم و فقط نامش در اینجا تغییر کرده است. تابع scope در اینجا فقط a را می شناسد و اگر از x استفاده کنیم انرا نمی شناسد پس اعلام خطا می کند مگر اینکه متغیر جدیدی را بنام x در این تابع تعریف کنیم که متغیر جدیدی است و هیچ ربطی به x در تابع main ندارد .
در سطر 17 یک واحد به a اضافه می شود و چون a همان x در main است کامپایلر یک کپی از مقدار آن گرفته و یک واحد به آن اضافه می کند و عدد 11 را چاپ می کند و با پایان تابع و برگشت کامپایلر به تابع main کامپایلر آن کپی را دور می ریزد در حالی که کپی را یک واحد افزایش داده بود و برای متغیر a .
کامپایلر اینبار برنامه را از سطر 11 ادامه می دهد ولی دیگر آن مقداری را که در تابع scope یعنی a را دور ریخته یعنی عمرش تمام شده و فقط در آن تابع معنی داشت. پس باز به سراغ محل x در حافظه که مقدارش همان 10 است رفته و آنرا چاپ کرده و با پایان برنامه و خروج از تابع main (حوزه x ) کپی آنرا هم دور میریزد و عمر آن متغیر هم تمام می شود و حافظه اختصاص داده شده به آنها آزاد می شود .
سربارگذاری توابع در برنامه نویسی C++ (Overloading functions) :
برای درک سربارگذاری توابع کد زیر را می بینیم :

1
2
3
4
5
6
7
8
9
10
11
12
13
14 #include <iostream.h>
#include <conio.h>

void func(int a){cout << a << "endl";};
void func(int a, int b){cout << a+b << "endl";};
void func(int a, int b, int c){cout << a+b+c;};

void main()
{
func(10);
func(10,10);
func(10,10,10);
getch();
}
10
20
30
در بالا می بینیم که سه تابع با نامهای یکسان func را تعریف و صدا زده ایم. درست است که نامها یکسان است اما تعداد آرگومانهای هر تابع با دیگری متفاوت است .
عمل فوق را سربارگذاری توابع گویند یعنی توابعی که دارای نام مشابه هستند ولی در تعداد آرگمانها و ترتیب ورودی آنها با یکدیگر تفاوت دارند. وقتی در تابع main در سطر 11 تابع func صدا زده می شود، کامپایلر با توجه به آرگومانهای آن متوجه می شود که از کدام یک از سربارگذاری تابع استفاده نماید .
عزیزان دقت نمایند که بنده بخاطر صرفه جویی در فضا، بدنه توابع را در اعلان تابع قرار داده ام که این هم سبکی از برنامه نویسی C++ می باشد و شما می توانید مانند قبل تعریف توابع را جداگانه بیان کنید .
مقدار دهی اولیه آرگومان های توابع (Initialization functions) :
همچنان که می توان در هنگام تعریف یک متغیر مقدار اولیه ای به آن نسبت داد، می توان در اعلان توابع به آرگومان های آن تابع نیز مقدار اولیه ای داد. در اینصورت اگر در فراخوانی تابع هیچ مقداری ارسال نشود از آن مقدار اولیع استفاده خواهد شد :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 #include <iostream.h>
#include <conio.h>

int initializefunction(int num = 50);
// int initializefunction(int=50);

void main()
{
cout << "Initialize value is : " << initializefunction();
cout << "Passed value is : " << initializefunction(100);
getch();
}

int initializefunction(int x)
{
return x;
}
Initialize value is : 50
Passed value is : 100
خوب همانطور که ملاحظه می کنید تابعی را بنام initializefunction که دارای یک آرگومان از نوع int است ومقداری از نوع int را هم برمی گرداند را در سطر 4 از برنامه بالا اعلان کردیم. به آرگومان تابع دقت نمایید که مقدار اولیه 50 را دریافت می کند. این عمل باعث می شود اگر در فراخوانی تابع مقداری به آن ارسال نشود از همین مقدار 50 بعنوان مقدار پیش فرض استفاده نماید مانند سطر 9 واگر هم مقداری برایش ارسال شد، مقدار پیش فرض را در نظر نگرفته و مقدار ارسالی را لحاظ می کند مانند سطر 10 .
در سطر 5 از برنامه هم روش تعریفی دیگری را مشاهده می کنید که بصورت توضیح آمده است. از هر دو صورت می توان استفاده نمود .
توابع بازگشتی در C++
توابع بازگشتی توابعی هستند که در درون تعریف خود تابع هم فراخوانی میشوند. هدف از اینکار صرفه جویی در کد نویسی و ایجاد خلاقیت است. به این نکته توجه داشته باشید که حتما شرطی برای تابع بازگشتی باید وجود داشته باشد تا برنامه به درستی اجرا شود و نتایج خواسته شده از تابع بدست آید و اگر این مورد رعایت نشود تابع بینهایت بار فراخوانی شده و هیچ وقت برنامه به پایان نمی رسد .
کدی به زبان C++ با استفاده از تابع بازگشتی بنویسید که حاصلضرب دو عدد را با استفاده از حاصلجمع آنها بدست آورد .(برای حل این مثال لازم است بدانید که
a*b=a

---

> اگر b=1
a*b=a*(b-1)+a

---

> اگر b>1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42 #include <iostream.h>
#include <conio.h>

int product(int, int);

int main()
{
int a, b;

cout << "Enter first number :" ;
cin >> a;
cout << "Enter second number :" ;
cin >> b;

cout << product(a, b);

getch();
return 0;
}

int product(int a, int b)
{
if(b == 1)