آموزش برنامه نویسی با ++c

[uody]

چند عملگر برای خلاصه کردن اعمال حسابی
عملگرهای ++ و -- برای افزایش و کاهش یک متغیر به اندازه یکی استفاده میشوند. مثلاً اگر int num = 23 را داشته باشیم، ++num به num یکی اضافه میکند و 24 میشود، اما --num از آن یکی کم میکند. این دستورات را میتوان بطور مستقل در یک دستور جدا بصورت ;--num یا در یک دستور دیگر مانند ;--cout << num استفاده کرد. بهرحال از num یکی کم خواهد شد، اما استفاده همزمان از آن در یک دستور دیگر، به کاهش تعداد خطوط برنامه کمک میکند.

وقتی دستور cout قبل را اجرا کنید خواهید دید که بازهم مقدار 23 چاپ میشود! در اینجا یکی از num کم میشود اما نکته ای وجود دارد. ما دو نوع از عملگر ++ داریم : پیش افزایشی(preincrement) و پس افزایشی(postincrement)، پس افزایشی همانی است که دیدید و بعد از نام متغیر قرارمیگیرد اما پیش افزایشی قبل از نام متغیر می آید مانند num++ (و همین دو نوع برای -- هم وجود دارد: پیش کاهشی و پس کاهشی). هر دونوع این عملگرها از این نظر که یکی به متغیری اضافه یا از آن کم میکنند فرقی ندارند، اما عملگرها پیش کاهشی و افزایشی وقتی یک متغیر را تغییر میدهند، مقدار تغییر یافته آنرا برمیگردانند، بنابراین همین مقدار تغییر یافته در عباراتی که عملگرها در آن قرار دارند استفاده میشود. مثلاً cout << --num اگر num مقدار 23 داشته باشد، عدد 22 را چاپ میکند، در صورتی که همین دستور با --num مقدار 23 را چاپ میکرد، چرا که پس کاهشی مقدار تغییر یافته را در دستوری که در آن قرار دارد استفاده نمیکند. البته فقط در دستوری که عملگر پس کاهشی در آن قرار دارد مقدار قبلی متغیر استفاده میشود، وگرنه متغیر تغییر یافته است و بعداً هرجا استفاده شود همان مقدارش که یکی کم شده است استفاده خواهد شد. پس این عملگرها معمولاً وقتی درون دستورات دیگر استفاده میشوند، تفاوتشان اهمیت پیدا میکند.

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

هرجا که نکاتی در مورد پیش افزایشی مطرح شد در مورد پیش کاهشی هم صدق میکند و همینطور در مورد پس افزایشی و کاهشی.

شما برای اضافه کردن یک مقدار به یک متغیر، مثلاً برای اضافه کردن 2 به num باید از دستور num = num + 2 استفاده کنید، اما راه بهتر و خلاصه تر استفاده از عملگر =+ هست: num += 2 که دوتا به num اضافه میکند. برای عملگرهای - و / و * و % هم اینچنین عملگر معادلی وجود دارد.
مثلاً num /= 3 متغیر num را بر 3 تقسیم کرده و خارج قسمت آنرا در num قرار میدهد.


متغیرهای const
کلمه کلیدی const از constant به معنی ثابت می آید و میتوان برای مشخص کردن عدم تغییر یک متغیر از آن استفاده کرد. یعنی بعد از آنکه متغیر تعریف و مقداردهی اولیه شد دیگر نمیتوان مقدار آنرا تغییر داد. برای تعریف یک متغیر از نوع const کلمه کلیدی const را در ابتدای تعریف متغیر قبل از نوع داده آن بیاورید. مثلاً const int c_num = 23 متغیر c_num را با خاصیت const تعریف میکند.

اگر بعد از تعریف c_num داشته باشید c_num = 24 یک خطای زمان کامپایل تولید میکند. چرا که مقدار c_num نمیتواند تغییر کند. هر دستور دیگری هم که c_num را تغییر بدهد، خطا تولید میکند.

متغیر const باید در هنگام تعریف، مقدار اولیه هم بگیرد(چراکه بعداً نمیتوان مقدار آنرا تغییر داد) وگرنه یک خطای زمان کامپایل تولید میشود.

وقتی که میدانیم یک متغیر نباید تغییر کند، const از این تغییر احتمالی جلوگیری میکند(مثلاً وقتی سرعت نور(یا هرچیز ثابت دیگری) را در یک متغیر ذخیره کنیم).

استفاده از define# برای تعریف ثوابت


این دستور را هر کجای برنامه در یک سطر منفرد میتوانید قرار دهید(و چون یک دستور پیش پردازنده است نباید ; در آخر آن بگذارید)، البته معمولاً آنرا قبل از تابع main و بعد از دستورات include# قرار میدهند.

چون استفاده از متغیرهای const فضایی از حافظه اصلی را برای متغیر میگیرد، اما استفاده از define# فضایی اشغال نمیکند، هرجا که فضای اشغال شده از حافظه اصلی توسط برنامه برای شما مهم است، از define# استفاده کنید. اما در کل استفاده از متغیرهای const بهتر است.

مثالی از شکل این دستور: 23 define NUM# که ثابت NUM را با مقدار 23 تعریف میکند.

مثالی از کاربرد این دستور:

define# مانند include# یک دستور پیش پردازنده است. از این دستور میتوان برای تعریف ثوابت درون برنامه استفاده کرد. در حقیقت این دستور ثابت مورد نظر را تعریف نمیکند، اما نامی برای آن مشخص میکند، آنگاه در مرحله پیش پردازش هرجا که نام ثابت بکار رفته باشد با مقدار آن جایگزین میکند. بنابراین متغیری تعریف نمیشود و مانند آن است که خود ما مقدار آن ثابت را در برنامه نوشته باشیم. البته define# استفاده های دیگری نیز دارد.
کد قالب بندی شده:

#include <iostream>
using namespace std;

#define NUM 23

int main()
**

cout << "NUM is a constant: " << NUM << endl;

return 0;
**

توجه: معمولاً نام ثابت ها را با حروف بزرگ مشخص میکنند.

دستور undef#
این دستور یک ثابت تعریف شده با define# را به حالت تعریف نشده درمی آورد. مثلاً پس از دستور undef NUM# ثابت NUM تعریف نشده خواهد بود، یعنی اگر از این نام بدون تعریف مجدد آن در برنامه استفاده کنید، خطایی دریافت میکنید.

برای مقدار دهی مجدد یک ثابت تعریف شده با define# میتوانید آنرا تعریف نشده کنید و دوباره با مقدار مورد نظر تعریف کنید، البته تبدیل به تعریف نشده اجباری نیست و فقط میتوانید دوباره تعریف کنید، اما این کار بهتر است چون ممکن است بعضی کامپایلرها خطایی مبنی بر تعریف مجدد تولید کنند(در VS فقط یک اخطار(warning) تولید خواهد شد که جنبه آگاهی دارد و شما میتوانید برنامه را بسازید، اما خطاها(errors) اجازه ساخت دوباره برنامه را نمیدهند).

هرجا بخواهید از تعریف نشده بودن یک ثابت اطمینان حاصل کنید میتوانید از undef# استفاده کنید، بنابراین برای استفاده از undef# لازم نیست حتماً ثابت را قبلاً با define# تعریف کرده باشید.

[uody]

دستورات کنترل برنامه
وقتی دستورات برنامه را به همان ترتیبی که زیر هم مینویسیم اجرا میشوند، این ساختار ترتیبی برنامه است، یعنی هر دستور به ترتیبی که ظاهر میشود اجرا میشود. اما دو ساختار دیگر نیز کمک کننده هستند: ساختار انتخاب و تکرار.

دستور انتخاب if
با دستور if میتوان درستی یک عبارت را بررسی کرد و براساس آن عملی را انجام داد. مثلاً ممکن است در برنامه بخواهیم یک عدد را بعنوان ID(شناسه) شخصی بگیریم و بعد اگر مقدار خاصی بود عملی را انجام دهیم. در اینجا از دستور if میتوان استفاده کرد. ابتدا بهتر است یک برنامه نمونه که از دستور if استفاده میکند را ببینید. این برنامه عددی را بعنوان ID شخص میگیرد و اگر مقدار آن 1 بود به کاربر بعنوان Admin خوش آمد میگوید.

کد قالب بندی شده:

#include <iostream>
using namespace std;

int main()
**
int ID = 0;

cout << "Hello, please enter your ID : ";
cin >> ID;

if (ID == 1)
cout << "Welcome Admin" << endl;

return 0;
**

پس از اجرای این برنامه باید عددی را بعنوان ID وارد کنید، اگر ID وارد شده 1 باشد، برنامه پیغام خوش آمد گویی را میدهد. دستور if در این برنامه برای انتخاب این است که آیا پیغام خوش آمد گویی چاپ شود یا نه و این را براساس اینکه ID یک هست یا نه انتخاب میکند(یعنی 'مساوی بودن ID با 1' شرط انتخاب است). شکل دستور if اینگونه است:

کد قالب بندی شده:

statement;

if ( condition )

condition شرط انتخاب است و دستور هم فقط یک دستور تنهاست. یک نکته را اینجا بگویم: استفاده از معادل های فارسی ممکن است خوب باشد، اما اگر شما با زبان انگلیسی آشنایی لازم را پیدا نکنید، نمیتوانید براحتی از منابع مرتبط با ++C موجود در اینترنت یا هرجای دیگر که به زبان انگلیسی هستند استفاده کنید(مثلاً از MSDN). حتی خود برنامه نویسی هم با دانستن بهتر انگلیسی راحت تر میشود. یعنی میتوان گفت اگر واقعاً قصد کار در زمینه برنامه نویسی یا هرچیز دیگری مرتبط با کامپیوتر را دارید، باید انگلیسی تان را قوی کنید، چرا که بیشتر منابع بروز انگلیسی هستند. در عین حال دیگر نیازی به گرفتن کتاب هم نخواهید داشت و از هزاران کتاب در زمینه های مختلف کامپیوتری که بصورت ebook در اینترنت موجودند میتوانید استفاده کنید یا از آموزشهایی که در سایتها موجودند و... بهره برید . یک نکته دیگر هم تعامل با کاربران موجود در اینترنت است که واقعاً کمک کننده است. مثلاً خیلی از سایت ها مثل همین جا یک انجمن(forum) برای برنامه نویسی دارند و کاربران در آنها با انگلیسی به بحث در مورد مباحث مختلف مشغولند. شما هم با کمی انگلیسی میتوانید به این جمع ها وارد شوید و مثلاً سؤالاتی بپرسید ، از اطلاعات دیگران استفاده کنید و پاسخ آنها را بدهید.
اما یادگیری انگلیسی برای کامپیوتر آسان و مفرح است! البته با این روش: ابتدا مقدمات قواعد دستور زبان انگلیسی را بلد باشید(مثل ساختار جملات، افعال و...) یعنی در همان حدی که در دبیرستان یاد میگیرید. حالا براحتی میتوانید متون را درک کنید. فقط میماند 'کلمات جدید'، از این به بعد هرجا کلمه جدیدی را در کامپیوتر مشاهده کردید فوراً معنی آنرا یافته و بخاطر بسپارید. استفاده از برنامه Babylon را توصیه میکنم که در اصل مجموعه ای از دیکشنری هاست و براحتی معانی و مترادف ها را در اختیارتان میگذارد و با یک کلیک روی کلمه ای که نمیدانید معنی را برای شما نمایش میدهد. البته ممکن است برخی از دیکشنری ها را نداشته باشید که باید از اینترنت یا جای دیگر بگیرید و به Babylon اضافه کنید. دیکشنری های Oxford هم برای Babylon وجود دارند که توصیه میشود به آن اضافه کنید.

خوب دوباره برگردیم به برنامه نویسی خودمان!

با ساختار دستور if آشنا شدید، در برنامه نمونه ای که مشاهده کردید، شرط ما ID == 1 بود. عملگر == با = ارتباطی ندارد. عملگر = برای انتساب است، اما == برای تست برابر بودن است. این گونه عملگرها مقدار منطقی true یا false برمیگردانند. متغیرهای bool هم که قبلاً معرفی شدند برای نگهداری مقادیر منطقی(true یا false) هستند. بنابراین از متغیرهای bool هم میتوان در شرط ها استفاده کرد.

در دستور if ما فقط یک دستور را مشخص کردیم تا در صورت درستی شرط اجرا شود اما برای داشتن چندین دستور باید با آکولاد باز و بسته دستورات را محصور کنیم. مثلاً دستور if زیر در صورت برقراری شرط، دو دستور cout را اجرا میکند:

کد قالب بندی شده:

**
cout << "Welcome Admin" << endl;
cout << "Learn C++ as soon as possible!" << endl;
**

if (ID == 1)

حتی اگر فقط یک دستور هم داشته باشید میتوانید از آکولادها استفاده کنید.

عملگرهای رابطه ای(Relational Operators)
این عملگرها چون true یا false را برمیگردانند، نتیجه شان میتواند بعنوان عاملی در عبارات منطقی استفاده شود.

== : برابری ، =! : نابرابری ، > : کوچکتر ، < : بزرگتر
=> : کوچکتر یا مساوی ، =< : بزرگتر یا مساوی

برای عملگر نابرابری، مثلاً (x != 1) یعنی x برابر نباشد با یک.

مراقب باشید بین اجزای عملگرهای چند قسمتی فاصله نیندازید، مثلاً در =< بین = و < اگر فاصله بیفتد دیگر یک عملگر بعنوان بزرگتر مساوی نخواهید داشت بلکه دو عملگر انتساب و بزرگتر نوشته اید و چون به شکل مناسبی استفاده نشده اند خطای زمان کامپایل تولید میکنند.

توجه: وقتی دارید یک شرط برابری مینویسید ممکن است اشتباهاً = را بجای == بکار برید. این اشتباه ممکن است تولید خطا نکند، چراکه عملگر = مقداری را که به متغیر سمت چپ آن نسبت میدهد، بعنوان نتیجه برمیگرداند و کامپایلر از این مقدار با یک تبدیل بجای یک مقدار منطقی استفاده میکند. بنابراین شرطی مانند ID == 1 اگر ID = 1 نوشته شود، همیشه درست خواهد بود! چراکه ابتدا مقدار 1 به ID نسبت داده میشود و سپس عملگر = همان مقدار 1 را برمیگرداند و چون کامپایلر یک مقدار bool میخواهد، مقدار int برگشتی را به bool تبدیل میکند(چون غیر صفر است true در نظرگرفته میشود) و چون همیشه 1 هست، همیشه true خواهد بود و مثلاً ID = 0 همیشه false خواهد بود.
پس ما در اینجا دو ضرر کردیم! یکی اشتباه شدن شرط و دیگری تغییر ناخواسته مقدار متغیر. خطایی هم که رخ نداده، پس برنامه اجرا میشود اما با نتایج نادرست. بنابراین در اشکال زدایی برنامه هایتان به این مورد توجه داشته باشید.

عملگرهای منطقی(Logical Operators)
مثلاً اگر در یک شرط بخواهید بدانید آیا x>1 و y<2 هست (یعنی دو شرط را با هم and کنید) از عملگر && استفاده کنید: (x>1 && y<2)، این عملگر روی دومقدار منطقی(> و < مقادیر منطقی برمیگردانند) عمل and را انجام داده و حاصل که یک مقدار منطقی است را برمیگرداند.

&& : AND (اگر هردو عملوند true باشند true وگرنه false برمیگرداند)
|| : OR (اگر هر دو عملوند false باشد false وگرنه true برمیگرداند)
! : NOT (نقیض عملگر خود را برمیگرداند)

برای OR، دوخط عمودی را با دوبار زدن کلیدهای Shift و \ تایپ کنید.

برای NOT، مثلاً در (x!) عملگر ! نقیض x را برمیگرداند(x یک متغیر bool است)، پس اگر true باشد false برمیگرداند، یا مثلاً در ((x == 6)!) نقیض برابری x با 6 را برمیگرداند، پس مانند شرط x مساوی با 6 نباشد هست (x != 6).

مثال: شرط ( (y != x) || (x <= 3) ) میگوید که y با x برابر نباشد یا x کوچکتر مساوی 3 باشد.

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

[uody]

ساختار انتخاب if-else
با دستور if توانستیم تعیین کنیم که با درستی یک شرط کاری انجام شود، اما با اضافه کردن قسمت else میتوانیم تعیین کنیم که در صورت نادرستی آن شرط کار دیگری انجام شود. در قطعه کد قبل بعد از گرفتن ID در صورتی که یک مقدار خاص بود پیغامی چاپ میکردیم، اما حالا میخواهیم در صورتی که مقدار مورد نظر نبود پیغام دیگری چاپ کنیم، این کار را با اضافه کردن قسمت else به if انجام میدهیم:

کد قالب بندی شده:

**
cout << "Welcome Admin" << endl;
cout << "Learn C++ as soon as possible!" << endl;
**
else
cout << "Welcome User" << endl;

if (ID == 1)

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

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

نکته: هر دستور if-else بدون توجه به اینکه چند خط باشد در کل یک دستور حساب میشود، بنابراین وقتی دو دستور if-else تودرتو دارید اگر if-else اول هیچ دستوری جز if-else دوم نداشته باشد نیازی به استفاده از آکولادها نیست.

مثالی برای نکات قبل:

کد قالب بندی شده:

#include <iostream>
using namespace std;

int main()
**
bool x = true,
y = false;

if (x)
if (y)
cout << "x & y";
else
cout << "x";
else if (y)
cout << "y";
else
cout << "no one";

return 0;
**

برای تحلیل راحت تر دستورات if-else، به x و y مقادیر اولیه متفاوتی بدهید و خروجی را مشاهده کنید.

یک نحوه رایج از نوشتن دستور if-else را در زیر میبینید (در این if-else ها بدلیل عدم اهمیت، قسمت شرط و دستورها آورده نشده):

کد قالب بندی شده:

else if ()
else if ()
else

if ()

این نحوه نوشتن if-else ها (که به ساختار else if مشهور است) چیز جدیدی نیست، فقط if-else های تودرتو هستند که پشت سرهم نوشته شده اند (یعنی else if یک if است که در یک else قرار گرفته). اما رایج است چون برای مواقعی استفاده میشود که چندین حالت متمایز ازهم برای یک موضوع وجود دارد، مثلاً فرض کنید نمره یک دانشجو را گرفته اید و حالا میخواهید براساس بازه نمرات به او اعلام کنید که وضعیت نمره او چگونه است (مثلاً A یا B و...). چون در اینجا هر بازه از دیگری جداست، میتوانید از else if استفاده کنید. البته از چندین if پشت سرهم نیز میتوان استفاده کرد، اما وجود else ها هم خوانایی کد را بالا میبرد (چون نشان میدهد که هر حالت از دیگری جداست)، هم سرعت برنامه را، چون در هنگام اجرای برنامه وقتی دستورات if متوالی داشته باشیم تمام دستورات if اجرا میشوند (یعنی شرطشان چک میشود، اگرچه فقط دستورات یکی از آنها اجرا شود) ولی وقتی else ها را اضافه کنیم، وقتی یک قسمت درست تشخیص داده شود مابقی دستورات if اجرا نمیشوند و هرچه if ها زیادتر باشند بهبود سرعت برنامه محسوس تر خواهد بود. البته وقتی تعداد حالات زیاد باشند اگر امکان داشته باشد استفاده از دستور switch بهتر است (این دستور بعداً توضیح داده میشود).

استفاده از عملگر :? بجای دستور if-else
عملگر سه تایی :? دقیقاً کار یک if-else ساده را انجام میدهد و برای زمانی خوب است که یک شرط ساده داریم (یعنی if و else هرکدام فقط یک دستور دارند) و بجای if-else از آن استفاده میکنیم تا تعداد خطوط برنامه کاهش یابد و خواندن آن سریعتر شود.
شکل کلی استفاده از عملگر :? بدین صورت است:

دستور نادرستی : دستور درستی ? شرط

یک مثال برای استفاده از این عملگر (x و y اعداد صحیح هستند و بعلت تقدم عملگرها، استفاده از پرانتزها لازم است):

;(cout << (x>y ? x : y

در این مثال ابتدا شرط x>y چک میشود، اگر صحیح بود حاصل عملگر :? میشود x وگرنه میشود y. یعنی ابتدا شرط قبل از ? چک میشود اگر(if) درست بود عبارت بعد از ? اجرا میشود (اگر متغیر باشد مقدارش برگردانده میشود) وگرنه(else) عبارت بعد از : اجرا میشود. در نهایت دستور cout مقداری که توسط :? برگردانده میشود را چاپ میکند. پس با استفاده از این دستور میتوان براساس یک شرط(درستی یا نادرستی) دستوری را اجرا کرد یا مقداری را برگرداند. مثلاً همین مثال cout قبل را میتوان با استفاده از قابلیت اجرای دستور عملگر :? چنین نوشت:

;x>y ? cout << x : cout << y

همانطور که میبینید ما در پایان دستورات قسمتهای ? و : سمی کالن) نمیگذاریم و فقط به یکی درآخر دستور احتیاج داریم.

دستور انتخاب switch
این دستور زمانی مناسب است که چندین انتخاب برای یک موضوع داشته باشیم (مثلاً بیش از 4 تا)، در اینصورت استفاده از دستور switch کد را خواناتر از موقعی میکند که if-else استفاده کنیم، همچنین تغییر آنهم راحت تر خواهد بود. در اصل switch برای انتخاب یک یا چند حالت از بین حالات موجود است و برای این منظور مناسبتر از if-else است. برای مثالی از این دستور، یک منو به کاربر نشان میدهیم سپس بر اساس انتخاب او پیغامی چاپ میکنیم:

کد قالب بندی شده:

#include <iostream>
using namespace std;

int main()
**
int choice;

cout << "===< Menu >===\n";
cout << "1. choice 1\n";
cout << "2. choice 2\n";
cout << "3. choice 3\n";

cout << "\n\n Enter a choice number : ";
cin >> choice;

switch(choice)
**
case 1:
cout << "You've chosen choice one.\n";
break;

case 2:
cout << "You've chosen choice two.\n";
break;

case 3:
cout << "You've chosen choice three.\n";
break;

default:
cout << "You should enter 1 or 2 or 3.\n";
**

return 0;
**

در این مثال میخواهیم براساس مقدار choice انتخابی انجام دهیم، بنابراین بعد از switch در پرانتزهای جلوی آن choice را آورده ایم. سپس پس از آن بدنه switch در آکولادها محصور میشود و درون بدنه آن انتخاب های مختلف برای choice را می آوریم. برای هر انتخاب یک case مینویسیم و پس از آن مقدار آن انتخاب را، سپس : و پس از آن دستوراتی که میخواهیم برای آن انتخاب انجام شوند را مینویسیم پایان دستورات هم با break مشخص میشود، همینطور برای انتخاب های دیگرهم case های جداگانه ای می آوریم، در آخر یک قسمت default وجود دارد که اختیاری است (یعنی میتوانید این قسمت را حذف کنید) و اگر هیچ کدام از case ها انتخاب نشوند default انتخاب میشود. مثلاً در این مثال اگر کاربر هرچیزی غیر از 1 و 2 و 3 را وارد کند default انتخاب میشود.

نکته: دستورات هر case اگر بیش از یکی هم باشند نیازی به استفاده از آکولاد برای محصور کردن آنها نیست و break پایان آنها را نشان میدهد (البته گذاشتن آکولادها اختیاری است). در آخر دستورات قسمت default نیازی به break نیست چون پایان آن با ** همراه است.

نکته: متغیری که روی مقادیر آن انتخاب انجام میدهیم (که در پرانتزهای جلوی switch می آید) باید صحیح(int) باشد یا مستقیماً به int تبدیل شود (مثل char که کد اسکی آن استفاده میشود، اما مثلاً از float نمیتوان استفاده کرد) .

برای نکات قبل، در مثالی دیگر میخواهیم یک نمره از کاربر بگیریم، سپس براساس آن پیغامی به او نشان دهیم (نمراتA و B و C هستند):

کد قالب بندی شده:

#include <iostream>
using namespace std;

int main()
**
char mark;

cout << "Enter a mark : "; 
cin >> mark;

switch(mark)
**
case 'A':
case 'a':
cout << "Best mark!\n";
break;

case 'B':
case 'b':
cout << "Good mark.\n";
break;

case 'C':
case 'c':
cout << "Bad mark!\n";
break;

default:
cout << "You should enter A or B or C for the mark.\n";
**

return 0;
**

این مثال هم استفاده از نوع char را نشان میدهد و هم OR کردن انتخاب ها را، یعنی مثلاً در صورتی که کاربر a یا A وارد کند برنامه یک پیغام را نشان میدهد و اگر c یا C را وارد کند پیغام دیگری. اینکه دو case را برای a و A پشت سرهم آورده ایم یعنی که OR کرده ایم. چراکه هر وقت برنامه یکی از case ها را انتخاب میکند تا رسیدن به یک break اجرای دستورات را ادامه میدهد.

توجه مهم: فراموشی در قراردادن break در آخر دستورات یک case منجر به اجرای دستورات سایر case ها تا رسیدن به یک break میشود.

توصیه: با گذاشتن break در انتهای default، اگر بعداً case دیگری بعد از default اضافه شود اشتباهی در اثر فراموشی قراردادن case ایجاد نمیشود (اگرچه بهتر است default همیشه آخر آورده شود).

محدودیت های switch
انتخاب برروی مقادیر متغیری انجام میشود که نوع آن باید صحیح باشد.
این انتخاب مانند چندین if-else است که شرط آنها یک تساوی است، بنابراین فقط مقادیر گسسته را میتوان چک کرد، مثلاً برای نمرات میتوان در یک case بیست بودن نمره را چک کرد، اما نمیتوان بین 18 و 20 بودن را چک کرد (یعنی قرارگرفتن در یک بازه را).
در صورت برخورد با محدودیت های switch از if-else میتوان استفاده کرد.

نکته: اگر در دستورات یک case متغیری را تعریف میکنید و مقدار اولیه هم میدهید، باید دستورات آن case را در آکولادها محصور کنید.

[uody]

دستور تکرار while
از while برای تکرار یک عمل براساس یک شرط استفاده میشود. شکل کلی while چنین است:

( while( condition
statement

برای تکرار چند دستور باید آنها را با آکولاد محصور کنید.

برای مثالی از دستور while میخواهیم یک رمز ورود را از کاربر دریافت کنیم و تا وقتی که مقدار صحیح (در این مثال 23 فرض شده) یا 1- (برای خاتمه پرسش) را وارد نکرده این عمل را تکرار کنیم:

کد قالب بندی شده:

#include <iostream>
#include <cstdlib> // system()
using namespace std;

int main()
**
int pass = 0;

cout << "Please enter the password or -1 to exit : ";
cin >> pass;

while (pass != -1 && pass != 23)
**
system("cls"); // clear screen

cout << "Please enter the password or -1 to exit : ";
cin >> pass;
** 

return 0;
**

به دستور تکرار، حلقه(loop) هم گفته میشود، چراکه مانند یک حلقه وقتی به آخر آن میرسیم دوباره به اول آن رسیده ایم و تکرار میشود.

اصطلاحاتی که در دستورات تکرار بکار میروند (توجه کنید که مفهوم جدیدی نیستند):

مقدار نگهبان(sentinel)
مقدار ویژه ای است که کاربر برای پایان تکرار(خروج از حلقه) وارد میکند، در مثال قبل این مقدار 1- است.

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

حلقه بی پایان (endless loop)
حلقه ای است که هیچگاه پایان نیابد، بنابراین برنامه هرگز پایان نمی یابد مگر اینکه کاربر این کار را بکند. در اصل حلقه بی پایان یک مشکل برنامه است که باید از آن اجتناب شود.

دستور break در حلقه ها
قبلاً دستور break را برای خاتمه دادن به یک قسمت case در دستور switch بکار بردیم، در اینجا هم برای خاتمه دادن فوری به یک حلقه از break استفاده میشود، یعنی این دستور موجب میشود برنامه به بیرون حلقه پرش کند. مثلاً دستور while مثال قبل را میتوان اینگونه هم نوشت:

کد قالب بندی شده:

**
if (pass == -1)
break;

system("cls"); // clear screen

cout << "Please enter the password or -1 to exit : ";
cin >> pass;
**

while (pass != 23)

بنابراین اگر شرط یک حلقه همیشه صحیح باشد نمیتوان نتیجه گرفت که حلقه بی پایان است، چراکه میتوان با break به حلقه پایان داد.

نکته: اگر بخواهیم شرط یک حلقه همیشه صحیح باشد از true بعنوان شرط آن استفاده میکنیم.

نکته: وقتی که از break استفاده میکنیم معمولاً براساس یک شرط خواهد بود که میتوان آنرا در شرط حلقه ادغام کرد و این بهتر است، اما وقتی بخواهیم در قسمتی از حلقه با برقراری یک شرط فوراً حلقه پایان یابد و بقیه آن تا پایان اجرا نشود، باید از break استفاده کنیم.

دستور continue
این دستور که در حلقه ها استفاده میشود، در هرجای حلقه آورده شود دستورات بعد از آن اجرا نمیشوند. معمولاً در یک دستور شرطی در حلقه آورده میشود تا در یک تکرار حلقه دستورات بعد از continue اجرا نشوند. بنابراین برنامه در یک تکرار حلقه هرجا به دستور continue برسد دستورات بعد از آن که در حلقه آمده اند را اجرا نمیکند و تکرار بعدی حلقه را دنبال میکند. یک مثال بهتر عملکرد این دستور را نشان میدهد:

کد قالب بندی شده:

#include <iostream>
#include <cstdlib> // system()
using namespace std;

int main()
**
int input = 0;

while (true)
**
cout << "If you want to see a message, enter 1; to exit enter -1 : ";
cin >> input;
system("cls");

if (input == -1)
break;

if (input != 1)
continue; 

cout << "This is the message.\n"; 
** 

return 0;
**

توضیح
یک مقدار را از کاربر درون input دریافت میکنیم، سپس اگر مقدار آن 1- بود حلقه را خاتمه میدهیم که پس از آن برنامه هم خانمه می یابد، اگر مقدار 1 داشت یک پیغام چاپ میشود وگرنه دستور continue اجرا میشود که موجب اجرا نشدن دستورات بعد از آن میشود که در اینجا دستور cout هست، بنابراین پیغام چاپ نمیشود و تکرار بعدی حلقه دنبال میشود.

دستور تکرار do while
این دستور همان عملکرد while را دارد بجز اینکه یکبار حتماً اجرا میشود. شکل کلی آن:

کد قالب بندی شده:

statement
while( condition );

do

اگر دستورات (بخش statement) بیش از یکی باشند باید در آکولاد محصور شوند.

در اولین مثال برای دستور while، ما باید ابتدا pass را از کاربر میگرفتیم تا وقتی در شرط while استفاده میشود مقدار دریافتی را داشته باشد. اما با دستور do while نیاز به نوشتن دستورات کمتری است:

کد قالب بندی شده:

#include <iostream>
#include <cstdlib> // system()
using namespace std;

int main()
**
int pass = 0;

do
** 
cout << "Please enter the password or -1 to exit : ";
cin >> pass;

system("cls"); // clear screen

** while (pass != -1 && pass != 23);

return 0;
**

همانطور که میبینید نیازی به گرفتن مقدار pass از کاربر قبل از شروع حلقه نیست، چراکه do while ابتدا یکبار اجرا میشود سپس شرط آن چک میشود. برای چنین موقعیت هایی که نیاز داریم یکبار دستورات حلقه در ابتدا و بدون توجه به شرط حلقه اجرا شوند، از do while استفاده میکنیم.

توجه: فراموشی در قرار دادن ; در انتهای قسمت while از دستور do while سبب بروز خطای زمان کامپایل میشود.

[uody]

دستور تکرار for
این دستور معمولاً زمانی بکار میرود که متغیر شمارنده داریم و شرط حلقه براساس مقدار آن است. ساختار کلی آن چنین است:

کد قالب بندی شده:

statement

for ( counter-initializer; condition; counter-stepping )

دستور for دو قسمت کلی دارد، یک قسمت آن دستوراتی است که در هر تکرار اجرا میشوند(در صورتی که بیش از یک دستور باشد در آکولاد محصور کنید)، قسمت دیگر برای کنترل تکرار حلقه است. این قسمت که در بین پرانتزها می آید خود از سه قسمت تشکیل شده که با ; از هم تفکیک میشوند، قسمت اول counter-initializer هست که برای مقداردهی اولیه متغیر شمارنده(و یا همراه با تعریف آن) استفاده میشود، قسمت بعد شرط حلقه است، قسمت آخر برای تغییر در مقدار شمارنده است. ابتدا یک مثال ساده از دستور for را ببینید:

کد قالب بندی شده:

#include <iostream>
using namespace std;

int main()
**
for (int i=0; i<10; i++)
cout << i << endl;

return 0;
**

این برنامه اعداد 0 تا 9 را چاپ میکند، که چاپ هرکدام از اعداد در یک تکرار for انجام میشود. قسمت اول دستور for متغیر شمارنده i را تعریف و مقدار اولیه میدهد (اگر i قبل از for تعریف شده بود نیازی به تعریف دوباره آن نبود و مقداردهی با دستور i=0 کافی بود). قسمت بعد مشخص میکند که تا وقتی i کمتر از 10 هست حلقه ادامه یابد و قسمت سوم بعد از هر تکرار حلقه به i یکی اضافه میکند. پس روند اجرای حلقه اینگونه است: ابتدا قبل از اولین تکرار، متغیر i تعریف میشود و مقدار اولیه 0 میگیرد (این عمل فقط همین یکبار انجام میشود). سپس کمتر بودن آن از 10 چک میشود و چون برقرار است اولین تکرار حلقه انجام میشود، در تکرارهای بعدی ابتدا به i یکی اضافه میشود سپس شرط حلقه چک میشود و اگر برقرار بود تکرار بعدی حلقه انجام میشود.

میتوان در بخش کنترل تکرار for چندین دستور در قسمت های مقداردهی و تغییر شمارنده داشت که باید هرکدام را با کاما(,) جداکرد. مثلاً اگر ما به دو متغیر شمارنده در حلقه نیاز داشته باشیم و آنها x و y باشند که قبل از حلقه تعریف شده اند، میتوان دستور for زیر را براساس x و y داشت (دستورات درون for بدلیل بی اهمیت بودن آورده نشده اند):


(--for (x=0, y=2; x<10 && y<23; x+=2, y

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

هر سه قسمت از بخش کنترل تکرار for اختیاری هستند اما وجود دو کامای جدا کننده الزامی است. یعنی مثلاً اگر به قسمت مقداردهی اولیه از for احتیاج نداشته باشیم (متغیرها از قبل مقداردهی شده باشند) میتوان for را اینگونه نوشت:

(++for  i<10; i

میتوان تمام قسمت ها را حذف کرد و نوشت for که مانند یک (while(true عمل میکند.

یادآوری: از دستورات continue و break در for هم میتوان استفاده کرد.

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

[uody]

مراجع (References)
برای هر متغیر میتوان نام های دیگری تعریف کرد که استفاده از آنها مانند استفاده از خود نام متغیر اصلی است. پس ما یک متغیر داریم با چندین نام نه اینکه برای هر نام یک متغیر و فضایی از حافظه تخصیص داده شود. مثلاً برای تعریف مرجع numa برای متغیر num از نوع int که قبلاً تعریف شده است مینویسم:

;int &numa = num

ظاهر این تعریف مانند تعریف یک متغیر است با این تفاوت که قبل از نام مرجع یک & می آید. مرجع باید هم نوع متغیری باشد که به آن ارجاع میدهد. پس از این دستور در هرجای برنامه که از num استفاده میکردیم میتوانیم از numa بجای آن استفاده کنیم. یعنی مثلاً اگر از numa یکی کم کنیم دراصل از num یکی کم کرده ایم(نام متغیر و مراجع آن همگی نامی هستند برای یک قسمت از حافظه بنابراین هرکدام که تغییر کند همان قسمت مشترک تغییر خواهد کرد). ممکن است بپرسید که به چه دردی میخورد؟ یکی از کاربردهای آن در توابع مطرح میشود که بعداً خواهیم دید. البته از مرجع در صورت نیاز یا برای سرعت بخشیدن به برنامه(در توابع) استفاده میشود، بنابراین استفاده از آن زیاد نیست.

نکته: میتوان بیش از یک مرجع برای یک متغیر تعریف کرد.

توجه: نمیتوان بعداً تعیین کرد که یک مرجع به متغیر دیگری ارجاع دهد، پس یک مرجع همیشه به یک متغیر ارجاع میدهد.

توجه: مراجع در هنگام تعریف باید با نام متغیری که میخواهند به آن ارجاع دهند مقدار بگیرند، مثلاً قبلاً numa با num مقدار گرفت.
پس دستور ;int &numa خطا تولید میکند، چون به numa مقدار نمیدهد.

نکته: اگر یک مرجع به مرجع دیگری ارجاع دهد(با نام آن مقدار اولیه گیرد) در اصل بازهم به متغیر اصلی ارجاع میدهد و با اینکه با نام متغیر اصلی مقدار اولیه بگیرد فرقی نمیکند.

استفاده از const
اگر بخواهیم یک مرجع نتواند مقدار متغیری که به آن ارجاع میدهد را تغییر بدهد، از کلمه کلیدی const استفاده میکنیم: const int& numa = num مشخص میکند که numa به num ارجاع میدهد اما نمیتواند مقدار آنرا تغییر دهد، بنابراین دستوری مانند numa = 2 خطا تولید میکند.

نکته و توجه! : در تعریف هر متغیری که از const استفاده کنیم فقط همان متغیر غیر قابل تغییر خواهد بود، مثلاً وقتی یک ارجاع ثابت داریم فقط از طریق آن ارجاع نمیتوان مقدار متغیر اصلی را تغییر داد وگرنه از طریق نام متغیر غیر ثابت یا ارجاع های غیر ثابت دیگر به آن میتوان مقدارش را تغییر داد. پس هرجا که از const استفاده میشود فقط در مورد متغیری که در تعریف آن آورده شده یک محدودیت ثابت بودن میگذارد وگرنه به جای دیگری کاری ندارد!

توجه: برای یک متغیر ثابت باید یک ارجاع ثابت تعریف کرد وگرنه خطا دریافت میکنید چراکه اصل فضای حافظه که با متغیر اصلی گرفته میشود خاصیت ثابت بودن دارد و مرجعی که بعداً به آن حافظه رجوع میکند هم باید این محدودیت را داشته باشد تا حافظه را تغییر ندهد.


اشاره گرها(Pointers)
اشاره گر مانند یک مرجع عمل میکند و میتوان از آن برای دستکاری یک متغیر استفاده کرد اما چند تفاوت دارد:









خوب حالا تعریف یک متغیر اشاره گر: ;int* numa = &num ، متغیر numa به num اشاره خواهد کرد یعنی آدرس num در numa قرار میگیرد. استفاده از * تعریف یک اشاره گر را مشخص میکند. متغیر numa در اصل یک int به اندازه 4 بایت است(32 بیت)، پس اگر آنرا چاپ کنید 8 عدد hex مشاهده خواهید کرد که آدرسی از حافظه است(هر رقم hex بیانگر 4 بیت است، بنابراین 8 تای آنها 32 بیت را نشان میدهد). اشاره گر باید همنوع با متغیری باشد که به آن اشاره میکند، مگر اشاره گری از نوع void که میتواند به هر متغیری اشاره کند اما بعداً برای استفاده از مقدار متغیری که به آن اشاره میکند باید *void به یک نوع اشاره گر دیگر تبدیل شود(مثلاً *int تا بتوان عدد موجود در یک متغیر صحیح را نشان داد). البته *void موقعی استفاده دارد که نوع متغیری که به آن اشاره میکنیم را نمیدانیم و بعداً مشخص خواهد شد. بهرحال استفاده از *void موردی است.

نکته: مرجعی از نوع void نداریم، یعنی &void نادرست است.

نکته: برای تعریف چندین اشاره گر از یک نوع در یک دستور، مثلاً برای تعریف اشاره گرهای num1 و num2 از نوع int بنویسید: int *num1, *num2 ، یعنی * را برای هردو بیاورید وگرنه int *num1, num2 متغیر num1 را از نوع اشاره گر و num2 را از نوع متغیر صحیح تعریف میکند.

1. خود اشاره گر یک متغیر جداست که مقدار آن برابر آدرس متغیری قرار میگیرد که میخواهیم به آن اشاره کند. 2. میتوان تعیین کرد که یک اشاره گر به متغیر دیگری اشاره کند، یعنی لازم نیست همیشه به یک متغیر اشاره کند. 3. چون مراجع مکانی از حافظه را اشغال نمیکنند بنابراین برای صرفه جویی در حافظه مناسب هستند. 4. جایی هست که از مرجع نمیتوان استفاده کرد و باید از اشاره گر استفاده کرد. عملگر &
قبلاً از & برای تعریف یک مرجع استفاده کردیم، حالا استفاده دیگری از آن میکنیم که برگرداندن آدرس عملوند خود هست.
بنابراین در دستور ;int* numa = &num ابتدا num& آدرس num را برمیگرداند سپس مقدار numa برابر آن قرار میگیرد.

یک اشاره گر را میتوان ابتدا بدون مقداردهی اولیه تعریف کرد و بعداً مقدار آنرا مشخص کرد. پس میتوان ابتدا int* numa را داشت و بعداً numa = &num را نوشت تا numa به num اشاره کند. بعداً هر آدرس دیگری را هم میتوان در اشاره گر ریخت تا به آن اشاره کند.

عملگر *
تا اینجا با اشاره گر و نحوه اشاره به یک مکان از حافظه(یک متغیر) آشنا شدیم، اما اشاره گرها چه استفاده ای دارند؟ خود آدرس درون یک اشاره گر ممکن است مورد استفاده قرار گیرد اما معمولاً از قابلیت دسترسی اشاره گر به متغیری که به آن اشاره میکند استفاده میشود. در اینجا عملگر * استفاده میشود. این عملگر بر روی اشاره گرها اعمال میشود و متغیری که به آن اشاره شده را برمیگرداند(البته نه مقدار آنرا بلکه انگار شما خود متغیر را به جای اشاره گر استفاده کرده اید). مثلاً فرض کنید 23=int num و int* numa = &num را داریم، پس numa به num اشاره میکند. حالا میخواهیم به num از طریق numa دسترسی پیدا کنیم. مثلاً برای چاپ مقدار آن: cout << *numa مقدار 23 را چاپ میکند، پس فرض کنید که بجای numa* خود num قرار گیرد، ساده میشود نه؟! برای تغییر مقدار num هم: numa = 32* مقدار num را به 32 تغییر میدهد. البته در عبارات پیچیده تر به تقدم عملگرها هم توجه کنید و برای کاهش پیچیدگی، از پرانتزها استفاده کنید.
پس هروقت به خود متغیر اشاره شده نیاز داشتید از * بهمراه نام اشاره گر استفاده کنید و هر وقت به آدرس آن نیاز داشتید فقط از نام اشاره گر استفاده کنید.

استفاده از const
قبلاً از const برای مشخص کردن ثابت بودن مقدار یک متغیر استفاده کردیم، برای یک اشاره گر نیز میتوان دو جنبه از ثابت بودن را درنظر گرفت، یکی مقدار خود اشاره گر و دیگری مقدار متغیری که به آن اشاره میکند. مقدار اشاره گر که همان آدرسی است که به آن اشاره میکند اگر ثابت فرض شود پس باید هنگام تعریف اشاره گر مقدار بگیرد، یعنی int* const numa = &num که مشخص میکند numa به num اشاره میکند و بطور ثابت باید به همین جا اشاره کند و اگر بعداً آدرس دیگری در numa بریزید خطا تولید میشود، البته میتوان مقدار جایی که numa به آن اشاره میکند(num) را با استفاده از numa تغییر داد. اما برای ثابت فرض کردن جایی که اشاره گر به آن اشاره میکند باید const را قبل از * قراردهید(یا قبل از int ، که فرقی نمیکند) مثلاً const int* numa = &num مشخص میکند که با استفاده از numa نمیتوان مقدار num را تغییر داد(اما numa میتواند به هرجای دیگری اشاره کند). پس const int* const numa = &num مشخص میکند که numa نمیتواند بجای دیگری جز num اشاره کند و همچنین نمیتوان مقدار num را با استفاده از numa تغییر داد.

توجه: اگر یک متغیر ثابت دارید و میخواهید اشاره گری به آن تعریف کنید، باید در تعریف اشاره گرمشخص کنید که به یک متغیر ثابت اشاره میکند(یعنی const قبل از int را حتماً قرار دهید).

[uody]

آرایه ها بعنوان اشاره گرها
وقتی یک آرایه را تعریف میکنید در حقیقت یک اشاره گر را تعریف کرده اید، چطور؟ نام آرایه اشاره گر ثابتی به اولین عنصر آرایه است (ثابت از این جهت که همیشه به یکجا اشاره میکند، اما مقدار آنجا میتواند تغییر کند). پس مثلاً اگر [int a[3 داشته باشید، a اشاره گر ثابتی است که مقدار آن آدرس اولین عضو آرایه یا همان [a[0& میباشد. در قسمتهای بعد کاربردهای این نگرش به آرایه ها را خواهید دید.

استفاده از عملگر جمع و تفریق روی اشاره گرها
قبلاً گفتیم که نام آرایه اشاره گری به اولین عضو آن است. در اینجا درمورد چنین اشاره گری صحبت میکنیم (یعنی فقط اشاره گری به یک عنصر یک آرایه که بعد از آن عنصر دیگری باشد، نه مثلاً اشاره گری به یک متغیر منفرد، همچنین فرض کنید که ما یک اشاره گر متغیر معادل با نام آرایه تعریف کرده ایم، پس میتوان تعیین کرد تا به محل دیگری اشاره کند(برخلاف نام آرایه)، مثلاً برای [int a[3 اشاره گر b را چنین تعریف میکنیم int *b = a پس میتوان آدرس درون b را تغییر داد). پس ما اشاره گری به محلی از حافظه داریم که دو خاصیت آن مورد نظر است: 1. از آن محل تا یک جایی مشخص کننده یک عنصر از آرایه است، مثلاً اگر به اول عنصر دوم از یک آرایه صحیح (int) اشاره کند، تا چهار بایت بعد از آن متعلق به عنصر دوم خواهد بود (هر int چهار بایت است) و بعد از آن چهار بایت برای عنصر سوم آرایه و بهمین ترتیب تا عنصر n ام آرایه.
حالا به کاربرد عملگر جمع اشاره میکنیم: اگر b اشاره گری (در اینجا همیشه منظور اشاره گر متغیر است نه ثابت) به اولین عنصر آرایه [int a[3 باشد عبارت b+2 اشاره گری به سومین عنصر آرایه برمیگرداند، بنابراین (b+2)* عنصر سوم را برمیگرداند. پس میبینیم که مثلاً جمع با 3 یعنی اینکه به اندازه 3 عنصر جلو برویم (در اینجا چون int داریم یعنی 3 تا 4 بایت). پس اینکه چند بایت جلو برویم بستگی به این دارد که نوع عناصر چیست. مثلاً چون char یک بایت میگیرد پس یک بایت هم جلو میرویم. تفریق هم درست عکس عمل جمع را انجام میدهد.
همانطور که میدانید عملگر + تغییری در عملوندش ایجاد نمیکند، بنابراین b تغییری نمیکند، اما اگر b مثلاً به اولین عنصر آرایه اشاره کند و بخواهیم آنرا تغییر دهیم تا به سومین عنصر اشاره کند باید بنویسیم b = b+2 یا معادل آن b += 2 و همینطور هم برای عملگر تفریق.

محدوده استفاده از متغیرها
وقتی یک متغیر را درون یک for تعریف میکنید، فقط میتوانید در بدنه همان for از آن استفاده کنید، آکولادهای for این محدوده را مشخص میکنند. محدوده ها با همین آکولادها مشخص میشوند، بنابراین محدوده بین دو آکولاد(باز وبسته) در هرجای دیگری هم همین محدودیت را اعمال میکند. به یک محدوده بلاک (block) یا scope میشود. مثلاً scope یک متغیر درون for، همان بدنه (بلاک) for است. متغیرها در حالت عادی در بیرون یک بلاک از بین میروند و حافظه شان آزاد میشود، بنابراین حافظه هرز باقی نمی ماند. همچنین از استفاده نا خواسته از یک متغیر در جای دیگر جلوگیری میشود و در عین حال میتوان متغیرهای همنامی در scope های مختلف داشت. مثلاً اگر یک متغیر a درون یک for داشته باشید و بعد از بلاک for هم بخواهید یک متغیر دیگر با همان نام ایجاد کنید این کار امکان پذیر خواهد بود.
خود تابع main هم با دو آکولادش یک محدوده را تعریف میکند. گسترده تر از آن محدوده فایل منبع است که در آن برنامه را مینویسید.

تخصیص حافظه پویا (Dynamic Memory Allocation) و عملگرهای new و delete
وقتی متغیری را تعریف میکنیم یعنی برای آن حافظه ای را اختصاص داده ایم و در بلاکی که تعریف شده حافظه اش را حفظ میکند. اما اگر خودمان بخواهیم آنرا از بین ببریم نمیتوانیم این کار را انجام دهیم. پس میتوان گفت که حافظه آن بصورت ایستا گرفته شده است. با استفاده از تخصیص پویای حافظه میتوان هر زمانی حافظه ای را تخصیص داد و هر وقت خواستیم آنرا از بین ببریم. حافظه ایستا از stack (پشته) حافظه برنامه گرفته میشود، اما حافظه پویا از heap یا پشته مخصوص حافظه پویا گرفته میشود.

عملگر new
با عملگر new یک حافظه پویا را درخواست میکنیم. مثلاً در int *a = new int ابتدا new int قسمتی از حافظه پویا به اندازه int را میگیرد و بعد اشاره گری به آن قسمت از حافظه را برمیگرداند، سپس این آدرس درون اشاره گر a ریخته میشود، بنابراین بعد از این میتوان در هرجا که خواستیم، با اشاره گر a به حافظه گرفته شده دسترسی پیدا کنیم. اگر new نتواند حافظه را بگیرد NULL (یا معادل آن مقدار 0) را برمیگرداند. حالا میتوان با اشاره گر a هر تغییری که میخواهیم در این حافظه بدهیم یا اینکه مقدار a را در اشاره گر دیگری بریزیم و با آن این تغییر را انجام دهیم، یعنی این حافظه درست مانند حافظه یک متغیر معمولی (که بصورت ایستا گرفته شده) میباشد.

نکته: برای دادن مقدار اولیه به حافظه ای که با new تخصیص میابد: مثلاً (int *a = new int(23 به جایی که a به آن اشاره میکند (a*) مقدار 23 را بعنوان مقدار اولیه میدهد.

آزاد کردن حافظه پویا با delete
وقتی با new یک حافظه را بصورت پویا گرفتید هر وقت که بخواهید میتوانید این حافظه را با استفاده از عملگر delete آزاد کنید (یعنی پس دهید). مثلاً اگر اشاره گر حافظه پویا در a باشد، دستور delete a حافظه را آزاد میکند، یعنی دیگر جایی که a به آن اشاره میکند را نمیتوان تغییر داد و در اختیار سایر برنامه ها قرار میگیرد. پس از آزاد سازی یک حافظه بهتر است اشاره گر آنرا با NULL مقدار دهیم تا بعداً هر کجا خواستیم، با مقایسه آن با NULL متوجه شویم که آیا اشاره گر به محل معتبر و قابل استفاده ای اشاره میکند یا نه.
همانطور که میبینید حافظه گرفته شده فقط با اشاره گری به آن قابل دسترسی است و نامی ندارد، بنابراین اگر ما فقط یک اشاره گر به این قسمت حافظه داشته باشیم و بعداً آن هم به جای دیگری اشاره کند، یعنی آدرس آن قسمت از حافظه گم شود، خود حافظه هم گم میشود چراکه تا با delete یک حافظه پویا را حذف نکنید از بین نمیرود.

توجه مهم: همیشه باید حافظه ای که با new گرفته اید را تا قبل از پایان برنامه delete کنید وگرنه این حافظه به برنامه های دیگر هم اختصاص نمی یابد و مشکلی به نامmemory leak (نشت حافظه) بوجود می آید، یعنی حافظه از یک جایی ناخواسته کم شده است.

تخصیص حافظه پویا برای آرایه ها
برای آرایه ها نیز میتوان به تعداد عناصر آنها یکجا حافظه گرفت. مثلاً دستور [int *a = new int[3 به اندازه یک آرایه با سه عنصر از نوع int حافظه میگیرد و سپس آدرس آن را درون a قرار میدهد. چون نام آرایه اشاره گری به اولین عنصر آن است پس میتوان مستقیماً از a بعنوان نام آرایه استفاده کرد. یعنی بعد از دستور قبل میتوان دستوری مانند [a[2 داشت که عنصر سوم آرایه را برمیگرداند.
برای آزاد کردن حافظه پویای یک آرایه از عملگر delete بصورت delete[] a استفاده میشود (یعنی قسمت [] که نمایانگر کار بر روی آرایه است به آن اضافه شده).

نکته: هنگام تعریف یک آرایه معمولی باید تعداد عناصر آنرا با یک مقدار ثابت تعیین کرد (مثلاً یک عدد یا یک متغیر ثابت)، اما مزیت تخصیص پویا این است که میتوان تعداد عناصر را با یک متغیر هم مشخص کرد و براساس مقدار آن تعداد عناصر مشخص میشود. مثلاً اگر int b=4 را داشته باشیم، میتوان بعد از آن داشت [int *a = new int[b و بعد از این a به محلی از حافظه که برای یک آرایه پویا با b عضو (4) تخصیص داده شده اشاره میکند.

اشاره گر به اشاره گر
خود اشاره گر هم یک متغیر است و فضایی در حافظه با آدرسی مشخص دارد، بنابراین میتوان اشاره گری به اشاره گر داشت، مثلاً اگر int *a داشته باشیم میتوان اشاره گر b به a را تعریف کرد: int **b = &a در اینجا ** یک اشاره گر به اشاره گر را مشخص میکند. البته اگر ستاره اول را با int و دومی را با b در نظر بگیریم تعبیر آن چنین میشود: b چون کنارش * آمده یک اشاره گر است و نوع آن همان نوع متغیری است که به آن اشاره میکند و چون در اینجا به یک اشاره گر به نوع صحیح اشاره میکند نوعش *int میشود. اگر این اشاره گر را از درجه 2 بگوییم، میتوان اشاره گرهایی با درجات بالاتر هم داشت اما بندرت استفاده میشوند (شاید اصلاً استفاده نکنید)، خود اشاره گر درجه 2 هم بندرت استفاده میشود.

آرایه های دو بعدی بعنوان اشاره گر به اشاره گر
آرایه دوبعدی را میتوان چنین در نظر گرفت: اگر هر سطر آنرا یک آرایه یک بعدی در نظر بگیریم پس آرایه دو بعدی آرایه ای یک بعدی است که هر عنصر آن خود یک آرایه یک بعدی است و چون آرایه یک بعدی اشاره گری به اولین عضو آن است پس با این نگرش میتوان گفت آرایه دو بعدی یک اشاره گر است که نوع عناصر آن هم اشاره گر است پس میشود اشاره گر درجه 2. نوع [int a[2][3 میشود [3]int که با اضافه شدن a به آن میشود [3](int(*a در اصل نوع **int است اما چون مربوط به آرایه است و باید تعداد عناصر بعد دوم آن مشخص شود، از **int استفاده نمیشود. برای تعبیر کردن [3]int باید ابتدا درون پرانتز را در نظر بگیرید و بعد بیرون آنرا نوعش در نظر بگیرید. در اینجا درون پرانتز * است که برای اشاره گر (آرایه یک بعدی) آمده است و بیرون آن [int [3 که برای نوع هر عنصر از آرایه (که خود یک آرایه یک بعدی با 3 عنصر است) آورده شده است. اگر در [3]int پرانتزها را نگذارید و بنویسید [3]*int یک آرایه دوبعدی را نشان نمیدهد بلکه آرایه یک بعدی است که هر عنصر آن یک اشاره گر است، بنابراین دراینجا حتماً از پرانتزها استفاده کنید. البته از [3]*int هم میتوان به روش دیگری برای آرایه دوبعدی استفاده کرد، اما مهم این است که به تفاوت این دو باهم توجه داشته باشید.
اگر تمام مطالبی که در این قسمت مطرح شد را یادنگرفته باشید اشکالی ندارد، اما مفهوم ها را اگر درک کنید در جاهای دیگر هم کمک میکند.

تخصیص حافظه پویا برای آرایه های دو بعدی
برای گرفتن حافظه پویا برای آرایه یک بعدی a با 3 عنصر مینویسیم [int *a = new int[3 چون آرایه یک بعدی اشاره گر ساده بود، برای آرایه دوبعدی a با 2 ردیف و 3 ستون مینویسیم: [int (*a) [3] = new int[2][3 و بعداً از a میتوان مانند یک آرایه دوبعدی معمولی استفاده کرد، مثلاً نوشت [a[1][2 تا عنصر ردیف دوم- ستون سوم را برگرداند.
میتوان برای مشخص کردن تعداد عناصر بعد اول آرایه از متغیر هم استفاده کرد: [int (*a) [3] = new int[b][3 اما برای ابعاد بالاتر نمیشود و باید مشخص شود.
برای آزاد کردن حافظه آن هم باید از همان []delete استفاده کرد و نوشت delete[] a.

پس یک delete داریم که برای آزاد کردن فضای متغیر تکی (غیر آرایه) بکار میرود و یک []delete که برای آرایه ها (با هر چند بعد) بکار میرود.

[uody]

تبدیل (cast) انواع داده ای
در ++C انواع مختلفی برای داده ها وجود دارد، مثل int و float و ... و گاهی پیش می آید که بخواهیم این انواع را تبدیل کنیم. مثلاً دو عدد اعشاری را داریم اما مجموع آنها را فقط بطور صحیح لازم داریم (و میخواهیم به یک متغیر int انتساب دهیم)، پس باید مثلاً نوع float به int تبدیل شود تا حاصل جمع در یک متغیر int ریخته شود. این تبدیل ها میتواند برای انواع داده ای تعریف شده توسط برنامه نویس هم انجام شود که در جای خود توضیح داده میشود. به انواعی که از ابتدا درون زبان وجود دارند (بدون تعریف برنامه نویس) انواع درونی (integral) میگویند. در اینجا بر اساس انواع درونی مثال می آوریم که برای انواع تعریف شده توسط کاربر هم همینگونه است اما به کار اضافی نیاز دارد.

دو نوع تبدیل وجود دارد: (ضمنی)implicit و (صریح)explicit

اساس عمل تبدیل: هرجا که کامپایلر انتظار استفاده از نوعی را داشته باشد اما نوع دیگری استفاده شود، اگر امکان داشته باشد خودش تبدیل میکند (implicit) وگرنه باید برنامه نویس خودش تبدیل کند (explicit).

نکته: برنامه نویس میتواند هر کجا که مجاز باشد از تبدیل صریح استفاده کند (حتی جایی که نیازی نباشد). مثلاً برای چاپ (با cout) کد اسکی یک متغیر از نوع char میتوان char را بطور صریح به int تبدیل کرد و سپس به خروجی فرستاد.

تبدیل implicit
قسمتی از تبدیل ها را خود کامپایلر برای شما انجام میدهد. مثلاً اگر f از نوع float با مقدار 2.3 باشد و i از نوع int باشد، حالا با انتساب f به i مقدار 2.3 به 2 تبدیل میشود و درون i ریخته میشود (البته مقدار f بدون تغییر خواهد ماند).

از دست رفتن داده ها (loss of data)
در اینجا کامپایلر یک warning میدهد که تبدیل float به int احتمال از دست رفتن داده ها را در پی دارد. مثلاً در اینجا سه دهم از 2.3 حذف خواهد شد، یعنی از دست میرود، اما اگر f مقدار 2 داشت (قسمت اعشاری نداشت) هیچ داده ای از دست نخواهد رفت و همان 2 در i ریخته میشود. پس باید در تبدیل ها به احتمال از دست رفتن داده ها توجه داشت، حتی ممکن است یک کامپایلر هشدار هم ندهد و ما از دست رفتن داده ها را متوجه نشویم. بهرحال با تبدیل انواعی که میتوانند مقادیری را نگه دارند که نوع تبدیل شده (مقصد) نمیتواند نگه دارد، احتمال از دست رفتن داده ها وجود دارد. مثلاً تبدیل float یا double به int یا تبدیل int به short int یا char (حتی در تبدیل int به float هم هشدار دریافت میکنید، چون int مقادیر صحیح بزرگتری نسبت به float نگه میدارد، در چنین جایی برای نگه داری تمام مقادیر ممکن میتوان از double بجای float استفاده کرد).

کوچک سازی (truncation)
حتی هنگام تعریف f بصورت float f = 2.3 شما یک هشدار truncation (کوتاه سازی) از double به float را دریافت میکنید، چراکه خود 2.3 هم یک نوع دارد (literal ها هم نوع دارند) و نوعش double است و هنگام ریخته شدن در f به float تبدیل میشود و چون float مقادیر کوچکتری را نگه میدارد پس ممکن است قسمتی از داده ها از دست برود (مثلاً دقت اعشاری کاهش یابد).

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

تبدیل explicit
این تبدیل توسط خود برنامه نویس با نوشتن دستوراتی درون کد برنامه انجام میشود. مثلاً وقتی هنگام انتساب f از نوع float به i از نوع int بنویسید



i = (int)f دیگر هشداری دریافت نمیکنید چون گذاشتن (int) قبل از f آنرا به صراحت به int تبدیل میکند و سپس در i میریزد. میتوان تبدیلات صریح را بگونه ای مثل (int(f هم نوشت که f را به int تبدیل میکند. عملگرهای تبدیل صریح
تبدیل صریح را میتوان با عملگرهای خاصی که در ++C وجود دارد هم انجام داد تا وضوح نوع تبدیل بالاتر رود. برای تبدیل یک نوع به دیگری از (static_cast<type> (expression استفاده میشود که در آن type نوع مقصد و expression عبارتی است که میخواهیم نوعش تبدیل شود. مثلاً (static_cast<int> (f نوع مقدار متغیر f را به int تبدیل میکند و برمیگرداند (البته نوع مقداری که برمیگرداند int میشود و f بدون تغییر میماند).

برای یک تبدیل که نوع تفسیر بیت ها را تغییر میدهد از (reinterpret_cast<type> (expression استفاده کنید، مثلاً
(reinterpret_cast<unsigned int>(p اگر p از نوع *void باشد به unsigned int تبدیل میکند، یعنی تفسیری که از بیت ها میشد یک اشاره گر بود اما مقدار برگشتی یک متغیر غیر اشاره گر از نوع unsigned int در نظر گرفته میشود.

برای تبدیل یک اشاره گر به متغیر const (که نمیتواند مقدار آنرا تغییر دهد) به همان نوع اشاره گر اما به متغیر غیر const (که بتواند مقدار متغیر را تغییر دهد) از (const_cast<type> (expression استفاده میشود. مثلاً (const_cast<int *> (ptr ، اگر ptr از نوع *const int باشد، اشاره گر برگشتی همان مقدار ptr را دارد اما با آن میتوان مقدار متغیری که اشاره میشود را تغییر داد.

نکته: به تبدیل هایی که از عملگرهای تبدیل استفاده نمیکنند (مانند int)number) ) تبدیل های سبک قدیمی زبان C گفته میشود.

نکته: از عملگرهای تبدیل برای رفع ابهام و امن تر کردن تبدیل های سبک قدیمی زبان C استفاده کنید.

توجه: سعی کنید از const_cast و reinterpret_cast بعنوان آخرین چاره استفاده کنید، چرا که امنیت تبدیل را پایین می آورند (و به تبدیل های زبان C نزدیک هستند).
__________________

[uody]

نوع داده شمارشی (enumeration)

مزایای نوع شمارشی
وقتی یک چیز چند حالت (مقدار) داشته باشد (مانند روزی از هفته که میتواند شنبه، یکشنبه و... باشد) برای نمایش این مقادیر چند راه داریم. مثلاً اگر بخواهیم به موضوعی نمره بدهیم و نمرات A و B و C باشند برای نمایش A و B و C میتوانیم اینگونه عمل کنیم:

1. یک متغیر int بعنوان نمره در نظر بگیریم و برای هرکدام از مقادیر نمره ها یک عدد در نظر بگیریم. مثلاً برای A صفر، B یک و C دو.
اما مشکل این است که حتی اگر این مقادیر را در توضیحات کد هم بیاوریم که معادل چه نمره ای هستند، چون از اعداد 0و 1و 2 استفاده میکنیم هیچ معنایی را نمی رساند و موجب سردرگمی میشود (و تشخیص مقادیر مختلفی که برای نمرات وجود دارد آسان نیست) و اگر بخواهیم مقدار معادل یک نمره را تغییر دهیم (مثلاً بجای صفر برای A مقدار 3 در نظر بگیریم)، باید در تمام کد دنبال عدد صفر بگردیم تا به یک تبدیل کنیم و حالا چطور از بین تمام صفرهای درون کد صفر معادل A را تشخیص دهیم؟
بهمین خاطر توصیه میشود که از این روش استفاده نشود (خصوصاً در مقیاس گسترده)، و به اعدادی مثل صفر در اینجا، اعداد جادویی (magic) میگویند چون باعث سردرگمی در برنامه نویسی شده و فوراً نمیتوان به معنی آن پی برد.

2. برای حل مشکلات روش 1 میتوان برای هر نمره یک متغیر ثابت تعریف کرد. مثلاً برای A داشته باشیم const int A = 0.
اکنون برای مشخص کردن نمره A خود A را مینویسیم که مشکل ابهام را حل میکند. اگر بخواهیم مقدار معادل A را از صفر به 3 تغییر دهیم حالا فقط لازم است در تعریف A مقدار آنرا تغییر دهیم که مشکل تغییر مقدار در چندین جای کد را حل میکند.
اما تعریف چند متغیر جنبه منفی هم دارد : خود تعریف چندین متغیر جالب نیست (که این مسئله وقتی تعداد حالات زیاد باشد خود را نشان میدهد) و مقادیر مختلف برای نمرات بهم مربوط نیستند (چون متغیرهای جدا گانه ای هستند)، پس مانند روش 1 تشخیص مقادیر مختلفی که برای نمرات وجود دارد آسان نیست.

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

تعریف نوع شمارشی
برای تعریف نوع داده شمارشی از کلمه کلیدی enum استفاده میشود، مثلاً :
;** enum Grade ** A, B, C نوع داده شمارشی Grade را تعریف میکند که دارای سه مقدار مختلف A و B و C میباشد. برای تعریف متغیری از نوع Grade مانند هر نوع دیگری مینویسیم Grade gr که متغیر gr را از نوع Grade تعریف میکند. بعنوان روش دیگری برای تعریف gr میتوان در آخر تعریف Grade نام gr را اضافه کنیم : ;enum Grade ** A, B, C **gr که gr را از نوع Grade تعریف میکند. برای تعریف چند متغیر در هنگام تعریف Grade بقیه را با کاما بعد از gr اضافه میکنیم : ;gr,gr1,gr2 که هر سه را از نوع Grade تعریف میکند. در این حالت میتوان مقدار اولیه هم داد gr=A, gr1=B, gr2=A یا اینکه فقط به برخی مقدار اولیه داد.

توصیه: بهتر است اولین حرف نام نوع داده ای که تعریف میکنید بزرگ باشد (مثل G در Grade) تا از متغیرها متمایز شود (و اهمیت بیشتر آنرا نشان دهد). اگر نام نوع داده بیش از یک کلمه است، اولین حرف هر کلمه را بزرگ بنویسید، مانند ClassGrade که دو کلمه ای است.

اشتباه رایج در استفاده از enum ها : برنامه نویسان ممکن است از خود نوع داده شمارشی (مثل Grade) بعنوان یک متغیر استفاده کنند در حالی که یک نوع هست و این کار تولید خطا میکند (مثل آنست که به خود int یک مقدار انتساب دهید!)، برای استفاده از نوع شمارشی باید یک متغیر از آن نوع را تعریف کنید.

برای هر مقدار از یک نوع داده شمارشی یک معادل عددی (صحیح) در نظر گرفته میشود. مثلاً برای نوع Grade مقدار A معادل عدد صفر، B یک و C دو میباشد. چون ما بطور صریح اعداد معادل را مشخص نکرده ایم کامپایلر از صفر معادل قرار میدهد. برای مشخص کردن معادل های صریح، در تعریف نوع شمارشی، هر مقدار را با عملگر = معادل عدد مورد نظر قرار میدهیم، مثلاً برای اینکه A معادل 3 باشد مینویسیم A=3 و اگر برای B معادلی مشخص نکنیم میشود 4 چون اگر مقداری صریحاً معادل نگیرد، به عدد معادل مقدار قبل از آن یکی اضافه میشود و بعنوان معادل آن قرار میگیرد (پس C هم بطور ضمنی 5 میشود). میتوان از اعداد منفی هم استفاده کرد. بازه اعدادی که برای معادل ها میتوان استفاده کرد بستگی به کامپایلر دارد، اما معمولاً همان بازه مقادیر int هست.

نکته: در اصل کامپایلر در عمل کامپایل از معادل عددی مقادیر شمارشی استفاده میکند، بنابراین اگر از معادل عددی یکسان برای مقادیر متفاوت استفاده کنید آن مقادیر یکسان خواهند بود.

نکته: اگر از یک مقدار شمارشی در جایی استفاده شود که انتظار استفاده از یک عدد صحیح میرود، معادل عددی آن استفاده میشود. در دستورات cout و switch هم همینطور است. اما عکس این مطلب درست نیست، یعنی نمیتوان به یک متغیر شمارشی با عدد صحیح مقدار داد مگر اینکه از تبدیل صریح به نوع شمارشی استفاده کنیم.

مثالی برای مطالب گفته شده

کد قالب بندی شده:

Grade gr1 = (Grade)4;

if (gr == A)
cout << "Excellent grade!\n";

if (gr != gr1)
cout << "Different grades\n";
else
cout << "Same grades\n";

gr = B;

switch (gr)
**
case A:
cout << "switch : Excellent\n";
break;

case B:
cout << "switch : Good\n";
break;
**

cout << "B is equivalent to " << B << endl;

توضیح
نوع شمارشی Grade (با سه مقدار) و متغیر gr با مقدار اولیه A از نوع آن تعریف میشوند. مقدار B در تعریف Grade چون صریحاً معادل نگرفته یکی بیش از مقدار A یعنی 4 را میگیرد.

یک دستور if و یک if-esle مقادیر متغیر های شمارشی را آزمایش میکنند.
یک دستور switch بر اساس متغیر شمارشی gr نوشته شده است که مقدار آنرا آزمایش میکند.
عدد معادل B چاپ میشود. enum Grade {A=3, B, C=-1** gr=A; gr1 از نوع Grade تعریف شده و با تبدیل صریح 4 به نوع Grade (که معادل B هست) مقدار اولیه میگیرد.

[صاصائیل]

سلام , اطلاعات من از کامپیوتر درحد ویژوال بیسیک است,آیا برای یادگرفتن
زبان برنامه نویسی ویژوالc++ اول باید ازآموزش برنامه نویسی با ++cاستفاده کنم؟خیلی ممنون.