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

[uody]

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

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

چرا ++C
برای نوشتن کد مورد نظر، ما از یک زبان برنامه نویسی باید استفاده کنیم. زبانهای مختلفی با اهداف گوناگون ساخته شده اند، اما فراگرفتن ++C در این بین این مزیت ها را دارد :

- ++C یک زبان قدرتمند است که میتوانید تقریباً هرکاری که سیستم عامل اجازه دهد با آن انجام دهید.
- یادگیری آن سخت نیست.
- بعداً میتوانید به راحتی با ++Visual C یا #Visual C برنامه نویسی کنید، چراکه قسمت اصلی جریان که کدنویسی است را بلد هستید(کد نویسی با #C بسیار نزدیک به ++C است، چرا که در اصل تغییر یافته ++C برای محیط NET. است).

البته مواردی مانند سرعت اجرای برنامه ها، قابلیت اجرا شدن روی سیستم های مختلف و... را هم دیگر همه شنیده اند! اما آنچه که مهم است اینست که شما با فراگیری آن فقط ++C یاد نمیگیرید، بلکه بعداً براحتی میتوانید برنامه های ویژوال مانند همین برنامه های معمول ویندوز بسازید. مثلاً یکی از جالب ترین کارهایی که با ++C و به کمک ابزارهای موجود میتوانید انجام دهید، ساختن بازی های کامپیوتری است.

درباره Microsoft Visual Studio و MSDN
برای نوشتن و کامپایل و اشکال زدایی برنامه های خود، باید از یک ابزار برنامه نویسی کمک بگیرید. به این ابزار، (IDE (Integrated Development Environment یا محیط یکپارچه(مجتمع) تولید میگویند، چراکه ابزارهای مختلف برای موارد ذکر شده را در خود مجتمع کرده است. ویژوال استودیو که توسط مایکروسافت تولید شده است، یکی از مشهورترین IDE ها است که قابلیت نوشتن برنامه ها در ++C# ، C (سی شارپ) ، ویژوال ++C ، ویژوال بیسیک و #J را میدهد. ما دراین آموزش از Visual Studio 2005 (یا به اختصار VS) استفاده خواهیم کرد.
اما (MSDN (Microsoft Developer Network در اصل راهنمای موجود در ویژوال استودیو است. MSDN هر راهنمایی که برای برنامه نویسی در ویژوال استودیو لازم داشته باشید را در خود دارد : راهنمای دستورات زبان، توابع، نحوه برنامه نویسی، نکات فنی، کدهای نمونه و... . این موارد برای تمام زبانهایی که میتوانید با آنها در VS برنامه نویسی کنید وجود دارند. در حقیقت MSDN تا اینجا تنها راهنمایی است که چنین کامل و جامع است. شما در هر محیطی که بخواهید برنامه نویسی کنید، بازهم میتوانید از راهنمایی MSDN استفاده کنید. وقتی که با آن مواجه شوید، حتماً از اینکه همه چیز را دارد تعجب خواهید کرد! MSDN بدلیل حجم زیاد در اصل جدای از VS ارائه میشود و بعدا میتوانید آن را بعنوان Help به VS اضافه نمایید (شما میتوانید درست بعد از نصب VS هم اینکار را بکنید). اگر بسادگی بخواهیم بگوییم MSDN چیست، همان Help ای است که شما با زدن F1 در هر برنامه دیگری بدست می آورید. شما اصلاً نمیخواهد نگران چیزی باشید، فقط آن را بعد از VS نصب کنید تا بعداً از راهنمایی آن در جای مناسب استفاده کنید. البته MSDN هم قابل دسترسی است، اما وقتی شما میخواهید از آن استفاده کنید، اگر مجبور باشید هربار ده ها صفحه وب را مرور کنید تا به اطلاعات خود برسید، با زحمتی که وصل شدن به اینترنت و آوردن صفحه های وب به ما تحمیل میکند، اصلاً کار عاقلانه ای نیست! فقط وقتی که به جدیدترین اطلاعات نیاز دارید یا چیزی را در نسخه فعلی خود از MSDN نیافتید، بهتر است به سایت MSDN مراجعه کنید. ما در این آموزش از MSDN 2005 استفاده میکنیم. برای کار با MSDN در محیط VS فقط کافی است روی موضوعی که میخواهید درباره اش راهنمایی بگیرید(مثلاً یک دستور که تایپ کرده اید) دکمه F1 را فشار دهید.


VS و MSDN بسته های نرم افزاری هستند، پس آنها را روی DVD یا چندین CD تهیه کنید و براحتی نصب کنید. چگونه در برنامه نویسی استاد شویم
بعد از دنبال کردن هر قسمت از این آموزش، خوب است که هر دستور را آزمایش کنید و تمام امکاناتی که ارائه میدهد را بررسی کنید(با استفاده از MSDN). اما اگر میدانید که یک قطعه کد را بخوبی فهمیده اید، حتماً لازم نیست آنرا امتحان کنید. آنچه که مهم است اینست که خودتان برنامه بنویسید. ابتدا هدف کاری که میخواهید بکنید را مشخص کنید، بعد ببینید چگونه باید این کار را با امکانات ++C انجام دهید و یک طرحی روی کاغذ یا ذهنتان داشته باشید، سپس شروع به کد نویسی و اشکال زدایی کنید(هر قسمت در جای خود شرح داده میشود). در حقیقت هرگاه میخواهید کاری را با کامپیوتر انجام دهید به دنبال پیدا کردن راهی باشید که آن را با ++C انجام دهید و سپس مراحل ذکر شده را دنبال کنید

[uody]

آغاز برنامه نویسی با ++C
برای برنامه نویسی باید کد خود را در یک فایل که فایل منبع نام دارد وارد کنید. در VS برای اینکه آغاز به کد نویسی برای یک برنامه جدید بکنید، باید یک پروژه جدید ایجاد کنید. این پروژه تمام فایل ها و منابع لازم برای ایجاد برنامه مورد نظر را درخود جای میدهد. البته پروژه در یک راه حل (solution) قرار میگیرد، چرا که ممکن است برای یک برنامه چندین پروژه ایجاد کنید که هر قسمت کلی از برنامه در یک پروژه قرار داشته باشد، در این حالت همه پروژه ها را در یک راه حل قرار میدهید. با ساختن اولین پروژه برای برنامه، VS برای آن یک راه حل میسازد، بعداً اگر خواستید میتوانید پروژه های دیگری هم به راه حل خود بیفزایید. هر پروژه روی دیسک سخت در یک فولدر جداگانه قرار میگیرد. شما میتوانید هنگام ایجاد یک پروژه جدید مشخص کنید که آیا برای راه حل هم یک فولدر ایجاد شود یا نه (که فولدر پروژه ها در آن قرارگیرد). اگر میدانید که فقط یک پروژه خواهید داشت میتوانید فولدری برای راه حل درست نکنید، اما اگر چندین پروژه دارید، بهتر است اینکار را بکنید.

حالا میخواهیم اولین پروژه را ایجاد کنیم. بعد از اجرای VS، در منو انتخاب کنید: ...File > New > Project ، پنجره New Project باز میشود. در اینجا انواع پروژه ها بر اساس زبان برنامه نویسی دسته بندی شده اند. به قسمت Visual C++ > Win32 بروید، سپس در قسمت Templates نوع Win32 Console Application را انتخاب کنید. در قسمت :Name بجای <Enter_name> نام پروژه را وارد کنید (در اینجا Test را وارد کنید) و در قسمت :Location محلی که میخواهید فولدر پروژه(با همان نام پروژه) در آنجا ساخته شود را انتخاب کنید. اگر چک باکس Create directory for solution را انتخاب کنید، یک فولدر برای راه حل در مسیری که برای فولدر پروژه مشخص کرده اید ساخته میشود، سپس فولدر پروژه در آن ساخته خواهد شد. در اینجا این چک باکس را انتخاب نکنید، چرا که یک پروژه بیشتر نخواهیم ساخت.

ایجاد پروژه جدید از نوع Win32 Console Application


توجه کنید که پروژه های ++C در شاخه ++Visual C قرار دارند و Win32 پلت فرمی است که ما در آن برنامه مینویسیم. در این پلت فرم ما میتوانیم برنامه های کنسول(console) بسازیم، که خروجی این برنامه ها در command prompt ویندوز نمایش داده خواهد شد. اما اگر مثلاً از نوع MFC برنامه مینوشتیم، برنامه ما مانند هر برنامه دیگری در یک پنجره ویندوز نمایش داده میشد. برای برنامه نویسی با MFC ، باید ابتدا ++C را بلد باشید، سپس از یک آموزش Visual C++ 6 استفاده کنید. خوب برگردیم به ایجاد یک پروژه جدید : حالا دکمه OK را کلیک کنید. در پنجره جدید Next را انتخاب کنید. در قسمت :Application type گزینه Console application را انتخاب کنید. چک باکس Empty Project را انتخاب کنید. دکمه Finish را کلیک کنید. حالا پروژه شما ساخته شده است و میتوانید فایل های لازم را به آن اضافه کنید. از منوی View گزینه Solution Explorer را انتخاب کنید (یا روی تب Solution Explorer در پایین سمت چپ پنجره کلیک کنید). در قاب Solution Explorer فایل های اضافه شده به پروژه را مشاهده میکنید. البته برای دسته بندی کردن، VS چند پوشه را برایتان ایجاد کرده است که در زیر نام پروژه مشاهده میکنید (این پوشه ها مجازی هستند و روی دیسک سخت قرار ندارند). VS به این پوشه ها ---------- میگوید، چرا که انواع فایل را ---------- میکند. شما میتوانید با کلیک راست روی قسمت خالی قاب Solution Explorer و انتخاب Add > New F ilter یک پوشه جدید بسازید. برای کد نویسی حداقل به یک فایل منبع(source) نیاز دارید، برای ایجاد آن روی پوشه Source Files(که فایل های منبع در آن قرار میگیرند) کلیک راست کرده و ...Add > New Item را انتخاب کنید. در قسمت Categories، از شاخه ++Visual C قسمت Code را انتخاب کنید. در قسمت :Templates نوع (C++ File (.cpp را انتخاب کنید و در قسمت :Name نامی برای فایل وارد کنید (در اینجا Test، اما هر نامی میتوانید وارد کنید). دکمه Add را کلیک کنید.

اضافه کردن فایل منبع جدید به پروژه

[uody]

اولین برنامه ++C : تعامل با کاربر

بگذارید پیش از هر چیز یک قطعه کد ساده از ++C را مشاهده کنیم تا قسمت های اصلی آن را شرح دهیم. باید این کد را در فایل منبعی که ساخته اید (Test.cpp) وارد کنید :

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


#include <iostream>
using namespace std;

int main()
**
int number;

cout << "Please enter a number : ";
cin >> number;

cout << "The entered number is : " << number << endl;

system( "pause" ); // shows "Press any key to continue..."
return 0;
**


بعد از وارد کردن این کد، برای ساختن فایل exe از آن، کلید F7 را بزنید (یا از منو انتخاب کنید: Build > Build Solution. اگر میخواهید فقط پروژه جاری ساخته شود، Build ProjectName را انتخاب کنید، که ProjectName نام پروژه است(مثلاً در اینجا Build Test وجود دارد). در حالتی مثل پروژه فعلی که راه حل شما فقط یک پروژه دارد، فرقی ندارد که راه حل را بسازید یا پروژه را، اما اگر چند پروژه داشتیم، با ساختن راه حل، تمام پروژه های آن ساخته میشدند). شما با این کار برنامه خود را می سازید. یعنی برنامه کامپایل میشود، اگر اشتباهی در دستورات شما وجود داشته باشد یا به هر دلیل دیگری کامپایلر موفق به کامپایل برنامه نشود، خطایی تولید خواهد کرد، وگرنه یک فایل میانی از برنامه شما میسازد، سپس آنرا به Linker میدهد تا فایل exe را تولید کند. اگر لینکر نتواند فایل exe تولید کند خطایی نمایش خواهد داد. پیغام هایی که در طی انجام عملیات ساختن برنامه تولید میشوند(که شامل خطاها میشود)، در تب Output، در پایین پنجره اصلی نمایش داده میشوند. اگر ماوس را بر روی عنوان تب Output یک لحظه نگهدارید، خود بخود باز میشود.

تب Output


برای اجرای برنامه کلید های Ctrl + F5 را بزنید، یا از منو انتخاب کنید: Debug > Start Without Debugging. برنامه در یک پنجره Command Prompt نمایش داده میشود.

اجرای برنامه در پنجره Command Prompt


نکته : برای ذخیره کردن تمام محتویات پروژه(فایل ها و تنظیمات و... ) از کلیدهای Ctrl+Shift+S یا از منو : File > Save All استفاده کنید.

اجرای فوری پروژه : قبل از اجرای پروژه اگر تغییری در آن داده باشید باید پروژه را دوباره بسازید، اما اگر میخواهید برنامه را فوراً اجرا کنید و بعد از آخرین تغییرات در پروژه آن را نساخته اید، بازهم میتوانید از Ctrl+F5 برای اجرای آن استفاده کنید. در این حالت سؤال میشود که آیا میخواهید آن را بسازید یا نه، اگر نه را انتخاب کنید، آخرین محصول(فایل exe) ساخت پروژه اجرا خواهد شد و پروژه دوباره ساخته نمیشود.

محل قرار گیری محصول پروژه (فایل اجرایی) در دیسک سخت : اگر پروژه را در حالت اشکال زدایی(debug) ساخته باشید(حالت پیش فرض)، فایل اجرایی در فولدر Debug در فولدر پروژه شما قرار دارد. اما اگر در حالت Release ساخته باشید، در فولدر Release در فولدر پروژه شما قرار دارد. در هردو حالت، اگر یک فولدر جداگانه برای راه حل خود ساخته باشید، فولدرهای مذکور در فولدر راه حل قرار دارند. در مورد حالات debug و release بعداً توضیح خواهیم داد.

گرفتن راهنمایی فوری از MSDN : برای گرفتن راهنمایی MSDN در مورد دستوراتی که در فایل وارد کرده اید، کافی است مکان نمای ورود از طریق صفحه کلید(که بشکل I هست) را بر روی دستور مورد نظر قرار دهید(یعنی فقط در بین یکی از کاراکترهای آن باشد) آنگاه F1 را بزنید (ممکن است MSDN با کمی تأخیر نمایش داده شود). اگر خطایی در هنگام کامپایل رخ دهد، برای گرفتن راهنمایی از MSDN در مورد آن خطا، ابتدا مکان نما را در تب Output روی خطی که عبارت 'error' در آن وجود دارد ببرید، سپس F1 را بزنید. البته در هر قسمتی از VS که باشید، میتوانید با زدن کلید F1 در مورد آن قسمت، از MSDN راهنمایی بگیرید.

باز کردن فوری پروژه : هروقت که VS را اجرا میکنید، تب Start Page نمایش داده میشود، شما میتوانید با کلیک بر روی نام پروژه خود از درون این تب، پروژه را باز نمایید. (توجه کنید که VS بیشتر جاها به 'راه حل' هم 'پروژه' میگوید). اما اگر بخواهید میتوانید در منو File به قسمت Recent Projects بروید، سپس نام پروژه خود را انتخاب کنید. توجه کنید که در هردو روش، فقط چندتا از پروژه هایی که اخیراً باز یا ایجاد کرده اید نمایش داده میشوند، اگر نام پروژه خود را نیافتید باید از منوی File > Open استفاده کنید. پسوند فایل های راه حل، sln میباشد(البته این نکته استفاده ای ندارد!).

[uody]

قالب کلی برنامه نویسی در ++C
برای برنامه نویسی در ++C، شما حداقل به یک فایل منبع نیاز دارید(در اینجا همان test.cpp است) که برای ایجاد فایل اجرایی از پروژه لازم است. البته فایل های دیگری نیز وجود دارند که برای در اختیار گذاشتن منابع لازم برای برنامه نویسی استفاده میشوند. برخی از این فایل ها را برنامه نویس مینویسد و برخی دیگر از قبل آماده اند، که توسط خود زبان ++C در اختیارتان قرار میگیرد یا اینکه افراد دیگر آنها را نوشته اند و شما آنها را مجانی یا با پول تهیه میکنید. در این باره در جای خود توضیح داده خواهد شد. چیزی که در اینجا مهم است، فایل هایی است که خود ++C در اختیارتان میگذارد. برای استفاده از این فایل ها که برخی امکانات برنامه نویسی را در اختیار شما میگذارند، باید از دستور include# استفاده کنید(به دستوراتی که با # شروع میشوند، هدایتگر پیش پردازنده میگویند. پیش پردازنده قبل از کامپایلر یکسری از اعمال مثل همین وارد کردن یک فایل را انجام میدهد). این دستور فایل موردنظر را وارد فایل منبع میکند و شما میتوانید از امکانات آن فایل استفاده کنید. فایل iostream که توسط این دستور در ابتدای کد وارد شده (داریم قطعه کد قبلی را بررسی میکنیم) شامل دستورات ورودی - خروجی است. نام فایل هم این را نشان میدهد : io برای Input Output و stream یعنی جریان. هنگامی که اطلاعات را به منبعی میفرستید یا از آن میگیرید(مثلاً به صفحه مانیتور یا به یک فایل)، جریانی از اطلاعات رد و بدل میشود. در ++C برای ورودی - خروجی روی فایل یا مانیتور از جریان (stream) استفاده میشود.
دستور ;using namespace std مشخص میکند از فضای نام std استفاده شود، وگرنه باید در ابتدای هر نامی که از این فضای نام استفاده میکنید، یک ::std بگذارید، مثلاً بجای cout باید بگذارید std::cout و این خسته کننده خواهد بود، اما اگر زمانی تداخل نام پیش آید مجبور به استفاده از این پیشوند خواهید بود(مثلاً وقتی یک متغیر با همین نام دارید).

قسمتهایی که در هر برنامه ++C وجود دارند:
- هر دستور اجرایی(دستوری که عملی را انجام میدهد) با ; پایان میابد.
- دستورات اجرایی برنامه بین ** و ** در کد زیر باید قرار گیرند (یعنی قطعه کد زیر در تمام برنامه های اجرایی باید قرار داشته باشد). این قطعه کد در اصل تعریف تابع main است (یک تابع مجموعه ای از دستورات است که اعمالی را انجام میدهد).

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



**

return 0;
**

int main()

دستورات برنامه بین ** و دستور return قرار میگیرند. دستور return باعث خاتمه اجرای برنامه میشود و 0 که بعد از آن آمده است، به فراخواننده برنامه ما (سیستم عامل یا برنامه های دیگری) میگوید که برنامه با موفقیت خاتمه یافته است. اما 1 مشخص میکند که خطایی در برنامه رخ داده است. البته return هر مقداری را برگرداند(اصطلاحاً به مقدار بعد از عبارت return گفته میشود 'برگردانده شده' یعنی return یک مقدار را برمیگرداند) معمولاً در خاتمه یافتن برنامه شما اشکالی ایجاد نمیشود، اما فرآیندی(به هر قطعه ای که توسط CPU اجرا میشود، فرآیند میگویند، مثلاً یک فایل اجرایی) که برنامه شما را اجرا کرده است اینطور در نظر خواهد گرفت که برنامه شما مشکلی داشته است.
- عبارت ;("system ("pause را میتوانید در هرجایی از بین دستورات برنامه استفاده کنید. این عبارت سبب میشود که اجرای برنامه شما متوقف شده و منتظر زدن کلیدی از سوی کاربر(کسی که برنامه شما را اجرا میکند) شود و در عین حال عبارت "...Press any key to continue" را نشان میدهد. البته وقتی برنامه را از درون VS اجرا میکنید، دو بار این عبارت را خواهید دید، اما اگر فایل اجرایی برنامه را از درون فولدر پروژه اجرا کنید فقط یکبار مشاهده خواهید کرد، چرا که VS خودش در آخر اجرای برنامه توقف میکند تا برنامه نویس بتواند نتایج را ببیند. بنابراین اگر از این دستور در پایان برنامه استفاده نکنید وقتی کاربر برنامه شما را از طریق فایل exe. اجرا کند برنامه در پایان فوراً خاتمه میابد و کاربر قسمتی از خروجی که برنامه بعد از آن توقف نکرده را نمیبیند.

[uody]

متغیرها
برای نگهداری یک مقدار در حافظه اصلی (RAM) تا بعداً به آن دسترسی داشته باشیم، باید یک متغیر تعریف کنیم. متغیرها انواع مختلفی دلرند که برخی از آنها از ابتدا در زبان وجود دارند، که نوع های بنیادی(fundamental) یا اصلی هستند و در سه گروه کلی جای میگیرند: 1.اعداد صحیح یا کامل مثل: 23، 2.اعداد اعشاری (با مقدار کسری یا همان ممیز شناور) مثل: 23.67، 3.بدون نوع مشخص(void). در جدول زیر انواعی که میتوانید برای تعریف متغیرها استفاده کنید آورده شده است. این جدول یک مرجع است، بنابراین سعی نکنید الآن همه آنرا بفهمید، فقط یکبار بخوانید، بعداً هر نوع درجای خود توضیح داده خواهد شد.

انواع بنیادی زبان


تعریف متغیر
در هرجایی که بخواهید مقداری را درون متغری ذخیره کنید، ابتدا باید متغیر را با نوع مشخصی تعریف(define) کنید، به این عمل معرفی کردن یا declare هم میگویند. شکل دستور تعریف یک متغیر چنین است: ;<نام متغیر> <نوع> . مثلاً برای تعریف متغیر number از نوع int این دستور را مینویسیم: ;int number . میتوان هنگام تعریف، یک مقدار اولیه هم به متغیر داد، که به این عمل مقداردهی اولیه یا initialization گویند: ;23 = int number متغیر number را تعریف و به آن مقدار 23 را میدهد. چندین متغیر از یک نوع را میتوانید در یک دستور تعریف و مقداردهی کنید:
;
int a,b
یا
;int a=0, b=6

در یک دستور، میتوانید چند تا از متغیرها را مقدار دهی اولیه نکنید در حالی که بقیه را مقدار میدهید.

شناسه ها (identifier)
به هر اسمی که معرف یک موجودیت باشد، شناسه میگویند. کلاً دو نوع شناسه داریم : 1.کلمات کلیدی (keyword) و 2.تعریف شده توسط برنامه نویس.


قواعد تعریف شناسه ها






پیشنهاداتی برای نام گذاری شناسه ها :
- از نام هایی استفاده کنید که بعداً از روی آنها به ماهیت شناسه پی ببرید. مثلاً اگر از متغیری برای ذخیره نام یک فرد استفاده میکنید، بهتر است نام متغیر را name بگذارید، نه چیزی مثل a12 . بعضی اوقات مشخص کردن نوع متغیر در نام آن میتواند کمک کننده باشد. مثلاً اگر متغیر num از نوع int است میتوانید بجای num از inum یا i_num استفاده کنید. بعداً بادیدن i در نام متغیر، پی به نوع آن که int است میبرید.

- چون در نام شناسه ها نمیتوان از فاصله استفاده کرد، از زیرخط برای جداکردن قسمت های مختلف یک شناسه استفاده کنید. مثلاً بجای familyname از family_name استفاده کنید. اینکار خوانایی برنامه را بالا میبرد.

- از کاراکتر زیرخط در ابتدای یک شناسه استفاده نکنید. مثلاً number_ نام خوبی نیست، چراکه ++C (یا کامپایلر VS) خودش از یک یا چند زیر خط در ابتدای برخی از کلمات کلیدیش استفاده میکند. مثلاً int32__ یک کلمه کلیدی است. حتی اگر موقعی که برنامه را مینویسید به مشکلی بر نخورید ممکن است بعداً ++C کلمه کلیدی ای هم نام با شناسه شما تعریف کند و آنگاه برنامه شما کامپایل نشود یا نتایج نادرست تولید کند.

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

1.کلمات کلیدی به رنگ آبی نمایش داده میشوند و از قبل در زبان تعریف شده اند و عملکرد خاص خود را دارند. مثلاً int یک کلمه کلیدی است که متغیری از نوع عدد صحیح را تعریف میکند. 2. شناسه هایی که برنامه نویس تعریف میکند، مثل: نام متغیرها، نام توابع و کلاس ها(بعداً توضیح داده خواهند شد) و... . 1. کلمات کلیدی را دوباره نمیتوان تعریف کرد. بنابراین شناسه های کاربر نمیتوانند هم نام با کلمات کلیدی باشند. مثلاً نمیتوان متغیری با نام int تعریف کرد. 2. شناسه ها باید با یک حرف یا یک زیرخط(_) شروع شوند، کاراکترهای بعدی میتواند یک حرف یا عدد یا زیرخط باشد. مثلاً این شناسه ها درستند: number و num_ber1_ و 123__ و حتی خود زیرخط بتنهایی. اما اینها نادرستند: 1number و 123 و 1_2. 3. حروف بزرگ و کوچک در تعریف شناسه تأثیر دارد. یعنی مثلاً number با Number متفاوت است. یک قاعده کلی در ++C :
وجود هر تعداد فاصله یا خط جدید بین عبارات یا قسمت های مجزا از یک عبارت ایرادی ندارد. مثلاً تمام عبارات زیر درستند:

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



int a , b;
int a,
b;

int a,b;

حتی مورد آخر در تعریف چند متغیر از یک نوع میتواند خوانایی برنامه را بالا برد.

[uody]

توضیح درباره انواع متغیرها

بازه مقادیر
هر متغیری در برنامه باید نوعی داشته باشد. این نوع مشخص میکند که متغیر چه مقادیری و از چه نوع را نگهداری میکند. اندازه هر نوع، بازه مقادیری که آن نوع میتواند نگهدارد را مشخص میکند. اما اندازه هر نوع با تعداد بایتی که در حافظه اشغال میکند مشخص میشود. هر بایت 8 بیت است و هر بیت هم میتواند 0 یا 1 باشد. بنابراین هر بیت دو حالت دارد. میدانید که اگر دو چیز که هرکدام دو حالت مختلف دارند را در کنار هم یک چیز در نظر بگیریم، حالا این چیز واحد که در اصل دو واحد مجزا دارد، 4 حالت مختلف دارد(از ضرب حالات واحدهای مجزا که 2x2 میشود 4). در اینجا هم یک بایت از واحدهای مجزا که بیت ها هستند تشکیل شده و هر بیت دوحالت دارد، حالا چون هر بایت 8 بیت دارد، پس برای مشخص کردن تمام حالات یک بایت باید 8 تا 2 را در هم ضرب کنیم(یا همان 2 بتوان 8) که میشود 256. پس هر بایت 256 حالت مختلف دارد و چون هر حالت در کامپیوتر معادل یک عدد مشخص است، پس یک بایت یکی از 256 عدد مختلف را میتواند نگهدارد. این اعداد از صفر تا 255 خواهند بود. پس ما خودمان مقادیری که یک بایت میتواند نگهدارد را حساب کردیم(کلاً بخاطر داشته باشید این مقدار میشود: 2 بتوان تعداد بیت ها). اگر اعداد منفی را بحساب بیاوریم، بحث اعداد علامت دار پیش می آید. ++C از روش 'مکمل دو' برای ذخیره اعداد علامت دار استفاده میکند. لازم نیست از چگونگی این روش اطلاع داشته باشید، چرا که حساب کردن بازه مقادیر خیلی راحت است. مثلاً در حالت قبل حساب کردیم که هربایت 256 عدد را نگه میدارد، حالا فقط کافی است 256 را به دو تقسیم کنیم که میشود 128. بسادگی بازه مقادیر خواهد بود: 128- تا 127. در کل بخاطر داشته باشید که هر نوعی اگر بخواهد مقادیر منفی را هم ذخیره کند، نصف کل مقادیری که ذخیره میکند را میتواند عدد منفی نگهدارد و نصف دیگر عدد مثبت(البته 0 را هم شامل میشود بهمین خاطر این مقدار یکی کمتر از مقادیر منفی است، یعنی 127 در مقابل 128). دانستن اینکه هر متغیر چه مقادیری را نگه میدارد، معمولاً موردنیاز نیست، بنابراین هرجا خواستید بدانید، میتوانید به جدول مرجعی که در زیر می آید مراجعه کنید. در جدول شما به کلمات signed(با علامت) و unsigned(بدون علامت) برمیخورید، اینها کلمات کلیدی هستند که مشخص میکنند آیا یک نوع مقادیر منفی را هم نگه میدارد یا نه.

قبلاً در جدول 'انواع بنیادی زبان' انواع مختلف را آوردیم، حالا مقادیری که هر نوع بنیادی میتواند نگهدارد را می آوریم:

بازه مقادیر انواع بنیادی

توضیح: 'نام دیگر' یعنی معادل، بنابراین بجای int دقیقاً میتوانید بنویسید signed.

توضیح انواع بنیادی
(ممکن است به عبارت ثابت لفظی(literal constant) برخورد کنید. یک لیترال(literal) ثابتی است که اسم آن همان مقدار آن باشد، مثل عدد 23 یا کاراکتر 'A' و...).

int
اعداد صحیح(کامل) را نگه میدارد. پیشوندهای short و long فقط بازه مقادیری که int نگه میدارد را تغییر میدهند. معمولاً از int استفاده میشود اما درجاهایی که مقدار فضای مصرفی برنامه مهم است، از short استفاده کنید، هرجا هم که میخواهید مقادیری فراتر از بازه مقادیر int را ذخیره کنید، از int64__ استفاده کنید. کلمات کلیدی intn__ خاص مایکروسافت هستند، بنابراین اگر از این انواع استفاده کنید، در کامپایلری که این انواع را نداشته باشد، کد شما خطا خواهد داد.
میتوانید مقادیر لیترال مبنای شانزده را در کد خود وارد کنید، به فرم: عدد0x مثلاً اگر number یک عدد int باشد، number = 0x10 معادل number = 16 هست، چراکه 10 در مبنای شانزده برابر 16 در مبنای ده است.

bool
مخفف نام boolean است که میتواند مقدار true(درست) یا false(نادرست) داشته باشد(true و false کلمات کلیدی هستند). معمولاً در تبدیل اعداد، عدد صفر 'نادرست' و اعداد غیر صفر، 'درست' در نظر گرفته میشوند.

char
کاراکتر به یک نشانه میگویند که در مجموعه کاراکترهای زمان اجرا وجود دارد. مثلاً 'a' یک نشانه یا کاراکتر است(در ++C هر کاراکتر منفرد در دوتا ' قرار میگیرد). این مجموعه کاراکترها برای ++ASCII ، Microsoft C هست. مجموعه کاراکترهای اسکی(ASCII) را میتوانید در MSDN مشاهده کنید(در قسمت ASCII character set). چون هر char یک بایت فضا میگیرد و 256 حالت دارد، بنابراین یکی از 256 کاراکتر مختلف را میتوان در آن نگهداری کرد. وقتی که مجموعه کاراکترها را در MSDN میبینید(مثلاً در قسمت 127-0)، هرکدام یک عدد در زیر ستون Dec دارند، در حقیقت مقدار هر کاراکتر یک عدد است. مثلاً کاراکتر A را در نظر بگیرید، اگر در ستون Dec مقدار آن 65 است. این یعنی وقتی A را بصورت عدد استفاده کنیم 65 هست و وقتی نمایش کاراکتری آن را داشته باشیم، A خواهد بود(در اصل وقتی A در حافظه بخواهد ذخیره شود، عدد 65 در یک بایت بعنوان A ذخیره میشود، که آن عدد خود بصورت یک عدد دودویی ذخیره میشود، چون در نهایت هرچیزی در حافظه کامپیوتر بصورت یک سری ارقام دودویی که یا صفر هستند یا یک، ذخیره میشود). البته این موضوع بعداً در کاربرد روشنتر خواهد شد. اما از اینجا این را درنظر داشته باشید که هر کاراکتر متناظر با یک عدد است(که به آن کد کاراکتر هم میگویند، که البته با ستون Code در MSDN متفاوت است).

wchar_t
همانطور که مجموعه کاراکتری ASCII وجود دارد، مجموعه های دیگری هم وجود دارند. زمانی که ASCII را تعریف کردند فقط یکسری از علایم بعلاوه حروف و اعداد انگلیسی را در آن در نظر گرفتند(همانطور که در MSDN میبینید). البته بیش از این هم جا نداشت! چرا که فقط یک بایت با 256 حالت در اختیار داشت. اما بعداً با رواج اینترنت و همچنین تلاش برای تولید نرم افزارهایی با پشتیبانی چندین زبان، نیاز به یکسری کد برای کاراکتر های سایر زبان ها احساس شد. چون ASCII قابل گسترش در یک بایت نبود، یک مجموعه کاراکتری جدید با دو بایت فضا ایجاد کردند و نامش را Unicode گذاشتند(که از Universal code (کد جهانی) می آید، چرا که برای داشتن تمام کدهای کاراکتری لازم در تمام جهان ابداع شد). wchar_t (یا همان wchar_t__) برای در برداشتن کاراکترهای یونی کد(Unicode) به ++C اضافه شده است. بنابراین مثلاً برای استفاده از کاراکترهای فارسی، از این نوع استفاده کنید.

enum
مخفف enumeration در انگلیسی است، که 'شمارشی' ترجمه میشود. این نوع را درجای خود توضیح خواهیم داد.

float و double
انواعی برای ذخیره اعداد اعشاری با ممیز شناورند. مثلاً عددی مثل: 123.456. تفاوتشان در اندازه شان هست، اندازه double دو برابر float میباشد. شما برای مشخص کردن ثابت هایی از نوع اعشاری، میتوانید از نماد علمی هم استفاده کنید، مثلاً برای ده بتوان 3- بنویسید: 10e-3 که e نماینده توان است(بزرگ و کوچک بودنش فرقی ندارد، اما باید بدون فاصله بنویسید)، یا مثلاً 1508E+30(که همان 1508E30 هست).

تعیین اندازه یک نوع یا متغیری از آن نوع
اگر میخواهید بدانید که یک نوع در کامپیوتری که برنامه شما اجرا میشود چند بایت است، یک عملگر که کلمه کلیدی هم هست، در ++C وجود دارد به نام sizeof. مثلاً (sizeof(int اندازه یک int را برمیگرداند، یا مثلاً اگر متغیر number داشته باشید، (sizeof(number اندازه number را برمیگرداند(وقتی sizeof را بر روی یک متغیر اعمال میکنید، میتوانید پرانتزها را نگذارید و بنویسید: sizeof number). این عملگر را برای نوع void نمیتوانید بکاربرید، و هیچ گاه مقدار 0 برنمی گرداند.

[uody]

دستورات cout و cin
این دستورات برای ورودی-خروجی استفاده میشوند. خروجی روی مانیتور هست و ورودی را از صفحه کلید توسط کاربر دریافت میکند. توجه کنید که اینها دراصل دستور نیستند. فقط اشیاءی از نوع کلی stream هستند.

cout
برای خروجی روی مانیتور استفاده میشود. شکل استفاده از آن چنین است:
;endl >> نام متغیر >> "پیغام" >> cout
این یک شکل کلی است که نشان میدهد ابتدا یک پیغام روی مانیتور چاپ شود، بعد مقدار یک متغیر و در انتها به سطر بعدی منتقل شود. endl که از end of line آمده است، به معنی آخر خط میباشد و مکان نما(یعنی خط فاصله چشمک زن در پنجره خروجی، که محل قرارگیری کاراکتر بعدی را نشان میدهد و به آن cursor میگویند) را به ابتدای سطر بعد میبرد.

cin
برای در یافت ورودی از سوی کابر استفاده میشود. مقدار دریافتی در متغیری که در دستور مشخص شده نگهداری خواهد شد. شکل کلی دستور:
;نام متغیر << نام متغیر << cin
هر تعداد متغیر که بخواهید میتوانید در دستور cin وارد کنید.

چند مثال و نکته
ابتدا به قطعه کد قسمت 'اولین برنامه ++C' که قبلاً ارائه دادیم برگردید و کاربرد دستورات cin , cout را مشاهده کنید. حالا به مثال دیگری توجه کنید:

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


#include <iostream>
using namespace std;

/*
It's a multiple line comment,
you can write your comments in more than one line
*/

int main()
**
int num1,
num2;

cout << "Please enter two numbers : "; // it's a one line comment
cin >> num1 >> num2;
cout << "The entered numbers are : " << num1 << " and " << num2 << endl;

cout << "Size of int in this computer is : " << sizeof(int) << endl;

cout << "It's in the first line\nIt's in the second one\n";

system( "pause" );
return 0;
**


خروجی:

CMD_Window.jpg (اندازه: 17.4 KB / دانلودها: 176)

تحلیل:
توضیحات (comments)
هرجایی از کد(خارج از یک رشته کاراکتری) میتوانید بعد از دوتا \ یک توضیح بیاورید، یعنی مثلاً در آخر یک دستور توضیح دهید که هدف از این دستور چیست. کامپایلر توضیحات را نادیده میگیرد، یعنی انگار که وجود ندارند. \\ یک توضیح یک خطی را فراهم میکند، برای وارد کردن یک توضیح در چند خط، بجای استفاده از \\ در ابتدای هر توضیح در هر خط، میتوانید در ابتدای توضیحات *\ را وارد کنید و در انتهایش(که ممکن است چند خط بعد باشد) \* را وارد کنید.

تحلیل عملکرد برنامه
ابتدا دو عدد num1 و num2 را تعریف کرده ایم. بعد با چاپ یک پیغام از کابر درخواست میکنیم که دو عدد را وارد کند. با دستور cin منتظر دریافت اعداد میشویم. در اینجا کاربر باید یک عدد را وارد کرده و سپس یک یا چندبار کلید space را بزند تا چند کاراکتر جای خالی(white space) ایجاد شود (یعنی بین اعداد فاصله بیفتد)، آنگاه عدد دیگر را وارد کرده و کلید Enter را بزند. حتی کاربر میتواند بین وارد کردن دوعدد، فقط کلید Enter را بزند(بجای space). سپس برنامه پیغامی میدهد و اعداد دریافت شده را چاپ میکند. دستور بعد اندازه یک int را برحسب تعداد بایت چاپ میکند. دستور بعد در دو سطر چاپ میشود، با اینکه از endl استفاده نکرده ایم. این عمل با استفاده از 'n\' در پیغام، انجام شده است. اما در ++C کاراکترهایی که بعد از \ در یک رشته کاراکتری(یعنی همان پیغام) می آیند، معنای خاصی میدهند. تمام اینها یک کاراکتر تنها هستند، مثلاً 'n\' یک کاراکتر است، بهمین خاطر میتوانیم آنرا در دوتا ' بگذاریم(چرا که اگر رشته کاراکتری بود باید در دوتا " میگذاشتیم). یعنی در هر جای یک رشته(یعنی همان رشته کاراکتری) که تایپ کنید n\ بعد از چاپ شدن یک سطر جدید تولید خواهد کرد. حتی میتوانید به تنهایی به جای endl بنویسید 'n\' و بعد از اجرای برنامه یک خط جدید در خروجی خواهید داشت.
غیر از 'n\' کاراکترهای ویژه دیگری هم داریم که در زیر آورده شده اند و استفاده آنها درست مانند 'n\' میباشد. در این کاربرد، به کاراکتر \ میگویند escape character و به این کاراکترهای ویژه escape sequence میگویند.




\\ : یک کاراکتر \ را چاپ میکند.
'\ : یک کاراکتر ' را چاپ میکند (البته برای ' نیازی به \ نیست).
"\ : یک کاراکتر " را چاپ میکند.


هرکدام از اینها را در چاپ یک رشته امتحان کنید. t\ : مکان نما را به اندازه یک تب جلو میبرد(یعنی مانند آنکه یکبار دکمه تب در کامپیوتر کاربر زده شود). r\ : مکان نما را به ابتدای سطر فعلی میبرد. به این عمل carriage return گویند. a\ : بوق(alert) سیستم را بصدا درمی آورد. b\ : آخرین کاراکتر را از خروجی حذف میکند(معادل backspace).

[uody]

آرایه ها
وقتی نیاز به چندین متغیر با یک نوع و مرتبط به یک موضوع دارید، از آرایه استفاده کنید. یک آرایه فقط مجموعه ای از متغیرهای همنوع است، مثلاً آرایه ای از int ها:
;[int iarray[5 یک آرایه با ظرفیت 5 عدد صحیح با نام iarray ادعا میکند. مثلاً میتوانید نمره های 5 دانش آموز را بجای نگهداری در پنج متغیر جداگانه، در عناصر این آرایه نگهدارید. برای مقدار دهی به یک عنصر آرایه: ;23 = [iarray[0 به عنصر اول آرایه مقدار 23 رامیدهد. همچنین برای دسترسی به مقدار عنصر اول از [iarray[0 استفاده کنید. اندیس(عدد درون کروشه ها) عناصر آرایه از صفر شروع میشود تا یکی کمتر از تعداد عناصر آرایه، پس آخرین عنصر با [iarray[4 در دسترس قرار میگیرد. آرایه iarray فقط یک بعد دارد، اما میتوان آرایه هایی با ابعاد بیشتر هم داشت. اگر آرایه یک بعدی را مجموعه ای از جعبه ها در نظر بگیرید، آرایه دو بعدی میشود جعبه هایی که درون آنها جعبه های دیگری وجود دارد. یک آرایه دو بعدی: ;[4][int iarray2[3 یک آرایه را تعریف میکند که بعد اول آن اندازه 3 و بعد دوم آن اندازه 2 دارد. یعنی 3 جعبه که در هر کدام 2 جعبه دیگر قرار دارد.
آرایه سه بعدی ;[2][5][int iarray3[4 اندازه بعد سوم آن 2 است.


میتوان گفت، آرایه یک بعدی مجموعه ای از متغیرهای ساده، آرایه دو بعدی مجموعه ای از آرایه های یک بعدی، آرایه سه بعدی مجموعه ای از آرایه های دوبعدی است. آرایه های با اندیس های بالاتر بندرت استفاده میشوند.

مقداردهی اولیه به آرایه ها
برای آرایه یک بعدی: ;{1,2** = [int ar[2 به عنصر اول مقدار 1 و به دوم 2 میدهد. برای آرایه دو بعدی: ;**{3,4**,{1,2**** = [2][int ar[2 ، آکولاد بازوبسته درونی اول برای سطر اول و دومی برای سطر دوم است (البته آکولادهای درونی اختیاری هستند، اما برای خوانایی بیشتر بهتر است بگذارید) یعنی {1,2** به سطر اول مقدار میدهد، طوریکه به ستون اول مقدار 1 و به ستون دوم مقدار 2 میدهد.
برای آرایه سه بعدی: ;** **{7,8**,{5,6**** , **{3,4**,{1,2**** ** = [2][2][int ar[2 قسمت **{3,4**,{1,2**** به سطر اول مقدارمیدهد، طوریکه {1,2** به ستون اول آن مقدار میدهد، طوریکه 1 برای عمق اول آن و 2 برای عمق دوم قرار میگیرد. مثلاً [ar[1][0][1 مقدار 6 را میدهد، چراکه در سطر دوم(**{7,8**,{5,6****) در ستون اول({5,6**) مقدار عمق دوم را برمیگرداند. اگر عمق اول را مشخص کرده بودیم([ar[1][0][0) پنج میداد، یا اگر سطر اول را مشخص کرده بودیم ([ar[0][0][1) دو میداد. البته مقدار اولیه دهی به آرایه های سه بعدی کمتر پیش می آید.
اگر در مقدار دهی اولیه آرایه، به یک عنصر از آن مقدار ندهید کامپایلر به آن مقدار صفر میدهد، مثلاً در ;**{1,2**** = [2][int ar[2 هر دو ستون سطر دوم مقدار صفر میگیرند. اگر میخواهید به تمام مقادیر آرایه مقدار صفر دهید، آرایه را هنگام تعریف برابر **** قرار دهید، مثلاً بنویسید : ;**** = [2][2][int ar[2

نکته: مقداردهی اولیه آرایه فقط در هنگام تعریف آرایه امکان پذیر است.

نکته: در مقدار دهی اولیه به یک آرایه میتوانید اندازه بعد اول را مشخص نکنید و کامپایلر خود با توجه به تعداد مقادیر اولیه ای که فراهم آورده اید اندازه آنرا تعیین میکند. اما اندازه سایر ابعاد را همیشه باید مشخص کنید. مثلاً: ;**{int ar[][2] = **{1,2**,{3,4

تعیین تعداد عناصر یک آرایه
اگر مثلاً [int ar[2][3 را داشته باشیم، عبارت (sizeof(ar مقدار 24 را میدهد که اندازه کل آرایه است، چراکه 2x3 یا 6 تا عنصر از نوع int دارد، و چون هر int چهار بایت میگیرد، پس 6x4 یا 24 بایت کل آرایه میگیرد. پس ما اندازه کل آرایه را داریم و اندازه هر عنصر میشود (sizeof(int چراکه نوع هر عنصر int است، در نهایت (sizeof(ar) / sizeof(int اندازه کل آرایه را به اندازه هر عنصر آن تقسیم میکند و تعداد عناصر آرایه را میدهد (/ عمل تقسیم را انجام میدهد).

مثالی برای استفاده از آرایه ها

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


#include <iostream>
using namespace std;

int main()
**
int ar[2][3] = {1**;

cout << "Enter a number : ";
cin >> ar[1][2];
cout << "Your number is : " << ar[1][2] << endl;

cout << "\n\nElement in first row and first column of the array is : " << ar[0][0]
<< "\nand for the second column : " << ar[0][1];

cout << "\n\nNumber of elements in the array is : " << sizeof(ar) / sizeof(int) << endl;

system("pause");
return 0;
**


خروجی


تحلیل
برنامه ابتدا عددی را از کاربر در عنصر[2] [1] از آرایه ar میگیرد (یعنی در عنصر سطر دوم-ستون سوم از آرایه مقدار دریافتی از کاربر قرار میگیرد)، سپس آنرا چاپ میکند. سپس عناصر [0][0] و [1][0] را نمایش میدهد که اولی مقدار 1 دارد چون مقداردهی اولیه شده، و دومی مقدار 0 چون مقداردهی اولیه نشده. در آخر نیز تعداد عناصر آرایه نمایش داده میشود.
__________________

[uody]

رشته های کاراکتری
یک مجموعه از کاراکترها را یک رشته کاراکتری(یا بطور خلاصه 'رشته' یا string) میگویند. مثلاً "This is a string" یک نمونه از رشته هاست. یک ثابت رشته ای همیشه در دوتا " قرارمیگیرد. اما ما دونوع رشته داریم: 1.مجموعه ای از char ها(که به رشته های سبک C-style) C) (منظور زبان C است) هم معروف اند) 2.از نوع کلاس string

رشته های سبک C
رشته های اصلی ++C هستند. برای این به فرمت C مشهورند که قبل از ++C در C وجود داشتند. این رشته ها در اصل آرایه ای از کاراکترها هستند. مثلاً رشته "char str[7] = "String ، که از 6 کاراکتر بعلاوه کاراکتر پایان رشته(که خود کامپایلر اضافه میکند) تشکیل شده و در هنگام تعریف مقدار اولیه گرفته است.

کاراکتر پایان رشته که به آن کاراکتر پوچ پایان دهنده (terminating null character) هم میگویند، در اصل یک کاراکتر است که وقتی چاپ شود یک فاصله چاپ خواهد شد(البته کاراکتر فاصله چیز دیگری است و کد اسکی آن 32 است)، و نام اصلی آن کاراکتر پوچ (null) است که در اینجا برای مشخص کردن پایان یک رشته از آن استفاده میشود. کد اسکی آن 0 است و بصورت کاراکتری '0\' نوشته میشود، بنابراین از کاراکتر '0' که کداسکی 48 دارد و یک 0 چاپ میشود متمایز میگردد. پس هر جایی که این کاراکتر در یک رشته قرار گیرد پایان آنرا مشخص میکند(حتی اگر بعد از آن کاراکترهای دیگری قرار داشته باشند) و در اعمال مختلفی که روی رشته انجام میشود معیار پایان آن قرار میگیرد. مثلاً وقتی یک رشته را با دستور cout << str چاپ کنید، فقط تا قبل از کاراکتر پوچی که در رشته قرار دارد چاپ میشود.

هر ثابت رشته ای که در بین دوتا " قرار میگیرد شامل یک '0\' هم در پایان خود هست، هرچند که شما چنین چیزی را مشخص نمیکنید، بنابراین وقتی با دستور "char str[7] = "String یک رشته را تعریف میکنید، کاراکتر هفتم آن '0\' قرار میگیرد (و مثلاً کاراکتر ششم g هست).
روش دیگر برای مقدار دهی یک آرایه کاراکتری(که در اصل نمایشگر یک رشته است) استفاده از مقداردهی هر کاراکتر بطور جداگانه است، مثلاً **'0\','char str[7] = **'S','t','r','i','n','g که همان String را نمایش میدهد، اما چون خودمان هر کاراکتر را مشخص کرده ایم، باید '0\' را هم مشخص کنیم.

برای مقدار دهی اولیه تهی('0\') به تمام اعضای یک آرایه کاراکتری میتوانید از عبارت **'char str[7] = **'\0 استفاده کنید، یا اینکه بجای '0\' بگذارید 0 چراکه همانطور که میدانید میتوان بجای نوشتن یک کاراکتر بین دوتا ' کد اسکی آنرا نوشت.

برای دریافت یک رشته از کاربر، اگر مثلاً [char str[7 را تعریف کرده باشیم، دستور cin >> str یک رشته را از کاربر دریافت میکند. البته باید تعداد کاراکترهای رشته ای که کاربر وارد میکند از طول آرایه کاراکتری ما کمتر باشد، یعنی برای str فقط 6 کاراکتر را از کاربر میتوان دریافت کرد(چرا که کاراکتر آخر را برای '0\' نگه میداریم و دستور cin بعد از دریافت رشته از سوی کاربر هفتمین کاراکتر را '0\' خواهد گذاشت). البته کاربر میتواند کمتر از 6 کاراکتر هم وارد کند، مثلاً اگر 3 تا وارد کند، کاراکتر چهارم مقدار '0\' خواهد گرفت و کاراکترهای پنجم تا هفتم تغییری نخواهند کرد.

اما اگر میخواهید با این مشکل مواجه نشوید که کاربر تعداد بیشتری کاراکتر وارد کند و برنامه شما هنگ کند، از دستور ;('cin.getline(str,4,'y استفاده کنید، که با استفاده از تابع getline یک ورودی به طول 4(با حساب کردن '0\') را از کاربر میگیرد و در str قرار میدهد، اگر زودتر از آن به کاراکتر y برسد، تا قبل از آن را در str قرار میدهد (در اصل y در اینجا حائل(delimiter) است). هریک از str و 4 و y یک آرگومان تابع getline هستند که شما میتوانید بجای آنها هرچیز دیگری از همان نوع بگذارید. اما مقداری که برای آرگومان دوم(4) در نظر میگیرید، باید با حساب کردن '0\' حداکثر برابر طول آرایه ای که در آرگومان اول مشخص میکنید باشد. یعنی اگر طول آرایه شما 7 هست، حداکثر 7 را میتوانید برای آرگومان دوم در نظر بگیرید و getline شش کاراکتر را از ورودی گرفته و در str قرار میدهد و کاراکتر هفتم را '0\' میگذارد.چنانچه کاربر کاراکتر های بیشتری وارد کند، اگر بعداً دستورات ورودی بیشتری در برنامه داشته باشیم، این کاراکترها را دریافت خواهند کرد، یعنی هیچ وقت ورودی های کاربر از بین نمیروند و در بافر ورودی قرارمیگیرند تا اینکه با یک دستور ورودی خوانده شوند یا با دستوری دیگر یا رسیدن به انتهای برنامه حذف شوند.


یکی از مزیت های getline به cin در دریافت رشته ها: getline رشته ای که بین آن فاصله وجود دارد را هم یکجا میگیرد، اما cin همیشه تاجایی که کاربر یک کاراکتر فاصله وارد کرده است میخواند. بنابراین getline میتواند کل 34 12 را با یک دستور بخواند، اما cin در هر بار فقط یک قسمت را میخواند، اول 12 وبعد 34 را دریافت میکند.

توجه: 'توابع مفید برای کار برروی رشته ها' و 'رشته های نوع string' بعد از توضیح توابع در قسمت های بعدی آورده خواهند شد. getline یک نمونه دو پارامتری هم دارد، مثلاً مثال قبل را میتوانید اینگونه بنویسید: (cin.getline(str,4 با این دستور کاراکترها تا جایی از کاربر دریافت میشوند که کلید Enter زده شده باشد یا اینکه به حد 3 کاراکتر رسیده باشند(این نمونه از دستور مشابه ('cin.getline(str,4,'\n هست، چراکه فشاردادن کلید Enter مقدار 'n\' را تولید میکند). این شکل از دستور برای زمانی مناسب است که یک حداکثری برای اندازه ورودی کاربر در نظر گرفته ایم اما حداقلی در نظر نداریم.

[uody]

عملگرها
به هر مجموعه ای از کاراکترها که بتواند بین یا قبل از دو مقدار یا متغیر قرارگیرد و عملی روی آنها(یا با استفاده از آنها) انجام داده و بطور اختیاری مقداری برگرداند، یک عملگر میگویند. مثلاً + یک عملگر است(عملگر جمع) که از یک کاراکتر '+' تشکیل شده، بین دو مقدار یا متغیر قرار میگیرد، عمل جمع را با استفاده از آنها انجام داده و مجموع آنها را برمیگرداند.

به مقادیر یا متغیرهایی که عملگر بین یا قبل و بعد از آنها قرار میگیرد و عملی را با آنها انجام میدهد، عملوند میگویند. مثلاً در 4 + 5 اعداد 5 و 4 عملوندهای عملگر جمع هستند، پس عملگر جمع دو عملوند دارد(میگیرد).

به عملگرهایی که فقط یک عملوند دارند یگانی(unary) میگویند. مثلاً عملگر جمعی که یک عملگر بگیرد هم داریم، که در اصل استفاده ای ندارد، چراکه مثلاً 2+ و 2 یکی هستند(اما عملگر یگانی منفی کاربرد برگرداندن مقدار منفی را دارد). عملگرهایی که دو عملوند میگیرند را دوتایی(binary) میگویند، مثل عملوند تفریق(-). عملوندهایی که سه تا عملوند میگیرند را سه تایی(ternary) میگویند، مثل عملگر انتخاب(:?). بعداً خواهید دید که رفتار عملگرها را میتوانید تغییر دهید.

عملگرهای حسابی
جمع : + ، تفریق(منفی) : - ، ضرب : * ، تقسیم : / ، باقیمانده : %

عملگر منفی یک عملوند میگیرد و منفی آنرا برمیگرداند، مثلاً 2- عدد 2 را منفی میکند.

عملگر / خارج قسمت تقسیم عملوند چپ به راستش را میدهد. اما میگوییم 'تقسیم صحیح' چراکه بعد از تقسیم دو عدد ممکن است باقیمانده ای ایجاد شود، میدانید که اگر تقسیم را ادامه دهیم باید در خارج قسمت ممیز قرار دهیم و جلو رویم، در آخر دیگر خارج قسمت یک عدد 'صحیح' نخواهد بود(اعشاری میشود). مثلاً خارج قسمت تقسیم 7 بر 2 ، 3.5 میشود، اما اگر خارج قسمت را صحیح در نظر بگیریم(یعنی قسمت اعشاری را در نظر نگیریم) میشود 3. در ++C هم عملگر تقسیم خارج قسمت را بصورت یک عدد صحیح میدهد، در نتیجه حاصل 7/2 میشود 3.

عملگر % باقیمانده تقسیم عملوند سمت چپ بر راستش را میدهد، مثلاً حاصل 2%7 میشود 1 چون باقیمانده تقسیم 7 بر 2 یک میشود.

اولویت عملگرها (Operator Precedence)
وقتی عبارتی شامل چندین عملگر را مینویسید، هر عملگر کی محاسبه میشود؟ مثال مشهور ریاضی آن 4*3+2 است، که اگر اول 2 با 3 جمع شود(5) و بعد در 4 ضرب(*) شود، حاصل 20 میشود، اما اگر اول 3 در 4 ضرب(12) و بعد با 2 جمع شود، حاصل 14 میشود، و 20 با 14 مساوی نیست! بنابراین اینکه حاصل کدام عملگر ابتدا محاسبه شود شاید در نتیجه عبارت تأثیرگذار باشد. پس در برنامه نویسی(مثل ریاضی) عملگرها اولویت گذاری شده اند. بنابراین مثلاً عملگر ضرب زودتر از جمع محاسبه میشود.

اولویت عملگرهای حسابی
هر دسته که در یک آکولاد قرار دارند اولویت یکسان دارند و از راست به چپ اولویت کم میشود:
{منفی و مثبت یگانی** {ضرب و تقسیم و باقیمانده** {جمع و تفریق**

شرکت پذیری عملگرها (Operator Associativity)
اگر در یک عبارت چندین عملگر که اولویت یکسان دارند داشته باشیم(مثلاً چندین جمع و تفریق)، حالا هرکدام کی محاسبه میشوند؟ اینجا شرکت پذیری مهم میشود. شرکت پذیری دو حالت دارد : راست به چپ و چپ به راست. مثلاً + چپ به راست شرکت پذیر است. یعنی اینکه ابتدا چپ ترین جمع حساب میشود، سپس سمت راست آن و بترتیب تا راست ترین جمع. مثلاً در 4+3+2 ابتدا 2 با 3 جمع میشود و حاصل با 4 جمع میشود. البته دراینجا شرکت پذیری در نتیجه تأثیری نمیگذارد، اما در برخی عبارات حاصل را تغییر میدهد.

شرکت پذیری عملگرهای حسابی
چپ به راست: ضرب ، تقسیم ، باقیمانده ، جمع ، تفریق
راست به چپ: منفی و مثبت یگانی

در ++C اولویت و شرکت پذیری عملگرها مشخص شده است. میتوانید آنها را در قسمت Operator Precedence and Associativity از MSDN مشاهده کنید.

عملگر پرانتز که همیشه شامل یک پرانتز باز یا ) و یک بسته یا ( میشود، میتواند ابهام و دردسرهای محاسبه حاصل یک عبارت را برطرف کند. چراکه همیشه محاسبات از درونی ترین پرانتز شروع و به بیرونی ترین ختم میشود. مثلاً با داشتن (4*3)+2 دقیقاً میدانیم که ابتدا باید ضرب و بعد از آن جمع انجام شود. اما 4*(3+2) نشان میدهد که ابتدا جمع و سپس ضرب انجام میشود.

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

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

[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استفاده کنم؟خیلی ممنون.

[NameEly]

سلام به دوست گلم :
ميشه منظورتون رو واضح تر بگين ؟
++c زباني هست شبيه java و c و #C ولي با دلفي تفاوت داره
شما ++c رو ياد داشته باشيد ويژال رو هم ياد داريد چون فقط بعضي از دستور هاش تفاوت داره

[صاصائیل]

سلام دوست عزیز/میخوام بدونم بهترین زبان بعدازیادگرفتن ویژول بیسیک چه زبان برنامه نویسی
مشابه به این زبان است و مزایایش چیست؟من مدرک ویژوال رو از فنی حرفه ای گرفتم.

[صاصائیل]

اولین برنامه ++c : تعامل با کاربر

بگذارید پیش از هر چیز یک قطعه کد ساده از ++c را مشاهده کنیم تا قسمت های اصلی آن را شرح دهیم. باید این کد را در فایل منبعی که ساخته اید (test.cpp) وارد کنید :

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


#include <iostream>
using namespace std;

int main()
**
int number;

cout << "please enter a number : ";
cin >> number;

cout << "the entered number is : " << number << endl;

system( "pause" ); // shows "press any key to continue..."
return 0;
**


بعد از وارد کردن این کد، برای ساختن فایل exe از آن، کلید f7 را بزنید (یا از منو انتخاب کنید: Build > build solution. اگر میخواهید فقط پروژه جاری ساخته شود، build projectname را انتخاب کنید، که projectname نام پروژه است(مثلاً در اینجا build test وجود دارد). در حالتی مثل پروژه فعلی که راه حل شما فقط یک پروژه دارد، فرقی ندارد که راه حل را بسازید یا پروژه را، اما اگر چند پروژه داشتیم، با ساختن راه حل، تمام پروژه های آن ساخته میشدند). شما با این کار برنامه خود را می سازید. یعنی برنامه کامپایل میشود، اگر اشتباهی در دستورات شما وجود داشته باشد یا به هر دلیل دیگری کامپایلر موفق به کامپایل برنامه نشود، خطایی تولید خواهد کرد، وگرنه یک فایل میانی از برنامه شما میسازد، سپس آنرا به linker میدهد تا فایل exe را تولید کند. اگر لینکر نتواند فایل exe تولید کند خطایی نمایش خواهد داد. پیغام هایی که در طی انجام عملیات ساختن برنامه تولید میشوند(که شامل خطاها میشود)، در تب output، در پایین پنجره اصلی نمایش داده میشوند. اگر ماوس را بر روی عنوان تب output یک لحظه نگهدارید، خود بخود باز میشود.

تب output


برای اجرای برنامه کلید های ctrl + f5 را بزنید، یا از منو انتخاب کنید: Debug > start without debugging. برنامه در یک پنجره command prompt نمایش داده میشود.

اجرای برنامه در پنجره command prompt


نکته : برای ذخیره کردن تمام محتویات پروژه(فایل ها و تنظیمات و... ) از کلیدهای ctrl+shift+s یا از منو : File > save all استفاده کنید.

اجرای فوری پروژه : قبل از اجرای پروژه اگر تغییری در آن داده باشید باید پروژه را دوباره بسازید، اما اگر میخواهید برنامه را فوراً اجرا کنید و بعد از آخرین تغییرات در پروژه آن را نساخته اید، بازهم میتوانید از ctrl+f5 برای اجرای آن استفاده کنید. در این حالت سؤال میشود که آیا میخواهید آن را بسازید یا نه، اگر نه را انتخاب کنید، آخرین محصول(فایل exe) ساخت پروژه اجرا خواهد شد و پروژه دوباره ساخته نمیشود.

محل قرار گیری محصول پروژه (فایل اجرایی) در دیسک سخت : اگر پروژه را در حالت اشکال زدایی(debug) ساخته باشید(حالت پیش فرض)، فایل اجرایی در فولدر debug در فولدر پروژه شما قرار دارد. اما اگر در حالت release ساخته باشید، در فولدر release در فولدر پروژه شما قرار دارد. در هردو حالت، اگر یک فولدر جداگانه برای راه حل خود ساخته باشید، فولدرهای مذکور در فولدر راه حل قرار دارند. در مورد حالات debug و release بعداً توضیح خواهیم داد.

گرفتن راهنمایی فوری از msdn : برای گرفتن راهنمایی msdn در مورد دستوراتی که در فایل وارد کرده اید، کافی است مکان نمای ورود از طریق صفحه کلید(که بشکل i هست) را بر روی دستور مورد نظر قرار دهید(یعنی فقط در بین یکی از کاراکترهای آن باشد) آنگاه f1 را بزنید (ممکن است msdn با کمی تأخیر نمایش داده شود). اگر خطایی در هنگام کامپایل رخ دهد، برای گرفتن راهنمایی از msdn در مورد آن خطا، ابتدا مکان نما را در تب output روی خطی که عبارت 'error' در آن وجود دارد ببرید، سپس f1 را بزنید. البته در هر قسمتی از vs که باشید، میتوانید با زدن کلید f1 در مورد آن قسمت، از msdn راهنمایی بگیرید.

باز کردن فوری پروژه : هروقت که vs را اجرا میکنید، تب start page نمایش داده میشود، شما میتوانید با کلیک بر روی نام پروژه خود از درون این تب، پروژه را باز نمایید. (توجه کنید که vs بیشتر جاها به 'راه حل' هم 'پروژه' میگوید). اما اگر بخواهید میتوانید در منو file به قسمت recent projects بروید، سپس نام پروژه خود را انتخاب کنید. توجه کنید که در هردو روش، فقط چندتا از پروژه هایی که اخیراً باز یا ایجاد کرده اید نمایش داده میشوند، اگر نام پروژه خود را نیافتید باید از منوی file > open استفاده کنید. پسوند فایل های راه حل، sln میباشد(البته این نکته استفاده ای ندارد!).
سلام
مطالب آموزشیتون بسیار جالبه فقط می خواستم بپرسم که آیا msdnیک نرم افزار است ؟که با نرم افزار
سی پلاس پلاس ؛باهم درکامپیوتر نصب میشود یا باید جدا تهیه کنم؟
با سپاس.

[NameEly]

سلام دوست عزیز/میخوام بدونم بهترین زبان بعدازیادگرفتن ویژول بیسیک چه زبان برنامه نویسی
مشابه به این زبان است و مزایایش چیست؟من مدرک ویژوال رو از فنی حرفه ای گرفتم.

ببخشید من دیر جواب دادم دوست عزیزم
متوجه نشدم اگه با نقل قول جواب می دادید خیلی زود جواب می دادم
شرمندم
#c یک زبانی هستش که تقریبا شبیه اون هست هر چند بقیه هم شبیه اون هستن
زبان #c زبانی هست از خانواده ماکروسافت که برای سیستم عامل ویندوز تعبیه شده
از نظر کتابخانه هاش جامع هست برنامه نویسی باهش راحت هست و فوایدی دیگری هم داره که بخواین یک لیست جامع براتون میزارم
ولی یک مشکلی داره که روی هر سیستم عاملی کار نمی کنه و فقط برای ویندوز هست
البته با پروژه ای به نام مانو ( اگه اسمش رو اشتباه نگفته باشم ) این برنامه نویسی قرار برای تمام سیستم عامل ها اجرایی باشه
java هم که یک پدیده ای هست برای خودش و نیاز به معرفی نداشته باشه زیاد
یکی از چیز هایی که جاوا رو به نظر من به #c اولویت میده این هست که روی تمام سیستم عامل ها اجرایی هست
ولی من یک زبان دیگه هم بهتون معرفی میکم که از نظر قدرت خیلی خوب هست و همه کاره هست اون هم زبان برنامه نویسی پیتون یا پایتون هست
یاد گرفتن اون خیلی مفید هست

[صاصائیل]

ببخشید من دیر جواب دادم دوست عزیزم
متوجه نشدم اگه با نقل قول جواب می دادید خیلی زود جواب می دادم
شرمندم
#c یک زبانی هستش که تقریبا شبیه اون هست هر چند بقیه هم شبیه اون هستن
زبان #c زبانی هست از خانواده ماکروسافت که برای سیستم عامل ویندوز تعبیه شده
از نظر کتابخانه هاش جامع هست برنامه نویسی باهش راحت هست و فوایدی دیگری هم داره که بخواین یک لیست جامع براتون میزارم
ولی یک مشکلی داره که روی هر سیستم عاملی کار نمی کنه و فقط برای ویندوز هست
البته با پروژه ای به نام مانو ( اگه اسمش رو اشتباه نگفته باشم ) این برنامه نویسی قرار برای تمام سیستم عامل ها اجرایی باشه
java هم که یک پدیده ای هست برای خودش و نیاز به معرفی نداشته باشه زیاد
یکی از چیز هایی که جاوا رو به نظر من به #c اولویت میده این هست که روی تمام سیستم عامل ها اجرایی هست
ولی من یک زبان دیگه هم بهتون معرفی میکم که از نظر قدرت خیلی خوب هست و همه کاره هست اون هم زبان برنامه نویسی پیتون یا پایتون هست
یاد گرفتن اون خیلی مفید هست


سلام
از کمک هایی که در مورد برنامه نویسی به من میکنید سپاسگزارم[labkhand]
نه تنها من بلکه همه از اطلاعات شما استفاده می کنند[shaad]به شما تبریک میگم[shaad]

[NameEly]

سلام
از کمک هایی که در مورد برنامه نویسی به من میکنید سپاسگزارم[labkhand]
نه تنها من بلکه همه از اطلاعات شما استفاده می کنند[shaad]به شما تبریک میگم[shaad]

شما لطف دارید
من وظیفم رو انجام میدم
امیدوارم تونسته باشم کمکتون کنم [cheshmak]

[majdifar]

ممنون
ورژن turbo c++ چنده
دستور for هم توضیح بده

[NameEly]

ممنون
ورژن turbo c++ چنده
دستور for هم توضیح بده


با سلام به دوست گلم :

من ورژن زیاد ازش دیدم
و اموزش برای قسمت دستور for
دستور for یک دستور است که باعث ایجاد حلقه های انتها دار می شود
یعنی شروع که می شود انتها دارد و مانند حلقه while نیست که انتهای ان را شرط تعیین کند
و انتهای ان از دید ما مشخص نباشد

دستور for در زبان به این شکل است


for(i=a;i<,>,=b,i++)

که در اینجا i یک شمارش گر است که حلقه را شمارش می کند در مرحله i=a شمارش گر را یک مقدار اولیه می دهیم و با ; بین سه قسمت حلقه for فاصله می دهیم
در قسمت دوم برای شمارش گر یک شرط قرار می دهیم که تا کجا این حلقه تکرار شود که شمارش گر می تواند با ><= شرط داده شود
و در قسمت سوم شمارش گر را یکی اضافه یا یکی کم می کنیم با دستور های ++i یا --i
یک نکته که درباره حلقه for باید رعایت کرد این است که اگر تعداد دستور هایی که زیر مجموعه ی ان هستند یکی باشد نیاز به استفاده از علامت های باز و بسته نیست ( } { )
در دستور for از قسمت else و else if هم استفاده می کنیم که else به معنای وگر نه و else if به معنای و اگر است
امیدوارم به دردتون خورده باشه

با تشکر

[majdifar]

ممنون که خیلی زود جواب دادی ورژن 4.5دستوراش با نسخه 2010نفاوت داره

[NameEly]

ممنون که خیلی زود جواب دادی ورژن 4.5دستوراش با نسخه 2010نفاوت داره

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

نباید زیاد تفاوت کنه فقط توی بعضی چیزها می دونم تفاوتداره مانند cls یا namespase که اول ویژال می نویسند

مهم اون نسخه استاندارد هست که دستورات اصلی ++c چی هست بقیه همه دارای تغییرات هستند

[majdifar]

داخل نسخه 4.5 یه .hبه اخر function اضافه می کنیم ولی تو 2010فکر می کنم این جور نیست

[NameEly]

داخل نسخه 4.5 یه .hبه اخر function اضافه می کنیم ولی تو 2010فکر می کنم این جور نیست


بله درسته توی 2010 توی فانکشن ها h رو نمی زاریم

[NameEly]

داخل نسخه 4.5 یه .hبه اخر function اضافه می کنیم ولی تو 2010فکر می کنم این جور نیست


بله درسته توی 2010 توی فانکشن ها h رو نمی زاریم

[صاصائیل]

سلام یه کتاب آموزشی در مورد سی شارپ میخوام تهیه کنم.[labkhand] که مطالبش برای من قابل فهم باشه [khejalat]
کتابی مدنظر دارید؟

[NameEly]

سلام یه کتاب آموزشی در مورد سی شارپ میخوام تهیه کنم.[labkhand] که مطالبش برای من قابل فهم باشه [khejalat]
کتابی مدنظر دارید؟


سلام به شما دوست گلم :

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