این برنامه ها چه کار می کنند؟
به نظر می رسد که اجرای دوم دو برابر سریعتر از اولین است. آیا انتظار چنین نتیجه ای را داشتید؟ چطور آن را توضیح می دهی؟

تمرین 3.15

آیا چیزی وجود دارد که بتوانید در بخش آخر مجموعه عملیات کلاس رشته را بهبود یا اضافه کنید؟ پیشنهادات خود را توضیح دهید

3.5. مشخص کننده const

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

برای(int index = 0; index< 512; ++index) ... ;

استفاده از 512 literal دو مشکل دارد. اولین مورد سهولت درک متن برنامه است. چرا باید کران بالای متغیر حلقه دقیقاً 512 باشد؟ چه چیزی پشت این ارزش پنهان است؟ او تصادفی به نظر می رسد ...
مشکل دوم مربوط به سهولت اصلاح و نگهداری کد است. فرض کنید برنامه از 10000 خط تشکیل شده است و 512 به معنای واقعی کلمه در 4٪ آنها رخ می دهد. فرض کنید در 80 درصد موارد باید عدد 512 را به 1024 تغییر دهید.
هر دوی این مشکلات به طور همزمان حل می شوند: ما باید یک شی با مقدار 512 ایجاد کنیم. با دادن یک نام معنی دار به آن، مانند bufSize، برنامه را بسیار قابل درک تر خواهیم کرد: مشخص است که حلقه دقیقاً چیست. متغیر با.

فهرست مطالب< bufSize

در این مورد، تغییر اندازه bufSize نیازی به بررسی 400 خط کد برای تغییر 320 خط از آنها ندارد. چقدر احتمال خطا به قیمت اضافه کردن یک شی کاهش می یابد! اکنون مقدار 512 است محلی شده است.

bufSize = 512; // اندازه بافر ورودی // ... برای (int index = 0; index< bufSize; ++index)
// ...

یک مشکل کوچک باقی می ماند: متغیر bufSize در اینجا یک مقدار l است که می تواند به طور تصادفی در برنامه تغییر کند، که منجر به یک خطای سخت می شود. در اینجا یکی از رایج ترین اشتباهات وجود دارد - استفاده از عملگر انتساب (=) به جای مقایسه (==):

// تغییر تصادفی مقدار bufSize اگر (bufSize = 1) // ...

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

Const int bufSize = 512; // اندازه بافر ورودی

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

// خطا: تلاش برای اختصاص یک مقدار به یک ثابت اگر (bufSize = 0) ...

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

Const double pi; // خطا: ثابت بدون مقدار اولیه

حداقل دستمزد دو برابر = 9.60; // درست؟ خطا؟
دو برابر *ptr =

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

*ptr += 1.40; // شی minWage را تغییر دهید!

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

Const double *cptr;

که در آن cptr یک اشاره گر به یک شی از نوع const double است. ظرافت در این واقعیت نهفته است که نشانگر خود یک ثابت نیست، به این معنی که می توانیم مقدار آن را تغییر دهیم. مثلا:

Const double *pc = 0; const double minWage = 9.60; // صحیح: نمی توان minWage را با کامپیوتر تغییر داد
pc = دو برابر dval = 3.14; // صحیح: نمی توان minWage را با کامپیوتر تغییر داد
// اگرچه dval یک ثابت نیست
pc = // صحیح dval = 3.14159; //درست
* pc = 3.14159; // خطا

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

کامپیوتر =

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

// در برنامه های واقعی، نشانگرهای ثابت اغلب به عنوان پارامترهای رسمی توابع int strcmp (const char *str1, const char *str2) استفاده می شوند.

(زمانی که در مورد توابع صحبت می کنیم، در فصل 7 بیشتر در مورد نشانگرهای ثابت صحبت خواهیم کرد.)
همچنین نشانگرهای ثابتی وجود دارد. (به تفاوت بین اشاره گر ثابت و اشاره گر به ثابت توجه کنید!). یک اشاره گر ثابت می تواند هم یک ثابت و هم متغیر را نشان دهد. مثلا:

Inter errNumb = 0; int *const currErr =

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

کاری بکنید()؛ اگر (*curErr) (
errorHandler();
*curErr = 0; // correct: مقدار errNumb را بازنشانی کنید
}

تلاش برای اختصاص یک مقدار به یک اشاره گر ثابت باعث ایجاد یک خطای کامپایل می شود:

CurErr = // خطا

یک اشاره گر ثابت به یک ثابت، اتحاد دو حالت در نظر گرفته شده است.

Const double pi = 3.14159; const double *const pi_ptr = π

نه مقدار شی مورد اشاره توسط pi_ptr و نه مقدار خود اشاره گر را نمی توان در برنامه تغییر داد.

تمرین 3.16

مفهوم پنج تعریف زیر را توضیح دهید. آیا هیچ کدام از آنها اشتباه می کنند؟

(الف) int i; (د) int *const cpi; (ب) Const int ic; (ه) const int *const cpic; (ج) const int *pic;

تمرین 3.17

کدام یک از تعاریف زیر صحیح است؟ چرا؟

(الف) int i = -1; (ب) const int ic = i; (ج) const int *pic = (d) int *const cpi = (e) const int *const cpic =

تمرین 3.18

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

(الف) i = ic; (د) عکس = cpic; (ب) pic = (i) cpic = (ج) cpi = عکس; (f) ic = *cpic;

3.6. نوع مرجع

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

Intival = 1024; // صحیح: refVal - ارجاع به ival int &refVal = ival; // خطا: مرجع باید به int مقداردهی شود

Intival = 1024; // خطا: refVal از نوع int است، نه int* int &refVal = int *pi = // صحیح: ptrVal ارجاع به یک اشاره گر int است *&ptrVal2 = pi;

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

int min_val = 0; // ival مقدار min_val را می گیرد، // not refVal مقدار را به min_val تغییر می دهد refVal = min_val;

RefVal += 2; 2 را به ival اضافه می کند، متغیری که refVal به آن ارجاع می دهد. به طور مشابه int ii = refVal; ii را به مقدار فعلی ival تنظیم می کند، int *pi = pi را به آدرس ival مقدار دهی اولیه می کند.

// دو شی از نوع int تعریف شده اند int ival = 1024, ival2 = 2048; // یک مرجع و یک شی تعریف شده int &rval = ival, rval2 = ival2; // یک شی، یک اشاره گر و یک مرجع تعریف شده است
int inal3 = 1024، *pi = ival3، &ri = ival3; // دو مرجع تعریف شده int &rval3 = ival3، &rval4 = ival2;

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

دو dval = 3.14159; // فقط برای مراجع const درست است
const int &ir = 1024;
const int &ir2 = dval;
const double &dr = dval + 1.0;

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

دو dval = 1024; const int &ri = dval;

سپس کامپایلر آن را به چیزی شبیه به این تبدیل می کند:

int temp = dval; const int &ri = temp;

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

Const int ival = 1024; // خطا: مرجع ثابت مورد نیاز است
int *&pi_ref =

تلاش برای رفع مشکل با افزودن مشخص کننده const نیز با شکست مواجه می شود:

Const int ival = 1024; // همچنان خطای const int *&pi_ref =

دلیل ش چیه؟ با خواندن دقیق تعریف، خواهیم دید که pi_ref اشاره ای به یک اشاره گر ثابت به یک شی از نوع int است. و ما به یک اشاره گر non-const برای یک شی const نیاز داریم، بنابراین ورودی زیر صحیح خواهد بود:

Const int ival = 1024; // درست
int *const &piref=

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

int*pi = 0;

ما نشانگر pi را صفر می کنیم، به این معنی که pi به هیچ شیئی اشاره نمی کند. در عین حال رکورد

const int &ri = 0;
یعنی چیزی شبیه این:
int temp = 0;
const int &ri = temp;

در مورد عملیات تخصیص، در مثال زیر:

int ival = 1024، ival2 = 2048; int *pi = &ival، *pi2 = pi = pi2;

متغیر ival که توسط pi به آن اشاره شده است بدون تغییر باقی می ماند و pi مقدار آدرس ival2 را دریافت می کند. هر دو pi و pi2 همچنان به یک شی ival2 اشاره می کنند.
اگر با لینک ها کار کنیم:

Int &ri = ival، &ri2 = ival2; ri = ri2;

// مثال استفاده از مراجع // مقدار در پارامتر next_value برگردانده می شود
bool get_next_value(int &next_value); // بارگذاری بیش از حد عملگر ماتریس+(const Matrix&, const Matrix&);

اینتیوال در حالی که (get_next_value(ival)) ...

int &next_value = ival;

(استفاده از مراجع به عنوان پارامترهای رسمی برای توابع با جزئیات بیشتر در فصل 7 مورد بحث قرار گرفته است.)

تمرین 3.19

آیا در این تعاریف خطایی وجود دارد؟ توضیح. چگونه آنها را تعمیر می کنید؟

(الف) int ival = 1.01; (ب) int &rval1 = 1.01; (ج) int &rval2 = ival; (د) int &rval3 = (e) int *pi = (f) int &rval4 = pi; (g) int &rval5 = pi*; (h) int &*prval1 = pi; (i) const int &ival2 = 1; (j) const int &*prval2 =

تمرین 3.20

آیا هر یک از تکالیف زیر (با استفاده از تعاریف تمرین قبلی) اشتباه است؟

(الف) rval1 = 3.14159; (ب) prval1 = prval2; (ج) prval2 = rval1; (د) *prval2 = ival2;

تمرین 3.21

در دستورالعمل های زیر به دنبال خطا باشید:

(الف) int ival = 0; const int *pi = 0; const int &ri = 0; (ب) پی =
ری =
پی =

3.7. bool را تایپ کنید

یک شی از نوع bool می تواند یکی از دو مقدار درست و غلط را بگیرد. مثلا:

// مقداردهی اولیه رشته string search_word = get_word(); // مقداردهی اولیه متغیر پیدا شده
bool یافت = نادرست; رشته next_word; در حالی که (cin >> next_word)
if (next_word == search_word)
یافت = درست
// ... // کوتاه نویسی: اگر (یافت == درست)
اگر (پیدا شد)
کوت<< "ok, мы нашли слово\n";
دیگر cout<< "нет, наше слово не встретилось.\n";

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

// خطا short bool found = false;

اشیاء از نوع bool به طور ضمنی به نوع int تبدیل می شوند. مقدار true می شود 1 و false 0 می شود. به عنوان مثال:

bool یافت = نادرست; int origin_count = 0; در حالی که (/* زمزمه */)
{
یافت = جستجو_برای(/* چیزی */); // مقدار یافت شده به 0 یا 1 تبدیل می شود
وقوع_شمار += یافت شد; )

به همین ترتیب، مقادیر انواع اعداد صحیح و اشاره گرها را می توان به مقادیر bool تبدیل کرد. در این مورد، 0 به عنوان نادرست، و هر چیز دیگر به عنوان درست تفسیر می شود:

// تعداد رخدادهای extern int find(const string&); bool یافت = نادرست; if (found = find("sebbud")) // correct: found == true // یک اشاره گر به عنصر برمی گرداند
extern int* find(int value); if (found = find(1024)) // صحیح: found == true

3.8. شمارش ها

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

ورودی Const int = 1; خروجی const int = 2; const int append = 3;

و از این ثابت ها استفاده کنید:

bool open_file (رشته file_name، int open_mode); //...
open_file("Phoenix_and_the_Crane"، ضمیمه)؛

این راه حل قابل قبول است، اما کاملاً قابل قبول نیست، زیرا نمی توانیم تضمین کنیم که آرگومان ارسال شده به تابع open_file() فقط 1، 2 یا 3 باشد.
استفاده از نوع برشماری این مشکل را حل می کند. وقتی می نویسیم:

Enum open_modes (ورودی = 1، خروجی، پیوست)؛

ما یک نوع جدید open_modes تعریف می کنیم. مقادیر معتبر برای یک شی از این نوع به 1، 2 و 3 محدود می شود و هر یک از مقادیر مشخص شده دارای یک نام یادگاری است. ما می توانیم از نام این نوع جدید برای تعریف یک شی از آن نوع و نوع پارامترهای رسمی تابع استفاده کنیم:

Open_file باطل (رشته file_name، open_modes om);

ورودی، خروجی و الحاقی هستند عناصر شمارش. مجموعه عناصر شمارش مجموعه مقادیر معتبر را برای یک شی از یک نوع معین مشخص می کند. متغیری از نوع open_modes (در مثال ما) با یکی از این مقادیر مقداردهی اولیه می شود، همچنین می توان هر یک از آنها را به آن اختصاص داد. مثلا:

Open_file("ققنوس و جرثقیل"، پیوست);

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

// خطا: 1 یک عضو enum نیست open_modes open_file("Jonah", 1);

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

open_modes om=input; // ... om = ضمیمه; open_file("TailTell"، om);

با این حال، نمی توان نام چنین عناصری را به دست آورد. اگر یک دستور خروجی بنویسیم:

کوت<< input << " " << om << endl;

ما هنوز دریافت می کنیم:

این مشکل با تعریف یک آرایه رشته ای حل می شود که در آن عنصر با شاخصی برابر با مقدار عنصر enum نام خود را در خود دارد. با چنین آرایه ای می توانیم بنویسیم:

کوت<< open_modes_table[ input ] << " " << open_modes_table[ om ] << endl Будет выведено: input append

همچنین، نمی‌توانید روی همه مقادیر enum تکرار کنید:

// برای (open_modes iter = input; iter != append; ++inter) پشتیبانی نمی شود // ...

از کلمه کلیدی enum برای تعریف شمارش استفاده می شود و نام عناصر در پرانتزهای مجعد مشخص می شود که با کاما از هم جدا می شوند. به طور پیش فرض، اولی 0، بعدی 1 و غیره است. اپراتور انتساب می تواند این قانون را تغییر دهد. در این حالت، هر عنصر بعدی بدون مقدار مشخصی 1 بیشتر از عنصر قبل از خود در لیست خواهد بود. در مثال ما به صراحت مقدار 1 را برای ورودی مشخص کرده ایم و خروجی و ضمیمه 2 و 3 خواهد بود. در اینجا مثال دیگری وجود دارد:

// shape == 0, sphere == 1, cylinder == 2, polygon == 3 enum Forms( share, spre, cylinder, polygon );

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

// point2d == 2، point2w == 3، point3d == 3، point3w == 4 تعداد امتیاز (point2d=2، point2w، point3d=3، point3w=4);

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

Void mumble() ( Points pt3d = point3d; // correct: pt2d == 3 // خطا: pt3w برای تایپ int Points pt3w = 3 مقداردهی اولیه می شود؛ // خطا: چند ضلعی در Points enum نیست pt3w = چند ضلعی؛ // صحیح است : هر دو شی از نوع Points pt3w = pt3d؛ )

با این حال، در عبارات حسابی، یک enum را می توان به طور خودکار به نوع int تبدیل کرد. مثلا:

const int array_size = 1024; // صحیح: pt2w به int تبدیل می شود
int chunk_size = array_size * pt2w;

3.9. "آرایه" را تایپ کنید

ما قبلاً در بخش 2.1 آرایه ها را لمس کردیم. آرایه مجموعه ای از عناصر از همان نوع است که با شاخص - شماره ترتیبی عنصر در آرایه - به آنها دسترسی پیدا می شود. مثلا:

اینتیوال

ival را به عنوان متغیری از نوع int و عبارت تعریف می کند

int ia[ 10];

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

ایوال = ia[ 2 ];

مقدار عنصر آرایه ia با اندیس 2 را به متغیر ival نسبت می دهد. به طور مشابه

Ia[ 7 ] = ival;

عنصر را در شاخص 7 برابر ival قرار می دهد.

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

extern int get_size(); // ثابت buf_size و max_files
const int buf_size = 512، max_files = 20;
intstaff_size = 27; // صحیح: char ثابت input_buffer[ buf_size ]; // صحیح: عبارت ثابت: 20 - 3 char *fileTable[ max_files-3 ]; // خطا: حقوق دو برابر ثابت نیست[ staff_size ]; // خطا: یک عبارت ثابت نیست int test_scores[ get_size() ];

اشیاء buf_size و max_files ثابت هستند، بنابراین تعاریف آرایه input_buffer و fileTable صحیح هستند. اما staff_size یک متغیر است (البته به مقدار ثابت 27 مقداردهی اولیه شده است)، بنابراین حقوق غیرقانونی است. (کامپایلر قادر به یافتن مقدار متغیر staff_size در زمان تعریف آرایه حقوق نیست.)
عبارت max_files-3 را می توان در زمان کامپایل ارزیابی کرد، بنابراین تعریف آرایه fileTable از نظر نحوی صحیح است.
شماره گذاری عناصر از 0 شروع می شود، بنابراین برای یک آرایه 10 عنصری، محدوده شاخص صحیح 1 - 10 نیست، بلکه 0 - 9 است. در اینجا مثالی از تکرار روی همه عناصر آرایه آمده است:

int main() (const int array_size = 10; int ia[ array_size ]; for (int ix = 0; ix< array_size; ++ ix)
ia[ ix ] = ix;
}

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

const int array_size = 3; int ia[ array_size ] = ( 0, 1, 2 );

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

// آرایه با اندازه 3 int ia = ( 0, 1, 2 );

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

// ia ==> ( 0, 1, 2, 0, 0 ) const int array_size = 5; int ia[ array_size ] = ( 0, 1, 2 );

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

Const char cal = ("C"، "+"، "+"); const char cal2 = "C++";

بعد آرایه ca1 3 است، بعد آرایه ca2 4 است (کاراکتر تهی پایانی در حرف های رشته ای در نظر گرفته می شود). تعریف زیر باعث خطای کامپایل می شود:

// error: string "Daniel" از 7 عنصر تشکیل شده است const char ch3[ 6 ] = "Daniel";

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

const int array_size = 3; int ix, jx, kx; // صحیح: آرایه ای از اشاره گرها از نوع int* int *iar = ( &ix, &jx, &kx ); // خطا: آرایه های مرجع نامعتبر هستند int &iar = ( ix, jx, kx ); int main()
{
int ia3( array_size ]; // صحیح است
// خطا: آرایه های داخلی قابل کپی نیستند
ia3 = ia;
بازگشت 0;
}

برای کپی کردن یک آرایه به آرایه دیگر، باید این کار را برای هر عنصر جداگانه انجام دهید:

const int array_size = 7; int ia1 = ( 0، 1، 2، 3، 4، 5، 6); int main() (
int ia3[اندازه_آرایه]; برای (int ix = 0; ix< array_size; ++ix)
ia2[ ix ] = ia1[ ix ]; بازگشت 0;
}

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

int someVal, get_index(); ia2[ get_index() ] = someVal;

تاکید می کنیم که زبان C++ نه در زمان کامپایل و نه در زمان اجرا کنترلی بر شاخص های آرایه ارائه نمی دهد. خود برنامه نویس باید اطمینان حاصل کند که ایندکس از مرزهای آرایه فراتر نمی رود. خطاهای ایندکس بسیار رایج هستند. متأسفانه، یافتن نمونه‌هایی از برنامه‌هایی که کامپایل می‌شوند و حتی اجرا می‌شوند، اما با این وجود حاوی خطاهای مهلکی هستند که دیر یا زود منجر به خرابی می‌شوند، چندان دشوار نیست.

تمرین 3.22

کدام یک از تعاریف آرایه زیر حاوی خطا است؟ توضیح.

(الف) int ia[buf_size]؛ (د) int ia[ 2 * 7 - 14 ] (ب) int ia[ get_size() ]; (ه) char st[ 11 ] = "بنیادی"; (ج) int ia[ 4 * 7 - 14 ];

تمرین 3.23

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

int main() (const int array_size = 10; int ia[ array_size ]; for (int ix = 1; ix<= array_size; ++ix)
ia[ia] = ix; //...
}

3.9.1. آرایه های چند بعدی

در C++ امکان استفاده از آرایه های چند بعدی وجود دارد که باید با مرز سمت راست هر بعد در براکت های مجزا اعلان شوند. در اینجا تعریف آرایه دو بعدی آمده است:

Int ia[ 4 ][ 3 ];

مقدار اول (4) تعداد سطرها و دومی (3) تعداد ستون ها را مشخص می کند. شی ia به عنوان آرایه ای از چهار رشته با سه عنصر تعریف می شود. آرایه های چند بعدی نیز می توانند مقداردهی اولیه شوند:

Int ia[ 4 ][ 3 ] = ( ( 0, 1, 2 ), ( 3, 4, 5 ), ( 6, 7, 8 ), ( 9, 10, 11 ) );

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

int ia = (0,1,2,3,4,5,6,7,8,9,10,11)؛

تعریف زیر فقط اولین عناصر هر ردیف را مقداردهی اولیه می کند. عناصر باقیمانده صفر خواهند بود:

Int ia[ 4 ][ 3 ] = ( (0)، (3)، (6)، (9));

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

Int ia[ 4 ][ 3 ] = ( 0, 3, 6, 9 );

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

int main() (const int rowSize = 4; const int colSize = 3; int ia[ rowSize ][ colSize ]; for (int = 0; i< rowSize; ++i)
برای (int j = 0; j< colSize; ++j)
ia[ i ][ j ] = i + j j;
}

طرح

Ia [ 1، 2 ]

از نظر نحو C++ معتبر است، اما به معنای آن چیزی نیست که یک برنامه نویس بی تجربه انتظار دارد. این به هیچ وجه اعلان یک آرایه دو بعدی 1 در 2 نیست. یک مجموع در پرانتز لیستی از عبارات جدا شده با کاما است که به مقدار نهایی 2 منجر می شود (عملگر "کاما" را در بخش 4.2 ببینید. ). بنابراین، اعلام ia معادل ia است. این یک فرصت دیگر برای اشتباه کردن است.

3.9.2. رابطه بین آرایه ها و اشاره گرها

اگر تعریف آرایه ای داشته باشیم:

Int ia = ( 0، 1، 1، 2، 3، 5، 8، 13، 21);

پس یک علامت ساده از نام آن در برنامه به چه معناست؟

استفاده از شناسه آرایه در یک برنامه معادل تعیین آدرس اولین عنصر آن است:

به طور مشابه، دو راه برای دسترسی به مقدار عنصر اول یک آرایه وجود دارد:

// هر دو عبارت اولین عنصر *ia; ia;

برای گرفتن آدرس عنصر دوم آرایه، می نویسیم:

همانطور که قبلا ذکر کردیم، بیان

همچنین آدرس عنصر آرایه دوم را می دهد. بر این اساس، ارزش آن با دو روش زیر به ما داده می شود:

*(ia+1)؛ ia;

به تفاوت عبارات توجه کنید:

*ia+1 و *(ia+1)؛

عملیات ارجاع بالاتری دارد یک اولویتاز عملیات جمع (برای اطلاعات بیشتر در مورد اولویت عملگر به بخش 4.13 مراجعه کنید). بنابراین عبارت اول ابتدا متغیر ia را تغییر می دهد و اولین عنصر آرایه را می گیرد و سپس 1 را به آن اضافه می کند و عبارت دوم مقدار عنصر دوم را ارائه می دهد.

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

#عبارتند از int main() ( int ia = ( 0, 1, 1, 2, 3, 5, 8, 13, 21 )؛ int *pbegin = ia؛ int *pend = ia + 9؛ while (pbegin != pend) ( کوت<< *pbegin <<; ++pbegin; } }

اشاره گر pbegin با آدرس اولین عنصر آرایه مقدار دهی اولیه می شود. هر تکرار از طریق حلقه این اشاره گر را 1 افزایش می دهد، به این معنی که به عنصر بعدی منتقل می شود. چگونه بدانیم کجا اقامت کنیم؟ در مثال ما یک نشانگر pend دوم تعریف کرده ایم و آن را با آدرسی که آخرین عنصر آرایه ia را دنبال می کند مقداردهی اولیه می کنیم. به محض اینکه مقدار pbegin برابر با pend شد، می دانیم که آرایه تمام شده است. بیایید این برنامه را بازنویسی کنیم تا ابتدا و انتهای آرایه به عنوان پارامتر به یک تابع عمومی که می تواند آرایه ای با هر اندازه ای را چاپ کند، ارسال شود:

#عبارتند از void ia_print(int *pbegin, int *pend) (
در حالی که (pbegin != pend) (
کوت<< *pbegin << " ";
++pbegin;
}
) int main()
{
int ia = ( 0، 1، 1، 2، 3، 5، 8، 13، 21);
ia_print(ia, ia + 9);
}

تابع ما جهانی تر شده است، با این حال، فقط می تواند با آرایه های int کار کند. راهی برای حذف این محدودیت نیز وجود دارد: تبدیل تابع داده شده به یک الگو (الگوها به طور خلاصه در بخش 2.5 معرفی شدند):

#عبارتند از قالب void print(elemType *pbegin, elemType *pend) ( while (pbegin != pend) (cout<< *pbegin << " "; ++pbegin; } }

اکنون می‌توانیم تابع print() خود را برای چاپ آرایه‌هایی از هر نوع فراخوانی کنیم:

int main() ( int ia = ( 0, 1, 1, 2, 3, 5, 8, 13, 21 )؛ double da = ( 3.14, 6.28, 12.56, 25.12 )؛ string sa = ( "piglet", " چشم، "pooh"); print(ia، ia+9);
print(da,da+4);
چاپ (sa, sa+3);
}

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

#عبارتند از int main() ( int ia = ( 107, 28, 3, 47, 104, 76 ); string sa = ( "piglet", "eeyore", "pooh"); sort(ia, ia+6);
مرتب سازی (sa, sa+3);
};

(ما الگوریتم های تعمیم یافته را به تفصیل در فصل 12 مورد بحث قرار خواهیم داد؛ نمونه هایی از استفاده از آنها در ضمیمه آورده شده است.)
کتابخانه استاندارد C++ شامل مجموعه ای از کلاس هاست که استفاده از کانتینرها و اشاره گرها را در بر می گیرد. (ما در این مورد در بخش 2.8 بحث کردیم.) در بخش بعدی، بردار استاندارد نوع ظرف را بررسی خواهیم کرد که یک پیاده سازی شی گرا از یک آرایه است.

3.10. کلاس برداری

استفاده از کلاس برداری (به بخش 2.8 مراجعه کنید) جایگزینی برای استفاده از آرایه های داخلی است. این کلاس ویژگی های بسیار بیشتری را ارائه می دهد، بنابراین استفاده از آن ترجیح داده می شود. با این حال، شرایطی وجود دارد که نمی توان آرایه هایی از نوع داخلی را کنار گذاشت. یکی از این موقعیت ها پردازش پارامترهای خط فرمان است که به برنامه منتقل می شود که در بخش 7.8 به آن خواهیم پرداخت. کلاس برداری، مانند کلاس رشته، بخشی از کتابخانه استاندارد C++ است.
برای استفاده از وکتور، باید یک فایل هدر اضافه کنید:

#عبارتند از

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

بردار< int >ivec (10)؛

که همان تعریف آرایه ای از نوع داخلی است:

int ia[ 10];

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

void simp1e_examp1e() (const int e1em_size = 10؛ برداری< int >ivec(e1em_size); int ia[ e1em_size ]; برای (int ix = 0; ix< e1em_size; ++ix)
ia[ ix ] = ivec[ ix ]; //...
}

می‌توانیم اندازه یک بردار را با استفاده از تابع size() دریابیم و با استفاده از تابع ()() خالی بودن بردار را بررسی کنیم. مثلا:

چاپ_بردار خالی (بردار ivec) (اگر (ivec.empty()) بازگشت؛ برای (int ix=0; ix< ivec.size(); ++ix)
کوت<< ivec[ ix ] << " ";
}

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

بردار< int >ivec (10, -1)؛

هر ده عنصر بردار برابر با 1- خواهد بود.
یک آرایه از نوع داخلی را می توان به طور صریح با یک لیست مقداردهی اولیه کرد:

int ia[ 6 ] = (-2، -1، 0، 1، 2، 1024);

برای یک شی از کلاس برداری، عمل مشابه امکان پذیر نیست. با این حال، چنین شیئی را می توان با آرایه ای از نوع داخلی مقداردهی کرد:

// 6 عنصر ia در بردار ivec کپی می شود< int >ivec(ia، ia+6)؛

دو اشاره گر به سازنده بردار ivec ارسال می شود - یک اشاره گر به ابتدای آرایه ia و به عنصری که بعد از آخرین نشانگر است. به عنوان لیستی از مقادیر اولیه، مجاز است که نه کل آرایه، بلکه برخی از محدوده آن را مشخص کنید:

// 3 عنصر کپی می شود: بردار ia، ia، ia< int >ivec(&ia[2]، &ia[5]);

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

بردار< string >svec; void init_and_assign() (// یک بردار توسط بردار دیگر مقداردهی اولیه می شود< string >user_names(svec); // ... // یک بردار در دیگری کپی می شود
svec = user_names;
}

صحبت از اصطلاح STL، منظور ما یک رویکرد بسیار متفاوت برای استفاده از یک برداری است. به جای اینکه فوراً اندازه مناسب را تنظیم کنیم، یک بردار خالی تعریف می کنیم:

بردار< string >متن;

سپس با استفاده از توابع مختلف به آن عناصر اضافه می کنیم. برای مثال، تابع push_back() یک عنصر را در انتهای یک بردار درج می کند. در اینجا یک قطعه کد است که دنباله ای از خطوط را از ورودی استاندارد می خواند و آنها را به یک بردار اضافه می کند:

کلمه رشته while (cin >> word) ( text.push_back(word); // ... )

اگرچه می توانیم از عملیات take index برای تکرار بر روی عناصر یک بردار استفاده کنیم:

کوت<< "считаны слова: \n"; for (int ix =0; ix < text.size(); ++ix) cout << text[ ix ] << " "; cout << endl;

معمول‌تر در این اصطلاح استفاده از تکرارکننده‌ها است:

کوت<< "считаны слова: \n"; for (vector::iterator it = text.begin(); it != text.end(); ++آن) cout<< *it << " "; cout << endl;

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

تکرار کننده را حذف می کند و خود عنصر برداری را می دهد. دستورالعمل

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

بردار ivec;

اشتباه است اگر بنویسیم:

ما هنوز یک عنصر از بردار ivec نداریم. تعداد عناصر با استفاده از تابع size() مشخص می شود.

شما همچنین می توانید اشتباه مخالف را مرتکب شوید. اگر یک بردار با اندازه ای تعریف کرده باشیم، برای مثال:

بردار ia (10);

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

Const int size = 7; int ia [ اندازه ] = ( 0، 1، 1، 2، 3، 5، 8); بردار< int >ivec (اندازه)؛ برای (int ix = 0; ix< size; ++ix) ivec.push_back(ia[ ix ]);

این به معنای مقداردهی اولیه بردار ivec با مقادیر عناصر ia بود که به جای آن یک بردار ivec با اندازه 14 دریافت کردیم.
با پیروی از اصطلاح STL، نه تنها می توانید عناصر یک بردار را اضافه کنید، بلکه حذف کنید. (ما همه اینها را به تفصیل و با مثال هایی در فصل 6 پوشش خواهیم داد.)

تمرین 3.24

آیا در تعاریف زیر اشتباهاتی وجود دارد؟
int ia[ 7] = ( 0، 1، 1، 2، 3، 5، 8);

(الف) بردار< vector< int >>ivec;
(ب) بردار< int >ivec = (0، 1، 1، 2، 3، 5، 8)؛
ج) بردار< int >ivec (ia، ia+7)؛
(د) بردار< string >svec = ivec;
(ه) بردار< string >svec(10، string("null"));

تمرین 3.25

تابع زیر را اجرا کنید:
bool is_equal(const int*ia, int ia_size,
بردار const &ivec)؛
تابع is_equal() دو ظرف را عنصر به عنصر مقایسه می کند. در مورد اندازه های مختلف ظروف، "دم" طولانی تر در نظر گرفته نمی شود. واضح است که اگر همه عناصر مقایسه شده برابر باشند، تابع true و اگر حداقل یکی متفاوت باشد، false را برمی گرداند. از یک تکرار کننده برای تکرار روی عناصر استفاده کنید. یک تابع main() بنویسید که is_equal() را فراخوانی کند.

3.11. کلاس پیچیده

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

#عبارتند از

یک عدد مختلط دو بخش دارد - واقعی و خیالی. قسمت خیالی جذر یک عدد منفی است. یک عدد مختلط معمولاً به صورت نوشته می شود

که در آن 2 قسمت واقعی و 3i قسمت خیالی است. در اینجا نمونه هایی از تعاریف پیچیده اشیاء آورده شده است:

// عدد خیالی خالص: 0 + 7-i مختلط< double >پوره (0, 7); // قسمت خیالی 0: 3 + مجتمع Oi است< float >rea1_num (3); // هر دو بخش واقعی و خیالی 0: 0 + 0-i مختلط هستند< long double >صفر؛ // مقدار دهی اولیه یک عدد مختلط توسط مختلط دیگر< double >purei2 (purei);

از آنجایی که پیچیده، مانند برداری، یک الگو است، می‌توانیم آن را با float، double و long double مانند مثال‌های بالا نمونه‌سازی کنیم. همچنین می توانید آرایه ای از عناصر پیچیده را تعریف کنید:

مجتمع< double >مزدوج[ 2 ] = (مختلط< double >(2، 3)، مجتمع< double >(2, -3) };

مجتمع< double >*ptr = پیچیده< double >&ref = *ptr;

3.12. دستورالعمل typedef

دستورالعمل typedef به شما امکان می دهد مترادف یک نوع داده داخلی یا تعریف شده توسط کاربر را مشخص کنید. مثلا:

دستمزد دو برابر Typedef; وکتور typedef vec_int; typedef vec_int test_scores; typedef bool in_attendance; typedef int *Pint;

نام های تعریف شده با دستورالعمل typedef را می توان به همان روشی که تعیین کننده نوع استفاده کرد:

// دو ساعتی، هفتگی؛ دستمزد ساعتی، هفتگی؛ // بردار vecl(10);
vec_int vecl(10); // بردار test0 (c1ass_size); const int c1ass_size = 34; test_scores test0(c1ass_size); // بردار< bool >حضور؛ بردار< in_attendance >حضور (c1ass_size)؛ // int *table[ 10]; جدول پینت [ 10 ];

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

Typedef char *cstring;

نوع متغیر cstr در اعلان زیر چیست:

extern const cstring cstr;

پاسخی که واضح به نظر می رسد این است:

Const char *cstr

با این حال، این درست نیست. مشخص کننده const به cstr اشاره دارد، بنابراین پاسخ صحیح یک اشاره گر const به char است:

Char *const cstr;

3.13. مشخص کننده فرار

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

فرار int disp1ay_register; وظیفه فرار *curr_task; volatile int ixa[ max_size ]; فرار صفحه نمایش bitmap_buf;

display_register یک شی ناپایدار از نوع int است. curr_task یک اشاره گر به یک شیء Task ناپایدار است. ixa یک آرایه ناپایدار از اعداد صحیح است و هر عنصر از چنین آرایه ای ناپایدار در نظر گرفته می شود. bitmap_buf یک شی فرار از کلاس Screen است که هر یک از اعضای داده آن نیز فرار در نظر گرفته می شود.
تنها هدف از استفاده از مشخص کننده فرار این است که به کامپایلر بگوییم که نمی تواند تعیین کند چه کسی و چگونه می تواند مقدار یک شی معین را تغییر دهد. بنابراین، کامپایلر نباید کدی را که از این شیء استفاده می کند، بهینه کند.

3.14. کلاس جفت

کلاس جفت کتابخانه استاندارد C++ به ما امکان می دهد در صورت وجود رابطه معنایی بین آنها، یک جفت مقادیر را با یک شی تعریف کنیم. این مقادیر می توانند انواع مشابه یا متفاوت باشند. برای استفاده از این کلاس، باید یک فایل هدر اضافه کنید:

#عبارتند از

به عنوان مثال، دستورالعمل

جفت کردن< string, string >نویسنده ("جیمز"، "جویس")؛

یک شی نویسنده از نوع جفت ایجاد می کند که از دو مقدار رشته تشکیل شده است.
بخش‌های مجزای یک جفت را می‌توان با استفاده از اعضای اول و دوم بازیابی کرد:

رشته firstbook; اگر (Joyce.first == "James" &&
Joyce.second == "جویس")
firstBook = "Stephen Hero";

اگر نیاز به تعریف چندین شی از یک نوع از این کلاس دارید، استفاده از دستورالعمل typedef راحت است:

جفت Typedef< string, string >نویسندگان؛ نویسندگان proust("marcel", "proust"); نویسندگان جویس ("جیمز"، "جویس"); نویسندگان musil("robert", "musi1");

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

ورودی کلاس؛ extern EntrySlot* 1ook_up(string); جفت typedef< string, EntrySlot* >SymbolEntry; SymbolEntry current_entry("نویسنده"، 1ook_up("نویسنده"));
// ... if (EntrySlot *it = 1ook_up("ویرایشگر")) (
current_entry.first = "ویرایشگر";
current_entry.second = آن;
}

(ما به بحث کلاس جفت در فصل 6 در مورد انواع کانتینر و الگوریتم های عمومی در فصل 12 باز خواهیم گشت.)

3.15. انواع کلاس ها

مکانیسم کلاس به شما اجازه می دهد تا انواع داده های جدید ایجاد کنید. انواع رشته، برداری، مختلط و جفتی را که در بالا توضیح داده شد معرفی کرد. در فصل 2، ما در مورد مفاهیم و مکانیسم هایی صحبت کردیم که از رویکرد شی گرا و شی گرا پشتیبانی می کنند و از پیاده سازی کلاس Array به عنوان مثال استفاده می کنیم. در اینجا، بر اساس رویکرد شی، یک کلاس String ساده ایجاد می کنیم، که اجرای آن به درک، به ویژه بارگذاری اپراتور کمک می کند - ما در مورد آن در بخش 2.3 صحبت کردیم. (در فصل های 13، 14 و 15 دروس به تفصیل بحث شده است). توضیح مختصری در مورد کلاس داده ایم تا مثال های جالب تری ارائه دهیم. خواننده‌ای که تازه شروع به یادگیری C++ کرده است، می‌تواند این بخش را نادیده بگیرد و منتظر توضیح سیستماتیک‌تر کلاس‌ها در فصل‌های بعدی باشد.)
کلاس String ما باید از مقداردهی اولیه با یک شی کلاس String، یک string literal و یک نوع رشته داخلی و همچنین عملیات تخصیص مقادیر این نوع به آن پشتیبانی کند. برای این کار از سازنده کلاس و یک عملگر انتساب اضافه بار استفاده می کنیم. دسترسی به کاراکترهای منفرد از یک رشته به عنوان یک عملگر دریافت شاخص اضافه بار اجرا می شود. علاوه بر این، ما به تابع size() برای دریافت اطلاعات در مورد طول رشته نیاز داریم. عملیات مقایسه اشیاء از نوع String و یک شی String با رشته ای از نوع داخلی. و همچنین عملیات I/O شی ما. در نهایت، ما توانایی دسترسی به نمایش داخلی رشته خود را به عنوان یک رشته نوع داخلی اجرا می کنیم.
تعریف کلاس با کلمه کلیدی کلاس و به دنبال آن یک شناسه، نام کلاس یا نوع شروع می شود. به طور کلی، یک کلاس از بخش هایی تشکیل شده است که قبل از کلمات عمومی (باز) و خصوصی (بسته) قرار می گیرند. یک بخش باز معمولاً شامل مجموعه ای از عملیات پشتیبانی شده توسط کلاس است که متدها یا توابع عضو کلاس نامیده می شوند. این توابع عضو، رابط عمومی کلاس را تعریف می کنند، به عبارت دیگر، مجموعه اقداماتی را که می توان روی اشیاء آن کلاس انجام داد. یک بخش خصوصی معمولاً شامل اعضای داده ای است که یک پیاده سازی داخلی را ارائه می دهند. در مورد ما، اعضای داخلی شامل _string - یک اشاره گر به char، و همچنین _size از نوع int هستند. _size اطلاعات مربوط به طول رشته را ذخیره می کند و _string آرایه ای از کاراکترها است که به صورت پویا تخصیص داده شده است. در اینجا تعریف کلاس به نظر می رسد:

#عبارتند از کلاس رشته; istream& operator>>(istream&, String&);
جریان و اپراتور<<(ostream&, const String&); class String {
عمومی:
// مجموعه ای از سازنده ها
// برای مقدار دهی اولیه خودکار
// Stringstrl; // رشته ()
// String str2("literal"); // رشته (const char*);
// رشته str3(str2); // رشته (const String&); string();
رشته (const char*);
رشته (const String&); // ویرانگر
~string(); // عملگرهای انتساب
// strl = str2
// str3 = "a string literal" String& operator=(const String&);
String& operator=(const char*); // عملگرهای برابری
// strl == str2;
// str3 == "یک رشته تحت اللفظی"; عملگر bool==(const String&);
bool operator==(const char*); // بارگذاری بیش از حد اپراتور دسترسی بر اساس شاخص
// strl[ 0 ] = str2[ 0 ]; char& operator(int); // دسترسی به اعضای کلاس
int size() ( return _size; )
char* c_str() ( return _string; ) private:
int_size;
char*_string;
}

کلاس String سه سازنده دارد. همانطور که در بخش 2.3 بحث شد، مکانیسم اضافه بار اجازه می دهد تا چندین پیاده سازی از توابع با نام یکسان تعریف شوند، تا زمانی که همه آنها در تعداد و/یا نوع پارامترهایشان متفاوت باشند. اولین سازنده

این سازنده پیش فرض است زیرا به مقدار اولیه صریح نیاز ندارد. وقتی می نویسیم:

برای str1، چنین سازنده ای نامیده می شود.
دو سازنده باقیمانده هر کدام یک پارامتر دارند. بله، برای

رشته str2 ("رشته کاراکتر");

سازنده نامیده می شود

رشته (const char*);

رشته str3(str2);

سازنده

رشته (const String&);

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

stringstr4(1024);

این باعث یک خطای کامپایل می شود زیرا سازنده ای با پارامتر نوع int وجود ندارد.
یک اعلامیه اپراتور بارگذاری شده دارای فرمت زیر است:

عملگر return_type op(parameter_list);

جایی که عملگر یک کلمه کلیدی است و op یکی از عملگرهای از پیش تعریف شده است: +، =، ==، و غیره. (برای تعریف دقیق نحو، به فصل 15 مراجعه کنید.) در اینجا اعلان عملگر زیر بارگذاری شده است:

Char& operator(int);

این عملگر دارای یک پارامتر واحد از نوع int است و یک مرجع به char برمی گرداند. اگر لیست پارامترهای نمونه های جداگانه متفاوت باشد، یک اپراتور بارگذاری شده می تواند خود بارگذاری شود. برای کلاس String خود، دو عملگر تخصیص و برابری متفاوت ایجاد خواهیم کرد.
برای فراخوانی یک تابع عضو، از نقطه (.) یا فلش (->) اپراتورهای دسترسی عضو استفاده کنید. فرض کنید اعلان شی از نوع String داریم:

شی رشته ("Danny");
String *ptr = new String("Anna");
Stringarray;
در اینجا فراخوانی تابع size() برای این اشیاء به نظر می رسد:
بردار اندازه (3)؛

// دسترسی اعضا برای اشیاء (.); // اشیاء 5 اندازه هستند[ 0 ] = object.size(); // دسترسی اعضا برای نشانگرها (->)
// ptr دارای اندازه 4 است
sizes[ 1 ] = ptr->size(); // دسترسی اعضا (.)
// آرایه اندازه 0 دارد
sizes[ 2 ] = array.size();

به ترتیب 5، 4 و 0 را برمی گرداند.
عملگرهای بارگذاری شده مانند عملگرهای معمولی به یک شی اعمال می شوند:

نام رشته ("Yadie"); Stringname2 ("Yodie"); // عملگر bool==(const String&)
اگر (نام == نام 2)
برگشت؛
دیگر
// String& operator=(const String&)
name=name2;

یک اعلان تابع عضو باید در داخل تعریف کلاس باشد و یک تعریف تابع می تواند داخل یا خارج از تعریف کلاس باشد. (هر دو size() و c_str() در داخل یک کلاس تعریف شده اند.) اگر تابعی خارج از یک کلاس تعریف شده باشد، باید مشخص کنیم که به کدام کلاس تعلق دارد. در این مورد، تعریف تابع در یک فایل منبع، مثلا String.C، و تعریف خود کلاس در یک فایل هدر (در مثال ما String.h) قرار می‌گیرد، که باید در فایل منبع گنجانده شود:

// محتویات فایل منبع: String.C // شامل تعریف کلاس String
#include "String.h" // شامل تعریف تابع strcmp() است
#عبارتند از
bool // نوع برگشتی
رشته:: // کلاسی که تابع به آن تعلق دارد
عملگر== // نام تابع: عملگر برابری
(const String &rhs) // لیست پارامترها
{
if (_size != rhs._size)
بازگشت نادرست؛
strcmp(_stringq، rhs._string) را برگردانید؟
غلط درست؛
}

به یاد بیاورید که strcmp() یک تابع کتابخانه استاندارد C است که دو رشته نوع داخلی را با هم مقایسه می کند و اگر رشته ها مساوی باشند 0 و در غیر این صورت غیر صفر است. عملگر شرطی (?:) مقدار قبل از علامت سوال را آزمایش می کند. اگر درست باشد، مقدار عبارت سمت چپ کولون برگردانده می شود، در غیر این صورت در سمت راست دو نقطه است. در مثال ما، اگر strcmp() یک مقدار غیر تهی را برگرداند، مقدار عبارت false است و اگر null باشد true است. (اپراتور شرطی در بخش 4.7 پوشش داده شده است.)
عملیات مقایسه اغلب استفاده می شود، تابعی که آن را پیاده سازی می کند کوچک است، بنابراین مفید است که این تابع را داخلی (داخلی) اعلام کنید. کامپایلر متن تابع را به جای فراخوانی جایگزین می کند، بنابراین زمانی برای چنین فراخوانی صرف نمی شود. (توابع داخلی در بخش 7.6 مورد بحث قرار می گیرند.) یک تابع عضو که در یک کلاس تعریف شده است به طور پیش فرض داخلی است. اگر خارج از کلاس تعریف شده باشد، برای اعلام آن به صورت inline، باید از کلمه کلیدی inline استفاده کنید:

Inline bool String::operator==(const String &rhs) (// همینطور)

تعریف یک تابع درون خطی باید در یک فایل هدر حاوی تعریف کلاس باشد. با تعریف مجدد عملگر == به عنوان یک عملگر داخلی، باید خود متن تابع را از فایل String.C به فایل String.h منتقل کنیم.
در زیر اجرای عملیات مقایسه یک شی String با یک رشته نوع داخلی است:

bool درون خطی String::operator==(const char *s) ( return strcmp(_string, s) ? false: true; )

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

#عبارتند از // رشته درون خطی سازنده پیش فرض::String()
{
_size=0;
_string=0;
) Inline String::String(const char *str) ( if (! str) ( _size = 0; _string = 0; ) other ( _size = str1en(str); strcpy(_string, str);) // سازنده کپی
رشته درون خطی:: رشته (const String &rhs)
{
اندازه = rhs._size;
if(!rhs._string)
_string=0;
دیگر(
_string = کاراکتر جدید[_size + 1];
} }

از آنجایی که ما به صورت پویا حافظه را با عملگر جدید تخصیص دادیم، باید آن را با یک فراخوانی آزاد کنیم تا زمانی که دیگر به شی String نیاز نداریم، آن را حذف کنیم. یکی دیگر از عملکردهای عضو ویژه به این منظور خدمت می کند، تخریبگر، که به طور خودکار برای یک شیء زمانی که آن شیء وجود ندارد فراخوانی می شود. (به فصل 7 در مورد طول عمر شی مراجعه کنید.) نام یک تخریبگر از کاراکتر tilde (~) و نام کلاس تشکیل شده است. در اینجا تعریف تخریبگر کلاس String آورده شده است. اینجاست که ما عملیات حذف را برای آزاد کردن حافظه اختصاص داده شده در سازنده فراخوانی می کنیم:

رشته درون خطی: :~String() (حذف _string;)

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

نام رشته ("اورویل")، name2 ("ویلبر");
name = "Orville Wright";
این یک اشاره گر است که به شی name1 در بدنه تابع عملیات تخصیص آدرس می دهد.
این همیشه به شی کلاسی که تابع از طریق آن فراخوانی می شود اشاره می کند. اگر
ptr->size();
obj[1024];

سپس در داخل size() مقدار این آدرس ذخیره شده در ptr خواهد بود. در داخل عملیات get index، این شامل آدرس obj است. با عدم ارجاع به این (با استفاده از *this)، خود شی را دریافت می کنیم. (این اشاره گر به تفصیل در بخش 13.4 توضیح داده شده است.)

رشته و رشته درون خطی::operator=(const char *s) (اگر (! s) ( _size = 0؛ حذف _string؛ _string = 0; ) دیگری ( _size = str1en(s؛ حذف _string؛ _string = کاراکتر جدید[ _size + 1 ]; strcpy(_string, s); ) *this;)

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

رشته و رشته درون خطی::operator=(const String &rhs) ( // در عبارت // namel = *pointer_to_string // this is name1, // rhs - *pointer_to_string. if (this != &rhs) (

در اینجا متن کامل عملیات اختصاص دادن یک شی از همان نوع به یک شی String است:

رشته و رشته درون خطی::operator=(const String &rhs) ( if (this != &rhs) (حذف _string؛ _size = rhs._size؛ if (! rhs._string)
_string=0;
دیگر(
_string = کاراکتر جدید[_size + 1];
strcpy(_string, rhs._string);
}
}
بازگشت *این;
}

عملیات زیرنویس تقریباً مشابه پیاده سازی آرایه ای است که در بخش 2.3 ایجاد کردیم:

#عبارتند از کاراکتر درون خطی&
رشته::عملگر (عنصر int)
{
عنوان (elem >= 0 && elem< _size);
بازگشت _string[elem];
}

عملگرهای ورودی و خروجی به عنوان توابع مجزا و نه اعضای کلاس پیاده سازی می شوند. (در بخش 15.2 به دلایل این موضوع خواهیم پرداخت. بخش های 20.4 و 20.5 بارگذاری بیش از حد عملگرهای ورودی و خروجی کتابخانه iostream را مورد بحث قرار می دهند.) اپراتور ورودی ما نمی تواند بیش از 4095 کاراکتر را بخواند. setw() یک دستکاری کننده از پیش تعریف شده است، تعداد مشخص شده کاراکترها را منهای 1 از جریان ورودی می خواند، بنابراین اطمینان می دهد که بافر داخلی inBuf سرریز نمی شود. (فصل 20 به طور مفصل درباره دستکاری‌کننده setw() بحث می‌کند.) برای استفاده از دستکاری‌کننده‌ها، باید فایل هدر مناسب را وارد کنید:

#عبارتند از istream& عملگر داخلی>>(istream &io، String &s) (// محدودیت مصنوعی: 4096 کاراکتر const int 1imit_string_size = 4096; char inBuf[ limit_string_size ]; // setw() بخشی از کتابخانه iostream است // بلوک خوانده شده را محدود می کند اندازه به 1imit_string_size -l io >> setw(1imit_string_size) >> inBuf; s = mBuf; // String::operator=(const char*); return io; )

دستور خروجی نیاز به دسترسی به نمایش داخلی رشته دارد. از آنجایی که اپراتور<< не является функцией-членом, он не имеет доступа к закрытому члену данных _string. Ситуацию можно разрешить двумя способами: объявить operator<< дружественным классу String, используя ключевое слово friend (дружественные отношения рассматриваются в разделе 15.2), или реализовать встраиваемую (inline) функцию для доступа к этому члену. В нашем случае уже есть такая функция: c_str() обеспечивает доступ к внутреннему представлению строки. Воспользуемся ею при реализации операции вывода:

جریان داخلی و اپراتور<<(ostream& os, const String &s) { return os << s.c_str(); }

در زیر یک نمونه برنامه است که از کلاس String استفاده می کند. این برنامه کلمات را از جریان ورودی می گیرد و تعداد کل آنها و همچنین تعداد کلمات "the" و "it" را می شمارد و حروف صدادار مواجه شده را ثبت می کند.

#عبارتند از #include "String.h" int main() ( int aCnt = 0، eCnt = 0، iCnt = 0، oCnt = 0، uCnt = 0، theCnt = 0، itCnt = 0، wdCnt = 0، notVowel = 0؛ / / کلمات "The" و "It"
// با عملگر==(const char*) بررسی می کنیم
رشته but, the("the"), it("it"); // عملگر >> (ostream&، String&)
در حالی که (cin >> buf) (
++wdCnt; // اپراتور<<(ostream&, const String&)
کوت<< buf << " "; if (wdCnt % 12 == 0)
کوت<< endl; // String::operator==(const String&) and
// رشته::operator==(const char*);
if (buf == the | | buf == "The")
++theCnt;
دیگر
اگر (buf == آن || buf == "این")
++itCnt; // رشته::s-ize() را فراخوانی می کند
برای (int ix = 0; ix< buf.sizeO; ++ix)
{
// رشته:: عملگر(int) را فراخوانی می کند
سوئیچ (buf[ix])
{
case "a": case "A": ++aCnt; زنگ تفريح؛
مورد "e": مورد "E": ++eCnt; زنگ تفريح؛
case "i": مورد "I": ++iCnt; زنگ تفريح؛
case "o": case "0": ++oCnt; زنگ تفريح؛
case "u": case "U": ++uCnt; زنگ تفريح؛
پیش فرض: ++notVowe1; زنگ تفريح؛
}
}
) // اپراتور<<(ostream&, const String&)
کوت<< "\n\n"
<< "Слов: " << wdCnt << "\n\n"
<< "the/The: " << theCnt << "\n"
<< "it/It: " << itCnt << "\n\n"
<< "согласных: " < << "a: " << aCnt << "\n"
<< "e: " << eCnt << "\n"
<< "i: " << ICnt << "\n"
<< "o: " << oCnt << "\n"
<< "u: " << uCnt << endl;
}

بیایید برنامه را آزمایش کنیم: یک پاراگراف از یک داستان کودکانه نوشته یکی از نویسندگان این کتاب را به آن پیشنهاد می کنیم (در فصل 6 با این داستان آشنا خواهیم شد). این هم خروجی برنامه:

آلیس اِما موهای بلند و قرمزی دارد. باباش می گوید وقتی باد میان موهایش می زند، تقریباً زنده به نظر می رسد، مثل یک پرنده آتشین در حال پرواز. او به او می گوید که یک پرنده آتشین زیبا، جادویی اما رام نشده است. او به او می گوید: "بابا، شوش، چنین چیزی وجود ندارد." با خجالت می پرسد: یعنی بابا آنجا هست؟ کلمات: 65
the/The: 2
آن/آن: 1
حروف صامت: 190
a:22
e:30
من:24
تقریبا 10
u:7

تمرین 3.26

در پیاده سازی سازنده ها و عملگرهای انتساب ما تکرارهای زیادی وجود دارد. همانطور که در بخش 2.3 انجام دادیم، کد تکراری را به یک تابع عضو خصوصی جداگانه منتقل کنید. مطمئن شوید که گزینه جدید کار می کند.

تمرین 3.27

برنامه آزمون را تغییر دهید تا صامت های b، d، f، s، t را نیز بشمارید.

تمرین 3.28

یک تابع عضو بنویسید که با استفاده از اعلان زیر تعداد وقوع یک کاراکتر را در یک رشته می‌شمارد:

Class String ( public: // ... int count(char ch) const; // ... );

تمرین 3.29

عملگر الحاق رشته (+) را طوری پیاده کنید که دو رشته را به هم متصل کرده و نتیجه را در یک شی String جدید برگرداند. در اینجا اعلان تابع است:

Class String ( public: // ... String operator+(const String &rhs) const; // ... );

یک نوع داده در برنامه نویسی مجموعه ای از دو مجموعه است: مجموعه ای از مقادیر و مجموعه ای از عملیات که می توان برای آنها اعمال کرد. به عنوان مثال، نوع داده اعداد صحیح غیر منفی، که از مجموعه محدودی از اعداد طبیعی تشکیل شده است، می تواند برای عملیات جمع (+)، ضرب (*)، تقسیم اعداد صحیح (/)، باقیمانده (%) اعمال شود. و تفریق (-).

یک زبان برنامه نویسی معمولاً دارای مجموعه ای از انواع داده های اولیه است - انواعی که توسط زبان برنامه نویسی به عنوان یک واحد داخلی پایه ارائه می شود. در C++، خالق زبان این گونه انواع را انواع بنیادی می نامد. انواع اساسی در C++ عبارتند از:

• بولی (بول)؛
• شخصیت (به عنوان مثال، کاراکتر)؛
• عدد صحیح (به عنوان مثال int)؛
• نقطه شناور (به عنوان مثال شناور).
• enums (تعریف شده توسط برنامه نویس)؛
• خالی .

در بالای موارد فوق، انواع زیر ساخته شده است:

• اشاره گر (به عنوان مثال، int*)؛
• آرایه ها (به عنوان مثال char)؛
• مرجع (به عنوان مثال double&);
• ساختارهای دیگر

بیایید به مفهوم یک کلمه (به عنوان مثال، 1، 2.4F، 25e-4، 'a'، و غیره) برویم: literal ورودی در کد منبع یک برنامه است که یک مقدار ثابت را نشان می دهد. به عبارت دیگر، Literal صرفاً نمایشی از یک شی (مقدار) از نوعی در کد برنامه است. C++ توانایی نوشتن مقادیر صحیح، مقادیر ممیز شناور، کاراکتر، بولی، مقادیر رشته را دارد.

Literal نوع صحیح را می توان به صورت زیر نوشت:

• سیستم شماره 10. برای مثال 1205 ;
• سیستم شماره هشتم با فرمت 0 + عدد. به عنوان مثال، 0142 ;
• سیستم شماره شانزدهم با فرمت 0x + عدد. به عنوان مثال، 0x2F.

24، 030، 0x18 همه ورودی های یکسان در سیستم های اعداد مختلف هستند.
برای نوشتن اعداد ممیز شناور، از علامت نقطه استفاده می شود: 0.1، 0.5، 4. - یا در
نماد نمایی - 25e-100. در چنین رکوردی نباید هیچ فاصله ای وجود داشته باشد.

نامی که می توانیم مقادیر نوشته شده توسط literals را با آن مرتبط کنیم متغیر نامیده می شود. متغیر یک مکان نامگذاری شده یا آدرس پذیر دیگری در حافظه است که آدرس آن می تواند برای دسترسی به داده ها استفاده شود. این داده ها در حین اجرای برنامه به روش خاصی در حافظه نوشته، بازنویسی و پاک می شوند. متغیر به شما امکان می دهد در هر زمان به داده ها دسترسی داشته باشید و در صورت لزوم آنها را تغییر دهید. داده هایی که می توانند از نام متغیر بازیابی شوند، مقدار متغیر نامیده می شوند.
برای استفاده از یک متغیر در برنامه باید آن را اعلان کرد و در صورت لزوم می توان آن را تعریف کرد (= مقداردهی اولیه). یک اعلان متغیر در متن برنامه لزوماً شامل 2 بخش است: نوع پایه و اعلام کننده. مشخص کننده و اولیه بخش های اختیاری هستند:

const int مثال = 3; // اینجا const - specifier // int - نوع پایه // مثال - نام متغیر // = 3 - مقداردهی اولیه.

نام متغیر دنباله ای از کاراکترها از حروف الفبای لاتین (کوچک و بزرگ)، اعداد و/یا زیرخط است، اما کاراکتر اول نمی تواند رقمی باشد. نام متغیر باید به گونه ای انتخاب شود که همیشه به راحتی بتوان حدس زد که چه چیزی را ذخیره می کند، به عنوان مثال "monthPayment". به صورت انتزاعی و عملی، از نماد CamelCase برای قوانین نوشتن متغیرها استفاده می کنیم. نام یک متغیر نمی تواند با کلمات رزرو شده در زبان مطابقت داشته باشد، نمونه هایی از این کلمات: if، while، function، goto، switch و غیره.

اعلام کننده، علاوه بر نام متغیر، می تواند شامل کاراکترهای اضافی نیز باشد:

• * - اشاره گر؛ قبل از نام
• *const - نشانگر ثابت؛ قبل از نام
• & - ارتباط دادن؛ قبل از نام
• - آرایه؛ بعد از نام؛
• () - تابع؛ بعد از نام

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

مشخص کننده ویژگی های اضافی غیر از نوع را مشخص می کند. مشخص کننده const داده شده در مثال به شما امکان می دهد تغییرات بعدی در مقدار متغیر را ممنوع کنید. این گونه متغیرهای تغییرناپذیر ثابت یا ثابت نامیده می شوند.

اعلان یک ثابت بدون مقداردهی اولیه به دلایل منطقی کار نخواهد کرد:

Const int EMPTY_CONST; // خطا، متغیر ثابت اولیه نشده const int EXAMPLE = 2; // ثابت با مقدار 2 EXAMPLE = 3; // خطا، تلاش برای اختصاص یک مقدار به یک متغیر ثابت

برای نامگذاری ثابت ها، مرسوم است که فقط از حروف بزرگ استفاده کنید و کلمات را با یک کاراکتر زیر خط جدا کنید.

انواع داده های پایه در C++

در تشریح هر نوع، خواننده باید به خاطر داشته باشد که نوع داده را تعریف کند.

1. نوع عدد صحیح (char، short (int)، int، long (int، long long)

از نام به راحتی می توان فهمید که مجموعه مقادیر از اعداد صحیح تشکیل شده است. همچنین مجموعه مقادیر هر یک از انواع فهرست شده می تواند دارای علامت (امضا) یا بدون علامت (بدون علامت) باشد. تعداد عناصر موجود در یک مجموعه به اندازه حافظه مورد استفاده برای ذخیره مقدار آن نوع بستگی دارد. به عنوان مثال، برای متغیری از نوع char، 1 بایت حافظه اختصاص داده می شود، بنابراین کل عناصر به صورت زیر خواهد بود:

• 2 8N = 2 8 * 1 = 256، که در آن N مقدار حافظه در بایت برای ذخیره مقدار است.

در چنین حالتی، محدوده اعداد صحیح موجود به شرح زیر است:

• - برای کاراکتر بدون امضا
• [-128..127] - برای کاراکتر امضا شده

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

مقادیر طولانی بدون علامت; // یک نوع بدون علامت عدد صحیح (طولانی) را تعریف می کند.

انواع ذکر شده فقط در میزان حافظه مورد نیاز برای ذخیره سازی متفاوت است. از آنجایی که زبان C++ یک استاندارد زبان نسبتاً مخصوص ماشین است، فقط شرایط زیر را تضمین می کند:

• 1 = اندازه کاراکتر ≤ اندازه کوتاه ≤ اندازه int ≤ اندازه بلند.

معمولاً اندازه انواع به شرح زیر است: char - 1، short - 2، int - 4، long - 8، long long - 8 بایت.

می توانید عملیات حسابی را با مقادیر نوع صحیح انجام دهید: +, -, *, /, %; عملیات مقایسه: ==، !=،<=, <, >، >=; عملیات بیت: &، |، xor،<<, >>.
درک اکثر عملیات مانند جمع، ضرب، تفریق و مقایسه آسان است. گاهی اوقات، پس از انجام عملیات حسابی، ممکن است نتیجه خارج از محدوده مقادیر باشد. در این صورت برنامه خطا می دهد.
تقسیم عدد صحیح (/) قسمت صحیح تقسیم یک عدد صحیح بر دیگری را پیدا می کند. مثلا:

• 6 / 4 = 1;
• 2 / 5 = 0;
• 8 / 2 = 4.

نماد درصد (%) عملیات تعیین باقیمانده تقسیم دو عدد صحیح را نشان می دهد:

• 6 % 4 = 2;
• 10 % 3 = 1.

درک عملیات به صورت بیتی دشوارتر است: & (AND)، | (OR)، xor (انحصاری OR)،<< (побитовый сдвиг влево), >> (تغییر بیتی به راست).

عملیات بیت AND، OR و XOR عملیات منطقی مربوطه را برای هر بیت از اطلاعات اعمال می کنند:

• 1 10 = 01 2
• 3 10 = 11 2
• 1 10 & 3 10 = 01 2 & 11 2 = 01 2
• 1 10 | 3 10 = 01 2 | 11 2 = 11 2
• 1 10 xor 3 10 = 01 2 xor 11 2 = 10 2

در پردازش تصویر، از 3 کانال برای رنگ استفاده می شود: قرمز، آبی و سبز - به علاوه شفافیت، که در متغیری از نوع int ذخیره می شود، زیرا هر کانال دارای محدوده ای از مقادیر از 0 تا 255 است. در هگزادسیمال، یک مقدار به صورت زیر نوشته می شود: 0x180013FF; سپس مقدار 18 16 مربوط به کانال قرمز، 00 16 - آبی، 13 16 - سبز، FF - کانال آلفا (شفافیت) است. برای انتخاب یک کانال خاص از چنین عدد صحیحی، از به اصطلاح استفاده کنید. ماسک، که در آن موقعیت های مورد علاقه ما F 16 یا 1 2 هستند. یعنی برای برجسته کردن مقدار کانال آبی، باید از ماسک استفاده کنید. به صورت بیتی و:

int blue_channel = 0x180013FF & 0x00FF0000;

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

یک شیفت بیتی هر تعداد بیت از یک عدد را که در سمت راست عملیات مشخص شده است به چپ یا راست تغییر می دهد. برای مثال عدد 39 برای نوع char به صورت باینری به صورت زیر نوشته می شود: 00100111. سپس:

Char binaryExample = 39; // 00100111 نتیجه کاراکتر = باینری مثال<< 2; // сдвигаем 2 бита влево, результат: 10011100

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

2. نوع نقطه شناور (شناور، دوگانه (شناور))

مجموعه مقادیر ممیز شناور زیر مجموعه ای از اعداد واقعی، اما هر عدد واقعی را نمی توان به صورت باینری نشان داد، که گاهی اوقات منجر به اشتباهات احمقانه می شود:

مقدار شناور = 0.2; مقدار == ​​0.2; // خطا، مقدار در اینجا برابر با 0.2 نخواهد بود.

هنگام کار با متغیرهای ممیز شناور، برنامه نویس نباید از عملیات برابری یا نابرابری استفاده کند، در عوض معمولاً از یک تست برای زدن یک بازه معین استفاده می کند:

مقدار - 0.2< 1e-6; // ok, подбирать интервал тоже нужно осторожно

علاوه بر عملیات مقایسه، نوع ممیز شناور از 4 عملیات حسابی پشتیبانی می کند که کاملاً با عملیات ریاضی با اعداد واقعی مطابقت دارد.

3. نوع بولی (منطقی) (bool)

فقط از دو مقدار تشکیل شده است: true (true) و false (false). برای کار با متغیرهایی از این نوع، از عملیات منطقی استفاده می شود: ! (نه)، == (برابری)، != (نابرابری)، && (و منطقی)، || (OR منطقی). نتیجه هر عملیات را می توان در جدول حقیقت مربوطه یافت. مثلا:

4. نوع کاراکتر (char، wchar_t)

نوع کاراکتر نه تنها یک نوع عدد صحیح است (معمولاً به چنین نوع بایتی گفته می شود)، بلکه یک نوع کاراکتر است که شماره کاراکتر جدول را به عنوان یک کاراکتر ASCII ذخیره می کند. به عنوان مثال، کد 0x41 با کاراکتر "A" و 0x71 - "t" مطابقت دارد.

گاهی اوقات لازم است از کاراکترهایی استفاده کنید که در جدول ASCII ثابت نیستند و بنابراین برای ذخیره شدن به بیش از 1 بایت نیاز دارند. یک شخصیت گسترده (wchar_t) برای آنها وجود دارد.

5.1. آرایه ها

آرایه ها به شما امکان می دهند مجموعه ای متوالی از عناصر از یک نوع را ذخیره کنید. یک آرایه در یک بلوک پیوسته در حافظه ذخیره می شود، بنابراین نمی توانید یک آرایه را بدون تعیین اندازه آن اعلام کنید. برای اعلام یک آرایه، بعد از نام متغیر، براکت () را بنویسید که اندازه آن را نشان می دهد. مثلا:

int myArray; // آرایه ای از 5 عنصر از نوع عدد صحیح

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

شانس int = (1، 3، 7، 9، 11); // آرایه با 5 مقدار مقداردهی اولیه می شود

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

شانس // دسترسی به اولین عنصر آرایه. شانس 1 را برمی گرداند. // دسترسی به عنصر سوم. مقدار 7 شانس = 13 را برمی گرداند. // یک مقدار جدید به عنصر پنجم شانس آرایه اختصاص دهید. // خطای دسترسی

5.3. رشته های

برای نوشتن یک رشته، برنامه نویسان از این ایده استفاده می کنند که یک رشته یک سری (آرایه) متوالی از کاراکترها است. برای شناسایی انتهای یک خط، استفاده کنید شخصیت خاصانتهای خط: '\0'. این کاراکترهای خاص که از یک بک اسلش و یک کاراکتر شناسایی تشکیل شده اند، کاراکترهای کنترل یا فرار نامیده می شوند. هنوز وجود دارد، برای مثال، '\n' - ابتدای یک خط جدید، '\t' - جدول بندی. برای ضبط یک بک اسلش در یک خط، از escaping استفاده می شود - یک اسلش دیگر قبل از خود علامت قرار می گیرد: '\'. از Escape برای نوشتن گیومه نیز استفاده می شود.

بیایید یک متغیر رشته ایجاد کنیم:

Char textExample = ('T', 'e', ​​'s', 't', '\0'); // رشته "Test" نوشته شده است

یک نماد ساده برای مقداردهی اولیه رشته وجود دارد:

Char textExample = "تست"; // آخرین کاراکتر نوشته نشده است، اما اندازه آن هنوز 5 است

بدون پرداختن به جزئیات، در اینجا یک نوع داده مفید دیگر وجود دارد - رشته. رشته های
از این نوع، برای مثال، می توانید اضافه کنید:

رشته سلام = "سلام، "; stringname = "Max!"; رشته hello_name = سلام + نام; // رشته "سلام، مکس!"

6. پیوند

Int a = 2; // متغیر "a" به مقدار 2 اشاره می کند int &b = a; // متغیر "b" به همان مکان "a" اشاره می کند b = 4; // با تغییر مقدار b، برنامه نویس مقدار a را تغییر می دهد. اکنون a = 4 int & c = 4; // خطا، شما نمی توانید این کار را انجام دهید، زیرا نمی توان به مرجع یک مقدار اختصاص داد

7. اشاره گر

برای مقابله با این نوع داده ها، لازم به یادآوری است که مجموعه مقادیر این نوع، آدرس سلول های حافظه است که داده ها از آنجا شروع می شوند. اشاره گر همچنین از عملیات جمع (+)، تفریق (-) و عدم ارجاع (*) پشتیبانی می کند.

آدرس‌های 0x0 به این معنی است که نشانگر خالی است، یعنی. به هیچ داده ای اشاره نمی کند. این آدرس به معنای واقعی کلمه خود را دارد - NULL:

Int *nullPtr = NULL; // نشانگر تهی

افزودن و تفریق یک آدرس با یک عدد صحیح یا آدرس دیگری اجازه می دهد
در حافظه موجود در برنامه حرکت کنید.

عملیات دریافت داده‌ها که از آدرس ذخیره شده در یک اشاره‌گر شروع می‌شود، عدم ارجاع (*) نامیده می‌شود. این برنامه تعداد مورد نیاز سلول های حافظه را می خواند و مقدار ذخیره شده در حافظه را برمی گرداند.

Int valueInMemory = 2; // یک متغیر از نوع عدد صحیح تنظیم کنید int *somePtr = // آدرس متغیر را کپی کنید، در اینجا & - آدرس متغیر somePtr را برمی گرداند. // آدرس سلول حافظه، به عنوان مثال، 0x2F *somePtr; مقدار // در 4 سلول ذخیره می شود: 0x2F، 0x30، 0x31 و 0x32

برای اشاره گرها، عملیات انتساب، که از نظر نحوی همان عملیات کپی است، در دسترس نیست. به عبارت دیگر، شما می توانید آدرس یک اشاره گر دیگر یا آدرس یک متغیر را کپی کنید، اما نمی توانید مقدار آدرس را خودتان تعیین کنید.

خود اشاره گر مانند مقادیر متغیرهای انواع دیگر در حافظه ذخیره می شود و 4 بایت طول می کشد، بنابراین می توانید یک اشاره گر به یک اشاره گر ایجاد کنید.

8. نقل و انتقالات

Enumerations تنها نوع پایه ای است که توسط برنامه نویس تعریف شده است. به طور کلی، شمارش مجموعه‌ای مرتب از ثابت‌های عدد صحیح نام‌گذاری‌شده است که نام شمارش نوع پایه آن است.

Enumcolor (قرمز، آبی، سبز)؛

به طور پیش فرض، قرمز = 0، آبی = 1، سبز = 2. بنابراین، مقادیر را می توان با یکدیگر مقایسه کرد، به عنوان مثال. قرمز< BLUE < GREEN. Программист при объявлении перечисления может самостоятельно задать значения каждой из констант:

دسترسی به فهرست (READ=1، WRITE=2، EXEC=4)؛

اغلب استفاده از شمارش هایی که مقادیر آنها توان دو است راحت است، زیرا در نمایش باینری، عددی که توان 2 است از واحد 1 و صفر تشکیل می شود. مثلا:

8 10 = 00001000 2

نتیجه جمع کردن این اعداد با هم همیشه به وضوح نشان می دهد که کدام اعداد اضافه شده اند:

37 10 = 00100101 2 = 00000001 2 + 00000100 2 + 00100000 2 = 1 10 + 4 10 + 32 10

خالی

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

شیء خالی؛ // خطا، هیچ شیئی از نوع void void // خطا وجود ندارد، هیچ ارجاعی به void void *ptr وجود ندارد. // خوب، یک اشاره گر را به یک نوع ناشناخته ذخیره کنید

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

قالب

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

int عدد صحیح = 2; floating floating = عدد صحیح; // شناور = 2.0

تبدیل نوع با از دست دادن اطلاعات انجام می شود، بنابراین فقط قسمت صحیح عدد ممیز شناور باقی می ماند، قسمت کسری از بین می رود.

امکان تبدیل نوع صریح (به صراحت) وجود دارد، برای این کار، در سمت چپ متغیر یا مقداری از نوع اصلی، در داخل پرانتز، نوع ریخته گری را بنویسید:

مقدار int = (int) 2.5;

عملیات واحد و باینری

به عملیاتی که قبلا انجام دادیم باینری می گویند: در سمت چپ و سمت راست نماد عملیات مقادیر یا متغیرهایی وجود دارد، به عنوان مثال، 2 + 3. علاوه بر عملیات باینری، زبان های برنامه نویسی از عملیات یونری نیز استفاده می کنند. که برای متغیرها اعمال می شود. آنها می توانند در سمت چپ یا راست یک متغیر باشند، چندین عملیات از این قبیل قبلاً با آن مواجه شده اند - عملیات ارجاع (*) و گرفتن آدرس یک متغیر (&) یکسان هستند. عملگرهای "++" و "-" مقدار یک متغیر عدد صحیح را به ترتیب 1 افزایش و کاهش می دهند و می توانند در سمت چپ یا راست متغیر نوشته شوند.

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

A += 2; // مشابه a = a + 2; b /= 5; // مانند b = b / 5; c &= 3; // مانند c = c & 3;

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

با تایپ پویا، یک متغیر در زمان مقداردهی اولیه با یک نوع مرتبط است. به نظر می رسد که یک متغیر در قسمت های مختلف کد می تواند انواع مختلفی داشته باشد. تایپ پویا توسط Java Script، Python، Ruby، PHP پشتیبانی می شود.

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

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

x = 1 + "2"؛ //error - نمی توانید یک علامت کاراکتر به عدد اضافه کنید

نمونه ای از تایپ ضعیف

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

کلاس های حافظه

متغیرها صرف نظر از نوعشان، دامنه و طول عمر خود را دارند.

کلاس های حافظه:

• خودکار؛
• استاتیک؛
• خارجی؛
• ثبت نام.

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

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

متغیر خارجی جهانی است. در هر قسمت از کد و حتی در فایل دیگری موجود است.

مشخص‌کننده‌های نوع داده در C ممکن است در موارد زیر حذف شوند:

1. همه متغیرهای داخل بلوک متغیر نیستند؛ بر این اساس، اگر قرار است از این کلاس ذخیره‌سازی خاص استفاده شود، مشخص‌کننده خودکار مشخص نمی‌شود.
2. همه توابع اعلام شده خارج از یک بلوک یا تابع به طور پیش فرض جهانی هستند، بنابراین مشخص کننده خارجی اختیاری است.

برای تعیین انواع ساده، مشخص کننده های int، char، float یا double مشخص می شوند. اصلاح کننده های بدون علامت (بدون علامت)، امضا شده (امضا)، کوتاه، طولانی، طولانی می توانند جایگزین متغیرها شوند.

به طور پیش فرض، همه اعداد امضا شده اند، بنابراین آنها فقط می توانند در محدوده اعداد مثبت باشند. برای تعریف متغیری از نوع char به صورت signed، signed char را بنویسید. طولانی، طولانی طولانی و کوتاه نشان می دهد که چقدر فضای حافظه برای ذخیره سازی اختصاص داده شده است. بزرگ ترین بلند بلند، کوچکترین کوتاه است.

Char کوچکترین نوع داده در C است. فقط 1 بایت حافظه به مقادیر ذخیره شده اختصاص داده شده است. به یک متغیر از نوع کاراکتر معمولاً کاراکترهایی اختصاص می‌یابد، و معمولاً به ارقام اختصاص می‌یابد. مقادیر کاراکترها در گیومه قرار می گیرند.

نوع int اعداد صحیح را ذخیره می کند، اندازه آن تعریف نشده است - بسته به معماری رایانه، حداکثر 4 بایت حافظه را می گیرد.

تبدیل صریح یک متغیر بدون علامت به صورت زیر ارائه می شود:

حالت ضمنی به این صورت است:

اعداد را با یک نقطه شناور و دوبار تعریف کنید. شناورها به صورت -2.3 یا 3.34 نمایش داده می شوند. Double برای دقت بیشتر استفاده می شود - ارقام بیشتری بعد از جداکننده اعشاری مشخص می شوند. این نوع فضای حافظه بیشتری نسبت به شناور اشغال می کند.

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

نوع بولی

در تست های وضعیت و حلقه ها استفاده می شود. فقط دو معنی دارد:

• درست است، واقعی؛
• دروغ.

مقادیر بولی را می توان به مقدار int تبدیل کرد. True معادل یک و false برابر با صفر است. تبدیل نوع فقط بین bool و int ارائه می شود، در غیر این صورت کامپایلر خطا ایجاد می کند.

if (x) (//خطا: "نمی توان به طور ضمنی نوع 'int' را به 'bool' تبدیل کرد""

if (x != 0) // راه C#

رشته ها و آرایه ها

آرایه ها انواع داده های پیچیده در C هستند. JS مانند جاوا اسکریپت یا روبی با رشته ها کار نمی کند. در C، تمام رشته ها آرایه هایی از عناصر ارزش کاراکتر هستند. رشته ها با بایت تهی به پایان می رسند.

اپراتورهای اعلامیه

ثابت های SI

در C نیز می توانید متغیرهایی ایجاد کنید که مقدار ثابتی دارند (مقدار آنها قابل تغییر نیست). اعلان چنین "متغیرهایی" دارای نحو زیر است: نوع const name1=value1[,name2=value2[,...]]; مثال ها:
const بدون علامت int x=80, y=25;
const double pi=3.1415;

اپراتور برای ایجاد انواع داده در SI