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

تمرین 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& operator داخلی>>(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; // ... );

آخرین به روز رسانی: 1396/09/17

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

bool : نوع بولی. می تواند یکی از دو مقدار true (true) و false (false) را بگیرد. ردپای حافظه برای این نوع دقیقاً تعریف نشده است.

char : نشان دهنده یک کاراکتر ASCII است. 1 بایت (8 بیت) در حافظه اشغال می کند. می تواند هر مقداری از -128 تا 127 یا 0 تا 255 را ذخیره کند

علامت امضا شده: نشان دهنده یک کاراکتر است. 1 بایت (8 بیت) در حافظه اشغال می کند. می تواند هر مقداری را بین -128 و 127 ذخیره کند

char unsigned: نشان دهنده یک کاراکتر است. 1 بایت (8 بیت) در حافظه اشغال می کند. می تواند هر مقداری بین 0 تا 255 را ذخیره کند

wchar_t : نشان دهنده یک کاراکتر گسترده است. در ویندوز 2 بایت (16 بیت) در حافظه مصرف می کند، در لینوکس 4 بایت (32 بیت). می تواند هر مقدار را از 0 تا 65535 (برای 2 بایت) یا از 0 تا 4294967295 (برای 4 بایت) ذخیره کند.

char16_t : نشان دهنده یک کاراکتر یونیکد است. 2 بایت (16 بیت) در حافظه اشغال می کند. می تواند هر مقدار از 0 تا 65535 را ذخیره کند

char32_t : نشان دهنده یک کاراکتر یونیکد است. 4 بایت (32 بیت) در حافظه اشغال می کند. می تواند هر مقداری از 0 تا 4294967295 را ذخیره کند

short : یک عدد صحیح را در محدوده -32768 تا 32767 نشان می دهد. 2 بایت (16 بیت) در حافظه اشغال می کند.

این نوع همچنین دارای مترادف های short int , signed short int , signed short است .

کوتاه بدون علامت : یک عدد صحیح را در محدوده 0 تا 65535 نشان می دهد. 2 بایت (16 بیت) در حافظه اشغال می کند.

این نوع همچنین دارای مترادفی برای int کوتاه بدون علامت است.

int : یک عدد صحیح را نشان می دهد. بسته به معماری پردازنده، می تواند 2 بایت (16 بیت) یا 4 بایت (32 بیت) طول بکشد. محدوده مقادیر حدی نیز به ترتیب می تواند از 32768- تا 32767 (برای 2 بایت) یا از -2 147 483 648 تا 2 147 483 647 (برای 4 بایت) متغیر باشد. اما در هر صورت سایز باید بزرگتر یا مساوی سایز نوع کوتاه و کمتر یا مساوی سایز نوع بلند باشد.

این نوع دارای مترادف های امضا شده و امضا شده است.

int بدون علامت: یک عدد صحیح مثبت را نشان می دهد. بسته به معماری پردازنده، می تواند 2 بایت (16 بیت) یا 4 بایت (32 بیت) طول بکشد، و به همین دلیل، محدوده مقادیر حدی می تواند متفاوت باشد: از 0 تا 65535 (برای 2 بیت) بایت)، یا از 0 تا 4294967295 (برای 4 بایت).

بدون علامت می تواند به عنوان مترادف برای این نوع استفاده شود.

long : یک عدد صحیح را در محدوده -2147483648 تا 2147483647 نشان می دهد. 4 بایت (32 بیت) حافظه را اشغال می کند.

این نوع همچنین دارای مترادف های long int ، signed long int و signed long است

طولانی بدون علامت: یک عدد صحیح را در محدوده 0 تا 4294967295 نشان می دهد. 4 بایت (32 بیت) حافظه را اشغال می کند.

مترادفی برای int طولانی بدون علامت دارد.

long long : یک عدد صحیح در محدوده -9223372036854775808 تا +9223372036854775807 را نشان می دهد. معمولاً 8 بایت (64 بیت) در حافظه.

دارای مترادف long long int , signed long long int و signed long long .

طولانی بدون علامت: یک عدد صحیح را در محدوده 0 تا 18446744073709551615 نشان می دهد. معمولاً 8 بایت (64 بیت) در حافظه است.

مترادفی برای int طولانی بدون علامت دارد.

float: یک عدد ممیز شناور با دقت معمولی را در محدوده +/- 3.4E-38 تا 3.4E+38 نشان می دهد. 4 بایت (32 بیت) حافظه را اشغال می کند

double : یک عدد ممیز شناور با دقت مضاعف را در محدوده +/- 1.7E-308 تا 1.7E+308 نشان می دهد. 8 بایت (64 بیت) حافظه را اشغال می کند

long double : یک عدد واقعی ممیز شناور با دقت دو برابر حداقل 8 بایت (64 بیت) را نشان می دهد. بسته به اندازه حافظه اشغال شده، محدوده مقادیر معتبر ممکن است متفاوت باشد.

void : بدون مقدار تایپ کنید

بنابراین، تمام انواع داده ها به جز void را می توان به سه گروه تقسیم کرد: کاراکتر (char، wchar_t، char16_t، char32_t)، عدد صحیح (short، int، long، long long) و انواع ممیز شناور (float، double، long double).

انواع شخصیت

یک برنامه از انواع char، wchar_t، char16_t و char32_t برای نمایش کاراکترها استفاده می کند.

بیایید چند متغیر تعریف کنیم:

Charc="d"; wchar_td="c";

متغیری از نوع char یک کاراکتر در گیومه تکی به عنوان مقدار خود می گیرد: char c = "d" . همچنین می توانید عددی را از محدوده مشخص شده در فهرست بالا اختصاص دهید: char c = 120 . در این حالت، مقدار متغیر c، کاراکتری خواهد بود که در جدول کاراکترهای اسکی دارای کد 120 است.

شایان ذکر است که برای خروجی کاراکترهای wchar_t به کنسول، نباید از std::cout استفاده کنید، بلکه از std::wcout stream استفاده کنید:

#عبارتند از int main() (char a = "H"؛ wchar_t b = "e"؛ std::wcout<< a << b << "\n"; return 0; }

در عین حال، جریان std::wcout می تواند با char و wchar_t کار کند. و جریان std::cout برای متغیر wchar_t کد عددی خود را به جای کاراکتر نمایش می دهد.

استاندارد C++11 انواع char16_t و char32_t را اضافه کرد که یونیکد گرا هستند. با این حال، در سطح سیستم‌عامل، رشته‌هایی برای کار با این انواع هنوز پیاده‌سازی نشده‌اند. بنابراین، اگر نیاز به نمایش مقادیر متغیرهای این نوع در کنسول دارید، باید متغیرها را به انواع char یا wchar_t تبدیل کنید:

#عبارتند از int main() (char a = "H"؛ wchar_t b = "e"؛ char16_t c = "l"؛ char32_t d = "o"؛ std::cout<< a << (char)b << (char)c << (char)d << "\n"; return 0; }

در این حالت، خروجی با cast به char - (char) قبل از متغیرها قرار می گیرد، به طوری که مقادیر متغیرهای b، c و d به char تبدیل می شوند و می توان با استفاده از std در کنسول چاپ کرد: جریان cout.

انواع عدد صحیح

انواع اعداد صحیح با انواع زیر نشان داده می شوند: کوتاه، کوتاه بدون علامت، int، بدون علامت int، طولانی، بدون علامت طولانی، طولانی طولانی، و بدون علامت طولانی طولانی:

کوتاه a = -10; کوتاه بدون علامت b= 10; int c = -30; بدون علامت int d = 60; طولانی e = -170; طولانی بدون علامت f = 45; بلند بلند g = 89;

انواع نقطه شناور

انواع ممیز شناور و/یا کسری با انواعی مانند float، double و long double نشان داده می شوند:

شناور a = -10.45; دو برابر b = 0.00105; طولانی دو برابر c = 30.890045;

اندازه های نوع داده

در لیست بالا، برای هر نوع، اندازه ای که در حافظه اشغال می کند مشخص شده است. با این حال، شایان ذکر است که توسعه دهندگان کامپایلر می توانند محدودیت های اندازه برای انواع را به تنهایی بر اساس قابلیت های سخت افزاری رایانه انتخاب کنند. استاندارد فقط حداقل مقادیری را که باید باشد را تعیین می کند. به عنوان مثال، برای انواع int و short حداقل مقدار 16 بیت، برای نوع طولانی 32 بیت، برای نوع long double است. در این صورت اندازه نوع بلند نباید از اندازه نوع int کمتر باشد و اندازه نوع int نباید از اندازه نوع کوتاه و اندازه نوع بلند دوبل باید کمتر باشد. بزرگتر از دو برابر باشد به عنوان مثال، کامپایلر g++ در ویندوز از 12 بایت برای دوبل طولانی استفاده می کند، در حالی که کامپایلر تعبیه شده در ویژوال استودیو و همچنین اجرا می شود، از 8 بایت برای دوبل طولانی استفاده می کند. یعنی حتی در یک پلتفرم، کامپایلرهای مختلف می توانند اندازه برخی از انواع داده ها را به روش های مختلف نزدیک کنند. اما به طور کلی، از اندازه هایی استفاده می شود که در بالا هنگام توصیف انواع داده ها نشان داده شده است.

با این حال، شرایطی وجود دارد که شما باید دقیقاً اندازه یک نوع خاص را بدانید. و برای این کار، C++ دارای عملگر sizeof() است که اندازه حافظه را بر حسب بایت برمی‌گرداند که یک متغیر اشغال می‌کند:

#عبارتند از int main() (عدد دوبل طولانی = 2؛ std::cout<< "sizeof(number) =" << sizeof(number); return 0; }

خروجی کنسول هنگام کامپایل به g++:

sizeof(تعداد) = 12

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

شماره کوتاه بدون امضا = -65535;

کامپایلر G++ هنگام کامپایل کردن برنامه با این خط، با این خطا که مقدار -65535 در محدوده مقادیر معتبر برای نوع کوتاه بدون علامت نیست و کوتاه می شود، می دهد.

در ویژوال استودیو، کامپایل ممکن است بدون خطا بگذرد، اما متغیر عدد روی 2 تنظیم می شود که نتیجه تبدیل -65535 به یک کوتاه بدون علامت است. یعنی باز هم نتیجه دقیقاً آن چیزی که انتظار می رود نخواهد بود. مقدار یک متغیر فقط مجموعه ای از بیت ها در حافظه است که بر اساس نوع خاصی تفسیر می شوند. و برای انواع مختلف، مجموعه بیت های یکسانی را می توان متفاوت تفسیر کرد. بنابراین، در نظر گرفتن محدوده ای از مقادیر برای یک نوع معین هنگام تخصیص یک مقدار به یک متغیر مهم است.

مشخص کننده خودکار

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

شماره خودکار = 5;

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

این برگه تقلب اطلاعاتی در مورد انواع داده های اصلی زبان برنامه نویسی C++ و ویژگی های اجرای آنها ارائه می دهد. همچنین در انتهای رکورد جدولی با محدوده مقادیر این نوع وجود دارد.

مفهوم نوع داده

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

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

• نمایش داخلی داده ها در حافظه کامپیوتر؛
• مجموعه مقادیری که مقادیر از این نوع می توانند بگیرند؛
• عملیات و توابعی که می توان برای مقادیر این نوع اعمال کرد.

بر اساس این ویژگی ها، برنامه نویس نوع هر مقدار مورد استفاده در برنامه را برای نمایش اشیاء واقعی انتخاب می کند. یک اعلان نوع اجباری به کامپایلر اجازه می دهد تا اعتبار ساختارهای مختلف برنامه را بررسی کند. نوع مقدار، دستورالعمل‌های ماشینی را تعیین می‌کند که برای پردازش داده‌ها استفاده می‌شود.

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

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

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

1. int (عدد صحیح);
2. کاراکتر (شخصیت)؛
3. wchar_t (کاراکتر گسترده)؛
4. bool (بولی)؛
5. شناور (واقعی)؛
6. دوبل (واقعی با دقت مضاعف).

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

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

• کوتاه (کوتاه)؛
• طولانی (طولانی)؛
• امضا شده (نشانه)؛
• بدون امضا (بدون امضا).

نوع عدد صحیح (int)

اندازه نوع int توسط استاندارد تعریف نشده است، اما به کامپیوتر و کامپایلر بستگی دارد. برای یک پردازنده 16 بیتی، 2 بایت برای مقادیر از این نوع، برای یک پردازنده 32 بیتی - 4 بایت اختصاص داده می شود.

مشخص کننده کوتاه در جلوی نام نوع به کامپایلر می گوید که بدون توجه به ظرفیت پردازنده، 2 بایت برای تعداد مورد نیاز است. مشخص کننده طولانی به این معنی است که مقدار عدد صحیح 4 بایت خواهد بود. بنابراین در یک کامپیوتر 16 بیتی معادل های int و short int و در کامپیوتر 32 بیتی int و long int هستند.

نمایندگی داخلی مقادیر از نوع عدد صحیح - یک عدد صحیح در کد باینری. هنگام استفاده از مشخص کننده علامت، مهم ترین بیت عدد به عنوان علامت (0 - عدد مثبت، 1 - منفی) تفسیر می شود. مشخص‌کننده بدون علامت اجازه می‌دهد فقط اعداد مثبت نمایش داده شوند، زیرا مهم‌ترین رقم بخشی از کد عدد در نظر گرفته می‌شود. بنابراین، محدوده مقادیر نوع int به مشخص کننده ها بستگی دارد. محدوده‌های مقادیر مقادیر نوع عدد صحیح با مشخص‌کننده‌های مختلف برای رایانه‌های سازگار با IBM PC در جدول «محدوده‌های ارزش انواع داده‌های ساده» در انتهای ورودی آورده شده است.

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

ثابت هایی که در برنامه با آنها مواجه می شوند، مطابق با نوع آنها، یک نوع یا نوع دیگری را اختصاص می دهند. اگر این نوع به دلایلی برای برنامه نویس مناسب نیست، می تواند با استفاده از پسوندهای L، l (طولانی) و U، u (بدون علامت) نوع مورد نیاز را به صراحت مشخص کند. به عنوان مثال، ثابت 32L از نوع long و 4 بایت خواهد بود. می توانید از پسوندهای L و U به طور همزمان استفاده کنید، به عنوان مثال، 0x22UL یا 05Lu.

توجه داشته باشید

انواع short int، long int، signed int و unsigned int را می توان به ترتیب به short، long، signed و unsigned کوتاه کرد.

نوع کاراکتر (کاراکتر)

مقدار یک نوع کاراکتر، تعداد بایت‌هایی است که برای قرار دادن هر کاراکتری از مجموعه کاراکتر برای یک رایانه خاص کافی است، که منجر به نام نوع آن می‌شود. به طور معمول، این 1 بایت است. نوع کاراکتر مانند سایر انواع عدد صحیح می تواند دارای علامت یا بدون علامت باشد. مقادیر امضا شده می توانند مقادیری از -128 تا 127 را ذخیره کنند. هنگام استفاده از مشخص کننده بدون علامت، مقادیر می توانند از 0 تا 255 متغیر باشند. این برای ذخیره هر کاراکتری در مجموعه کاراکترهای ASCII 256 کاراکتری کافی است. مقادیر نوع char نیز برای ذخیره اعداد صحیحی که از مرزهای محدوده های مشخص شده تجاوز نمی کنند استفاده می شود.

نوع کاراکتر توسعه یافته (wchar_t)

نوع wchar_t برای کار با مجموعه ای از کاراکترها طراحی شده است که 1 بایت برای کدگذاری کافی نیست، مانند Unicode. اندازه این نوع به پیاده سازی بستگی دارد. به عنوان یک قاعده، با نوع کوتاه مطابقت دارد. ثابت های رشته ای از نوع wchar_t با پیشوند L نوشته می شوند، به عنوان مثال، L"Gates".

نوع بولی (bool)

مقادیر Boolean فقط می توانند مقادیر true و false را که کلمات رزرو شده هستند، بگیرند. نمایش داخلی false 0 (صفر) است. هر مقدار دیگری به عنوان درست تفسیر می شود. هنگامی که به یک نوع عدد صحیح تبدیل می شود، true مقدار 1 را دارد.

انواع ممیز شناور (شناور، دوبل و بلند دوبل)

استاندارد C++ سه نوع داده را برای ذخیره مقادیر واقعی تعریف می کند: float، double و long double.

انواع داده های ممیز شناور در حافظه کامپیوتر متفاوت از انواع داده های صحیح ذخیره می شوند. نمایش داخلی یک عدد واقعی از دو بخش تشکیل شده است - مانتیس و توان. در رایانه های سازگار با IBM PC، مقادیر شناور 4 بایت را اشغال می کنند که یک بیت برای علامت مانتیس، 8 بیت برای توان و 23 بیت برای مانتیس اختصاص داده می شود. مانتیس عددی بزرگتر از 1.0 اما کمتر از 2.0 است. از آنجایی که بالاترین رقم مانتیس همیشه 1 است، ذخیره نمی شود.

برای مقادیر نوع double با اشغال 8 بایت، 11 و 52 رقم به ترتیب برای دستور و مانتیس در نظر گرفته شده است. طول آخوندک دقت عدد را تعیین می کند، در حالی که طول نما محدوده آن را تعیین می کند.همانطور که در جدول انتهای ورودی مشاهده می کنید، با تعداد یکسانی از بایت های اختصاص داده شده برای مقادیر float و long int، محدوده مقادیر معتبر آنها بسیار متفاوت است. به دلیل فرم نمایندگی داخلی.

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

ثابت های ممیز شناور به طور پیش فرض از نوع double هستند. با استفاده از پسوندهای F, f (شناور) و L, l (طولانی) می توانید به صراحت نوع یک ثابت را مشخص کنید. برای مثال، ثابت 2E+6L از نوع long double و ثابت 1.82f از نوع float خواهد بود.

برای نوشتن برنامه های چند پلتفرمی، نمی توانید در مورد اندازه نوع int فرضیاتی داشته باشید. برای دریافت آن باید از عملگر sizeof استفاده کنید که اندازه نوع را بر حسب بایت برمی گرداند. به عنوان مثال، در یک سیستم عامل MS-DOS، sizeof(int) به 2 و در ویندوز 98 یا OS/2، نتیجه 4 خواهد بود.

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

sizeof(float) ≤ slzeof(دوبل) ≤ sizeof(طولان دوبل)
sizeof(char) ≤ slzeof(کوتاه) ≤ sizeof(int) ≤ sizeof(طولانی)

توجه داشته باشید

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

نوع خالی

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

محدوده ارزش انواع داده های ساده در C++ برای رایانه های سازگار با IBM PC

س: عبارت کامپیوتر سازگار با IBM PC به چه معناست؟
A: رایانه سازگار با IBM PC (eng. IBM PC compatible) - رایانه ای که از نظر معماری به رایانه های شخصی IBM، XT و AT نزدیک است. کامپیوترهای سازگار با IBM PC مبتنی بر ریزپردازنده‌های سازگار با Intel 8086 هستند (و همانطور که می‌دانید، تمام پردازنده‌های جدید اینتل کاملاً با 8086 سازگار هستند). در واقع، این تقریباً تمام رایانه های مدرن است.

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

برای انواع واقعی، جدول مقادیر مطلق مقادیر حداقل و حداکثر را نشان می دهد.

برچسب ها: انواع داده C++، خودکار، decltype، استنتاج نوع خودکار

انواع داده ها

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

مانند C، C++ یک زبان حساس به حروف کوچک و بزرگ است.

انواع داده های پایه

انواع داده های پایه در C++ را می توان به چند گروه تقسیم کرد

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

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

انواع داده های عدد صحیح همانطور که در C، آنها می توانند اصلاح کننده های امضا شده و بدون علامت داشته باشند. همانطور که در C، انواع اصلی عبارتند از char، int، long و long long. هیچ چیز جدیدی در اینجا ظاهر نشده است.

اعداد اعشاری. نشان دهنده انواع شناور، دوبل و دوبل طولانی است. در مقایسه با si چیز جدیدی نیست.

تمام انواعی که در بالا توضیح داده شد، حسابی نیز نامیده می شوند. علاوه بر آنها، یک نوع خالی نیز وجود دارد - void (همچنین در مقایسه با C چیز جدیدی نیست) و یک اشاره گر تهی. اکنون به جای NULL با ویژگی های شگفت انگیزش، یک نوع بنیادی جدید nullptr_t با یک مقدار nullptr وجود دارد که یک اشاره گر تهی را ذخیره می کند و فقط با خودش برابر است. در این حالت می توان آن را به یک اشاره گر تهی از نوع دلخواه فرستاد.

C++ نوع بولی را معرفی کرد. فقط دو مقدار ممکن true و false را ذخیره می کند.

C++ همچنین از بسیاری از انواع داده های ترکیبی پشتیبانی می کند که بعداً مورد بحث قرار خواهد گرفت.

اعلان و راه اندازی متغیرها

در C++، متغیرها را می‌توان در هر جایی از یک تابع اعلان کرد، نه فقط در ابتدای بلوک کد، متغیرها را می‌توان در داخل یک حلقه for نیز اعلان کرد.

شناور a; شناور b; floatsum; پله شناور؛ a = 3.0f; b = 4.3f; مجموع = 0.0f; گام = 0.05f. برای (float i = a; i< b; i += step) { sum += i * i; } float mid = sum / (b - a) / step;

متغیرها را می توان در هنگام ایجاد مقداردهی اولیه کرد، مانند C

int x = 0;

یا با استفاده از سازنده

intx(0); دو برابر d (3.2);

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

StructPoint (int x; int y; ); struct Point position = ( 3, 4 ); Point *pt = new Point(6, 8); int length(5);

استنتاج تایپ کنید

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

خودکار x = 3; //معادل int x = 3; نقطه خودکار = نقطه جدید; //معادل Point *point = new Point

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

int intX = 42; decltype(intX) intY = 33; //معادل int intY = 33; خودکار pt1 = newPoint; decltype(pt1) p2 = new Point(2, 6); //معادل //Point *pt1 = new Point; //Point *pt2 = new Point(2, 6)

رشته های

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

#عبارتند از #عبارتند از void main() ( std::string first_name = "Vasya"; std::string last_name = ( "Pupkin"); //رشته الحاق auto full_name = first_name + " " + last_name; std::string *department = std جدید ::string("بخش کپی و اسکن")؛ std::cout<< full_name << std::endl; //сравнение строк std::string a = "A"; std::string b = "B"; if (first_name.compare(last_name) >0) ( std::cout<< a + " >" + ب<< std::endl; } else { std::cout << a + " < " + b << std::endl; } //подстрока std::string subs = department->substr(0, 10); std::out<< subs << std::endl; //замена подстроки std::cout << last_name.replace(0, 1, "G") << std::endl; //вставка std::string new_department = department->insert(department->length()، " and shreddering"); std::out<< new_department << std::endl; delete department; system("pause"); }

در ادامه با جزئیات بیشتر با کتابخانه رشته استاندارد آشنا خواهیم شد.

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

• کاراکتر - شخصیت.

یک متغیر نوع char دارای اندازه 1 بایت است، مقادیر آن کاراکترهای مختلفی از جدول کد است، به عنوان مثال: 'f'، ':'، 'j' (هنگامی که در برنامه نوشته می شود، آنها در یک نقل قول قرار می گیرند. ).

• int یک عدد صحیح است.

اندازه یک متغیر از نوع int در استاندارد C تعریف نشده است. در اکثر سیستم های برنامه نویسی، اندازه یک متغیر از نوع int با اندازه کل کلمه ماشین مطابقت دارد. به عنوان مثال، در کامپایلرهای پردازنده های 16 بیتی، یک متغیر int اندازه 2 بایت دارد. در این حالت، مقادیر علامت گذاری شده این متغیر می تواند از -32768 تا 32767 باشد.

• شناور واقعی است

کلمه کلیدی float به شما اجازه می دهد تا متغیرهای ممیز شناور را تعریف کنید. مقادیر آنها دارای یک قسمت کسری است که با یک نقطه از هم جدا شده است، به عنوان مثال: -5.6، 31.28 و غیره. اعداد حقیقی را می توان به صورت ممیز شناور نیز نوشت، به عنوان مثال: -1.09e+4. عدد قبل از نماد "e" را آخوندک و بعد از "e" - ترتیب نامیده می شود. یک متغیر float 32 بیت در حافظه اشغال می کند. می تواند مقادیری در محدوده 3.4e-38 تا 3.4e+38 داشته باشد.

• دقت دو برابر واقعی؛

کلمه کلیدی double به شما امکان می دهد یک متغیر واقعی با دقت دوگانه تعریف کنید. دو برابر بیشتر از یک متغیر شناور فضای حافظه اشغال می کند. یک متغیر از نوع double می تواند مقادیری در محدوده 1.7e-308 تا 1.7e+308 داشته باشد.

• باطل - ارزشی ندارد.

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

انواع متغیر:

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

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

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

char تایپ کنید

char به صرفه ترین نوع است. نوع کاراکتر می تواند امضا شده یا بدون علامت باشد. به عنوان "char Signed" (نوع امضا شده) و "Signed char" (نوع بدون علامت) مشخص می شود. یک نوع علامت دار می تواند مقادیر را در محدوده -128 تا +127 ذخیره کند. بدون علامت - از 0 تا 255. 1 بایت حافظه (8 بیت) برای متغیر نوع char اختصاص داده شده است.

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

int را تایپ کنید

مقدار صحیح int می تواند کوتاه (کوتاه) یا طولانی (طولانی) باشد. کلمه کلیدی کوتاه بعد از کلیدواژه های امضا شده یا بدون امضا قرار می گیرد. بنابراین، انواعی وجود دارد: امضای کوتاه بین‌المللی، بدون علامت کوتاه بین‌المللی، امضای طولانی بین‌المللی، بدون علامت بلند int.

متغیری از نوع signed short int (signed short integer) می‌تواند مقادیری از -32768 تا +32767 داشته باشد، int short unsigned (عدد صحیح کوتاه بدون علامت) - از 0 تا 65535. دقیقاً دو بایت حافظه (16 بیت) برای آن اختصاص داده شده است. هر یک از آنها.

هنگام اعلام یک متغیر از نوع signed short int، کلمات کلیدی signed و short را می توان حذف کرد و چنین نوع متغیری را می توان به سادگی int اعلام کرد. همچنین می توان این نوع را با یک کلمه کلیدی کوتاه اعلام کرد.

یک متغیر short int بدون علامت را می توان به عنوان int بدون علامت یا کوتاه بدون علامت اعلام کرد.

هر int طولانی امضا شده یا طولانی int بدون علامت دارای 4 بایت حافظه (32 بیت) است. مقادیر متغیرهای این نوع می تواند به ترتیب از 2147483648- تا 2147483647 و از 0 تا 4294967295 متغیر باشد.

همچنین متغیرهایی از نوع long long int وجود دارد که 8 بایت حافظه (64 بیت) به آنها اختصاص داده شده است. آنها می توانند امضا یا بدون امضا باشند. برای نوع علامت دار، محدوده مقادیر از -9223372036854775808 تا 9223372036854775807، برای نوع بدون علامت، از 0 تا 18446744073709551615 است. یک کلمه علامت‌دار با دو کلید به سادگی می‌تواند طولانی باشد.

اعلان متغیرها

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

[modifiers] typespecifer id [, id] ...

اصلاح کننده ها کلمات کلیدی امضا شده، بدون امضا، کوتاه، طولانی هستند.
یک نوع مشخص کننده یک کلمه کلیدی char یا int است که نوع متغیری را که اعلام می شود مشخص می کند.
شناسه نام متغیر است.

Charx; int a, b, c; بدون امضا long long y;

هنگام اعلام یک متغیر، می توانید آن را مقداردهی اولیه کنید، یعنی یک مقدار اولیه به آن اختصاص دهید.

int x = 100;

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