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

• تبدیل صریحبرخلاف آنچه به طور ضمنی توسط برنامه نویس انجام می شود. چندین راه برای انجامش وجود دارد:

1. تبدیل به سبک سی: (شناور) الف
2. تبدیل به سبک C ++: شناور ()

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

static_cast<>() const_cast<>() reinterpret_cast<>() dynamic_cast<> ()

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

نوع Static_cast<Тип>(یک شی)؛

با استفاده از static_cast، نمی‌توانید constness را از یک متغیر حذف کنید، اما این در توان عبارت زیر است. const_cast- فقط زمانی استفاده می شود که لازم باشد ثابت ها را از جسم حذف کنیم. نحو به این صورت خواهد بود:

یک نوعconst_cast< یک نوع> (یک شی);

reinterpret_cast- برای تبدیل انواع مختلف، اعداد صحیح به اشاره گر و بالعکس استفاده می شود. اگر کلمه جدید "اشاره گر" را می بینید - نگران نباشید! این نیز یک نوع داده است، اما به زودی با آن کار نخواهیم کرد. نحو در اینجا مانند عملگرهایی است که قبلاً در نظر گرفته شده بود:

یک نوعتفسیر مجدد_قالب< یک نوع> (یک شی);

dynamic_cast- برای تبدیل نوع پویا استفاده می شود، ریخته گری اشاره گرها یا پیوندها را اجرا می کند. نحو:

یک نوعپویا _قالب< یک نوع> (یک شی);

شخصیت ها را کنترل کنید

شما قبلاً با برخی از این "کاراکترهای کنترل" آشنا هستید (مثلاً با \ n). همه آنها با یک بک اسلش شروع می شوند و همچنین توسط نقل قول های دوگانه احاطه شده اند.

تفاوت مهم بین زبان C و سایر زبان ها (PL1، FORTRAN و غیره) عدم وجود یک اصل پیش فرض است که منجر به نیاز به اعلام صریح همه متغیرهای مورد استفاده در برنامه همراه با نشان دادن انواع مربوط به آنها می شود. .

اعلان های متغیر دارای فرمت زیر هستند:

[memory-class-specifier] type-specifier specifier [= Initiator] [, specifier [= Initiator]] ...

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

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

Initiator - یک مقدار اولیه یا لیستی از مقادیر اولیه را مشخص می کند که (که) در زمان اعلام به یک متغیر اختصاص داده می شود.

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

1.2.1 دسته بندی نوع داده

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

انواع عدد صحیح: انواع شناور: char float int دوبل کوتاه بلند دوبل علامت بلند بدون علامت

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

Const double A = 2.128E-2; const B = 286; (به معنی Const int B = 286 است)

نمونه هایی از اعلان داده های ترکیبی در زیر مورد بحث قرار خواهند گرفت.

1.2.2. نوع داده عدد صحیح

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

جدول 6

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

بدون علامت int n; بدون علامت int b; int c; (با امضای c دلالت دارد). بدون امضا d; (به معنی int بدون علامت d) است. امضا شده f; (به طور ضمنی با امضای f).

توجه داشته باشید که اصلاح کننده char برای نشان دادن یک کاراکتر (از آرایه ای از نمایش کاراکترها) یا برای اعلان حرف های رشته ای استفاده می شود. مقدار یک شی از نوع char یک کد (به اندازه 1 بایت) است که مطابق با کاراکتری است که باید نمایش داده شود. برای نشان دادن کاراکترهای الفبای روسی، تغییر دهنده نوع شناسه داده به شکل کاراکتر بدون علامت است، زیرا کدهای حروف روسی از مقدار 127 فراتر می رود.

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

برای مثال:

A = sizeof (int)؛ b = sizeof (طولانی). c = sizeof (بدون علامت طولانی)؛ d = اندازه (کوتاه)؛

همچنین توجه داشته باشید که ثابت‌های هشت‌گانه و هگزادسیمال نیز می‌توانند اصلاح‌کننده بدون علامت داشته باشند. این با تعیین پیشوند u یا U بعد از ثابت به دست می آید؛ ثابت بدون این پیشوند، امضا شده در نظر گرفته می شود.

برای مثال:

0xA8C (int signed)؛ 01786l (امضای طولانی)؛ 0xF7u (int بدون علامت)؛

1.2.3. داده های شناور

برای متغیرهایی که یک عدد ممیز شناور را نشان می‌دهند، از اصلاح‌کننده‌های نوع زیر استفاده می‌شود: float، double، long double (در برخی از پیاده‌سازی‌های زبان C long double وجود ندارد).

یک مقدار شناور 4 بایت طول می کشد. از این تعداد، 1 بایت برای علامت، 8 بیت برای توان اضافی و 23 بیت برای مانتیس رزرو شده است. توجه داشته باشید که مهم ترین بیت آخوندک همیشه 1 است، بنابراین پر نمی شود؛ بنابراین، محدوده مقادیر برای متغیر ممیز شناور تقریباً 3.14E-38 تا 3.14E + 38 است.

یک دابل 8 بیت در حافظه اشغال می کند. فرمت آن شبیه به float است. بیت های حافظه به صورت زیر تخصیص داده می شوند: 1 بیت برای علامت، 11 بیت برای توان و 52 بیت برای مانتیس. با در نظر گرفتن بیت مرتبه بالا حذف شده آخوندک، محدوده مقادیر از 1.7E-308 تا 1.7E + 308 است.

شناور f, a, b; دو برابر x، y;

1.2.4. اشاره گرها

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

نوع-مشخص کننده [تغییرکننده] * مشخص کننده.

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

کلمات کلیدی const, near, far, large را می توان به عنوان اصلاح کننده هنگام اعلام اشاره گر استفاده کرد. کلمه کلیدی const نشان می دهد که نشانگر را نمی توان در برنامه تغییر داد. اندازه متغیری که به عنوان اشاره گر اعلام می شود به معماری رایانه و مدل حافظه استفاده شده که برنامه برای آن کامپایل می شود بستگی دارد. نشانگرهای انواع داده های مختلف نباید طول یکسانی داشته باشند.

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

بدون امضا int * a; / * متغیر a یک اشاره گر به نوع int بدون علامت (اعداد صحیح بدون علامت) * / double * x; / * متغیر x نشان دهنده دقت مضاعف نوع داده های نقطه شناور * / char * fuffer است. / * یک اشاره گر به نام fuffer اعلام می شود که به متغیری از نوع char * / double nomer اشاره می کند. void * آدرس آدرس = & nomer; (دوگانه *) آدرس ++; / * آدرس متغیر به عنوان یک اشاره گر به یک شی از هر نوع اعلام می شود. بنابراین، می توان آدرس هر شیئی را به آن اختصاص داد (& عمل محاسبه یک آدرس است). با این حال، همانطور که در بالا ذکر شد، تا زمانی که نوع داده ای که به آن اشاره می کند به صراحت مشخص نشود، هیچ عملیات حسابی را نمی توان روی یک اشاره گر انجام داد. این را می توان با استفاده از یک عملیات ریخته گری (double *) برای تبدیل آدرس ها به یک اشاره گر به دو برابر و سپس افزایش آدرس انجام داد. * / const * dr; / * متغیر dr به عنوان یک اشاره گر به یک عبارت ثابت، یعنی. مقدار یک اشاره گر می تواند در طول اجرای برنامه تغییر کند، اما مقداری که به آن اشاره می کند نمی تواند. * / char بدون علامت * const w = & obj. / * متغیر w به عنوان یک اشاره گر ثابت برای داده های نوع char بدون علامت اعلام می شود. این بدان معنی است که در کل برنامه w به همان ناحیه از حافظه اشاره می کند. محتوای این قسمت قابل تغییر است. */

1.2.5. متغیرهای برشمرده شده

متغیری که بتواند مقداری را از فهرستی از مقادیر بگیرد، متغیر شمارش شده یا شمارش نامیده می شود.

یک اعلامیه شمارش با کلمه کلیدی enum شروع می شود و دارای دو قالب ارائه است.

قالب 1. enum [enum-tag-name] (enumeration-list) descriptor [, descriptor ...];

قالب 2. enum enum-tag-name descriptor [, descriptor ..];

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

یک متغیر از نوع شمارش می‌تواند مقادیر یکی از ثابت‌های نام‌گذاری شده در لیست را بگیرد. ثابت های لیست نامگذاری شده از نوع int هستند. بنابراین، حافظه مربوط به متغیر شمارش، حافظه مورد نیاز برای تطبیق مقدار int است.

متغیرهای نوع enum را می توان در عبارات شاخص و به عنوان عملوند در عملیات حسابی و رابطه ای استفاده کرد.

در قالب اول 1، نام ها و مقادیر شمارش در لیست شمارش مشخص شده است. انتخابی enumeration-tag-name شناسه‌ای است که تگ شمارش تعریف شده توسط لیست شمارش را نام‌گذاری می‌کند. توصیفگر یک متغیر شمارش را نامگذاری می کند. بیش از یک متغیر از نوع شمارش را می توان در یک اعلان مشخص کرد.

List-Enumeration شامل یک یا چند ساختار از فرم است:

شناسه [= عبارت ثابت]

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

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

1. یک متغیر می تواند حاوی مقادیر تکراری باشد.

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

3. نام انواع شمارش باید متمایز از نام های دیگر انواع شمارش، ساختارها و مخلوط در همان محدوده باشد.

4. مقدار می تواند از آخرین عنصر لیست شمارش پیروی کند.

تعداد هفته (SUB = 0، / * 0 * / VOS = 0، / * 0 * / POND، / * 1 * / VTOR، / * 2 * / SRED، / * 3 * / HETV، / * 4 * / PJAT / * 5 * /) rab_ned;

در این مثال، تگ شماره شمارش شده با مجموعه مقادیر مربوطه، و متغیر rab_ned از نوع week اعلام شده است.

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

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

1.2.6. آرایه ها

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

توصیفگر نوع مشخص کننده [ثابت - بیان]؛

دسته مشخص کننده نوع؛

توصیفگر یک شناسه آرایه است.

type-specifier نوع عناصر آرایه اعلام شده را مشخص می کند. عناصر آرایه نمی توانند توابع و عناصر خالی باشند.

بیان ثابت براکتی تعداد عناصر آرایه را مشخص می کند. Const-expression را می توان هنگام اعلام یک آرایه در موارد زیر حذف کرد:

وقتی اعلام شد، آرایه مقداردهی اولیه می شود،

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

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

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

Int a; / * به عنوان یک ماتریس a a a a a a * / double b نشان داده شده است. / * بردار 10 عنصر از نوع دوگانه * / int w = ((2، 3، 4)، (3، 4، 8)، (1، 0، 9));

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

در زبان C می‌توانید از برش‌های آرایه مانند سایر زبان‌های سطح بالا (PL1 و غیره) استفاده کنید، اما محدودیت‌هایی برای استفاده از برش‌ها اعمال می‌شود. بخش ها با حذف یک یا چند جفت براکت تشکیل می شوند. جفت براکت ها را فقط می توان از راست به چپ و کاملاً متوالی انداخت. بخش‌هایی از آرایه‌ها در سازماندهی فرآیند محاسباتی در توابع زبان C که توسط کاربر ایجاد شده است، استفاده می‌شوند.

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

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

نمونه ای از اعلان یک آرایه کاراکتری.

char str = "اعلام یک آرایه کاراکتر";

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

1.2.7. سازه های

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

ساختار (فهرست تعریف)

ساختار باید حداقل شامل یک جزء باشد. تعریف سازه ها به شرح زیر است:

توصیفگر نوع داده؛

که در آن data-type نوع ساختار اشیاء تعریف شده در توصیفگرها را نشان می دهد. در ساده ترین شکل خود، توصیفگرها شناسه یا آرایه هستند.

ساختار (x دوگانه، y؛) s1، s2، sm. ساختار (int year; char moth, day;) date1, date2;

متغیرهای s1 و s2 به عنوان ساختارهایی تعریف می شوند که هر کدام از دو جزء x و y تشکیل شده است. متغیر sm به عنوان آرایه ای از نه ساختار تعریف می شود. هر یک از دو متغیر date1, date2 از سه جزء سال، پروانه، روز تشکیل شده است. > p> راه دیگری برای مرتبط کردن نام با نوع ساختار وجود دارد، این روش مبتنی بر استفاده از تگ ساختار است. یک تگ ساختار شبیه به یک تگ شمارش شده است. تگ ساختار به صورت زیر تعریف می شود:

تگ struct (لیست توضیحات؛);

جایی که تگ یک شناسه است.

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

دانش آموز ساختاری (نام کاراکتر؛ شناسه داخلی، سن؛ char prp؛)؛

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

struct tag list-identifiers;

struct Studeut st1, st2;

استفاده از تگ های ساختاری برای توصیف ساختارهای بازگشتی ضروری است. استفاده از تگ های ساختار بازگشتی در زیر مورد بحث قرار گرفته است.

گره ساختار (داده های int؛ گره ساختار * بعدی؛) st1_node;

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

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

St1.name = "ایوانف"; st2.id = st1.id; st1_node.data = st1.age;

1.2.8. انجمن ها (مخلوط)

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

اتحاد (توضیح عنصر 1؛ ... توضیحات عنصر n;);

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

دسترسی به اعضای اتحادیه به همان روشی است که ساختارها انجام می دهند. تگ اتحاد را می توان به همان روشی که تگ ساختار رسمی کرد.

اتحادیه برای اهداف زیر استفاده می شود:

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

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

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

اتحادیه (char fio; char adres; int vozrast; int telefon;) inform; اتحاد (int ax; char al;) ua;

هنگام استفاده از شی اطلاعات از نوع اتحادیه، می توانید فقط عنصری را که مقدار را دریافت کرده است پردازش کنید. پس از تخصیص یک مقدار به عنصر inform.fio، ارجاع به عناصر دیگر بی معنی است. ترکیب ua امکان دسترسی جداگانه به بایت های ua.al و ua.al بالایی عدد دو بایتی ua.ax را می دهد.

1.2.9. فیلدهای بیتی

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

ساختار (شناسه بدون علامت 1: طول فیلد 1؛ شناسه بدون علامت 2: طول میدان 2؛)

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

ساختار (بدون علامت a1: 1؛ بدون علامت a2: 2؛ بدون علامت a3: 5؛ بدون علامت a4: 2;) prim;

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

1.2.10. متغیرهایی با ساختار قابل تغییر

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

مثالی را در نظر بگیرید که در آن اطلاعاتی در مورد اشکال هندسی بر اساس استفاده ترکیبی از ساختار و اتحاد ارائه شده است.

شکل ساختار (مساحت دوگانه، محیط؛ / * مولفه های مشترک * / نوع int؛ / * ویژگی مؤلفه * / اتحاد / * شمارش اجزا * / (شعاع دوگانه؛ / * دایره * / دو برابر a؛ / * مستطیل * / دو برابر b ; / * مثلث * /) geom_fig;) fig1, fig2;

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

توجه داشته باشید که به جای کامپوننت نوع از نوع int، توصیه می شود از یک نوع شمارش شده استفاده کنید. به عنوان مثال، چنین

تعداد شکل_شطرنج (CIRCLE، BOX، TRIANGLE)؛

ثابت های CIRCLE، BOX، TRIANGLE به ترتیب مقادیر 0، 1، 2 را دریافت خواهند کرد. متغیر نوع را می توان به عنوان دارای یک نوع برشماری اعلام کرد:

enum figure_type شطرنج;

در این مورد، کامپایلر C به برنامه نویس در مورد تخصیص بالقوه اشتباه هشدار می دهد، مانند:

figure.type = 40;

به طور کلی، یک متغیر ساختار از سه بخش تشکیل می شود: مجموعه ای از اجزای مشترک، یک برچسب جزء فعال، و بخشی با اجزای متغیر. شکل کلی یک ساختار متغیر به شرح زیر است:

ساختار (کامپوننت‌های مشترک؛ برچسب مؤلفه فعال؛ اتحاد (شرح مؤلفه 1؛ توصیف مؤلفه 2؛ ::: توصیف مؤلفه n;) شناسه اتحادیه؛) شناسه ساختار؛

مثالی از تعریف یک متغیر ساختاری به نام helth_record

ساختار (/ * اطلاعات عمومی * / نام کاراکتر؛ / * نام * / سن بین‌المللی؛ / * سن * / جنسیت کاراکتر؛ / * جنسیت * / / * برچسب مؤلفه فعال * / / * (وضعیت تأهل) * / فهرست شرایط ارزشی . ) ثبت_سلامتی؛ enum marital_status (SINGLE، / * مجرد * / MARRIGO، / * متاهل * / DIVOREED / * مطلقه * /);

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

Helth_record.neme، helth_record.ins، helth_record.marriage_info.marriage_date.

1.2.11. تعریف اشیا و انواع

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

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

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

با این حال، باید به خاطر داشت که برخی از ترکیبات اصلاح کننده مجاز نیستند:

عناصر آرایه نمی توانند توابع باشند،

توابع نمی توانند آرایه ها یا توابع را برگردانند.

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

برای تفسیر توصیفات پیچیده، یک قانون ساده پیشنهاد شده است که به نظر می رسد "از درون به بیرون" و شامل چهار مرحله است.

1. با یک شناسه شروع کنید و به سمت راست نگاه کنید تا ببینید آیا پرانتز یا پرانتز وجود دارد یا خیر.

2. اگر هستند، این قسمت از توصیفگر را تفسیر کنید و سپس به سمت چپ برای ستاره نگاه کنید.

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

4. تعیین کننده نوع را تفسیر کنید.

Int * (* comp) (); 6 5 3 1 2 4

در این مثال، متغیر comp (1) به صورت آرایه ای از ده (2) اشاره گر (3) به توابع (4) نشانگر (5) را به مقادیر صحیح (6) باز می گرداند.

Char * (* (* var) ()); 7 6 4 2 1 3 5

متغیر var (1) به عنوان یک اشاره گر (2) به یک تابع (3) اعلام می شود که یک اشاره گر (4) را به آرایه (5) از 10 عنصر، که اشاره گر (6) به مقادیر کاراکتر هستند، برمی گرداند.

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

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

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

Typedef double (* MATH) (); / * MATH - نام نوع جدید نشان دهنده یک اشاره گر به تابعی است که مقادیر دوگانه را برمی گرداند * / MATH cos. / * cos یک اشاره گر به یک تابع است که مقادیری از نوع double * / / * را برمی گرداند * می توان یک اعلان معادل * / double (* cos) () ایجاد کرد. typedef char FIO / * FIO - آرایه از چهل کاراکتر * / FIO شخص. / * متغیر شخص آرایه ای از چهل کاراکتر است * / / * این معادل اعلان * / char person است.

هنگام اعلام متغیرها و انواع، از نام نوع در اینجا استفاده می شود (MATH FIO). علاوه بر این، نام های نوع را می توان در سه حالت دیگر استفاده کرد: در لیست پارامترهای رسمی، در اعلام توابع، در عملیات نوع ریخته گری و در عملیات sizeof (عملیات ریخته گری نوع).

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

نوع مشخص کننده چکیده-توصیف;

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

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

1.2.12. مقداردهی اولیه داده ها

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

قالب 1: = آغازگر;

فرمت 2: = (لیست - آغازگر)؛

فرمت 1 هنگام مقداردهی اولیه متغیرهای انواع پایه و اشاره گرها و فرمت 2 برای مقداردهی اولیه اشیاء ترکیبی استفاده می شود.

متغیر tol با "N" مقداردهی اولیه می شود.

const long megabute = (1024 * 1024)؛

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

static int b = (1,2,3,4);

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

static int b = ((1،2)، (3،4));

هنگام تنظیم اولیه یک آرایه، می توانید یک یا چند بعد را حذف کنید

static int b type_ specifier identifier [, identifier] ...

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

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

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

Int x = 100;

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

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

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

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

نمونه هایی از توضیحات:

char a, b; / * متغیرهای a و b از نوع هستند

char * / intх; / * متغیر x - از نوع int

* / char sym; / "متغیرهای sym از نوع char شرح داده شده است.

* / int count.num; / * تعداد و تعداد از نوع int * /

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

مثال ها: char backch = "\ 0";

بیایید انواع اصلی را در زبان C در نظر بگیریم.

int - کل ("عدد صحیح").مقادیر این نوع اعداد صحیح از یک محدوده محدود هستند (معمولاً از 32768 تا 32767). محدوده با اندازه سلول برای نوع تعیین می شود و به رایانه خاص بستگی دارد. علاوه بر این، کلمات خاصی وجود دارد که می توان با نوع int استفاده کرد: short int ("عدد صحیح کوتاه")، int بدون علامت ("عدد صحیح بدون علامت" - "عدد صحیح بدون علامت")، long int ("عدد صحیح طولانی") که کوتاه می شود. یا برعکس، دامنه نمایش اعداد را گسترش دهید.

کاراکتر- شخصیت ("شخصیت"). مقدار معتبر برای این نوع یک کاراکتر است (با متن اشتباه نشود!). شخصیت به صورت آپاستروف نوشته شده است.

مثال ها:"x" 2 "?"

در حافظه کامپیوتر، یک کاراکتر یک بایت را اشغال می کند. در واقع، یک کاراکتر ذخیره نمی شود، بلکه یک عدد - یک کد کاراکتر (از 0 تا 255) ذخیره می شود. تمام کاراکترهای معتبر و کدهای مربوط به آنها در جداول رمزگذاری ویژه نشان داده شده است.

در زبان C، مجاز است از نوع char به عنوان عددی استفاده شود، یعنی برای انجام عملیات با کد کاراکتر، با استفاده از مشخص کننده نوع عدد صحیح در براکت - (int).

شناور - واقعی (نقطه شناور).مقادیر این نوع اعداد هستند، اما برخلاف char و int، لزوما اعداد صحیح نیستند.

12.87 -316.12 -3.345e5 12.345e-15

اعداد واقعی با دقت دو برابر.این نوع شبیه به نوع شناور است، اما دامنه مقادیر بسیار گسترده تری دارد (به عنوان مثال، برای سیستم برنامه نویسی Borland-C از 1.7E-308 تا 1.7E + 308 به جای محدوده از 3.4E-38 تا 3.4E + 38 برای نوع شناور). اما افزایش برد و دقت نمایش اعداد منجر به کاهش سرعت اجرای برنامه و استفاده بیهوده از رم کامپیوتر می شود.

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

لازم به ذکر است که آخرین عنصر آرایه کاراکتر \ 0 است. این یک کاراکتر پوچ است و در C برای علامت گذاری انتهای یک خط استفاده می شود. کاراکتر تهی رقم 0 نیست. چاپ نمی شود و در جدول اسکی 0 شماره گذاری شده است وجود یک کاراکتر تهی به این معنی است که تعداد سلول های آرایه باید باشد. حداقل یک عدد بیشتر از تعداد کاراکترهایی که باید در حافظه تخصیص داده شود.

بیایید مثالی از استفاده از رشته ها بزنیم.

برنامه 84

# عبارتند از اصلی ()

scanf ("% s"، رشته)؛

printf ("% s"، رشته)؛

این مثال آرایه ای از 31 سلول حافظه را توصیف می کند که 30 مورد از آنها می توانند یک عنصر از نوع char را در خود جای دهند. زمانی که تابع scanf ("% s"، رشته) فراخوانی می شود، وارد می شود. هنگام تعیین یک آرایه کاراکتر، "&" وجود ندارد.

اشاره گرها. اشاره گر - نوعی نمایش نمادین از آدرس حافظه اختصاص داده شده به متغیر.

به عنوان مثال، & name یک اشاره گر به نام متغیر است.

در اینجا & عملیات به دست آوردن آدرس است. آدرس واقعی یک عدد است و نمایش نمادین & name یک ثابت اشاره گر است.

در زبان C نیز متغیرهایی از نوع اشاره گر وجود دارد. همانطور که مقدار متغیری از نوع char یک کاراکتر است و مقدار متغیری از نوع int یک عدد صحیح است، مقدار متغیری از نوع اشاره گر آدرس مقداری است.

اگر به اشاره گر نام ptr را بدهیم، می توانیم یک عملگر مانند این بنویسیم:

ptr = / * آدرس نام را به متغیر ptr اختصاص می دهد * /

ما در این مورد می گوییم که prt یک نام "اشاره گر به" است. تفاوت بین ptr و & name در این است که prt یک متغیر است، در حالی که & name یک ثابت است. در صورت لزوم، می توانید نقطه متغیر ptr را به شی دیگری تبدیل کنید:

ptr= / * ptr به bah اشاره می کند، نه نام * /

حال مقدار متغیر prt آدرس متغیر bah است. فرض کنید می دانیم که متغیر ptr حاوی ارجاع به متغیر bah است. سپس برای دسترسی به مقدار این متغیر می توانید از عملیات آدرس دهی غیر مستقیم * استفاده کنید:

val = * ptr; / * مقداری را که توسط ptr به آن اشاره می شود تعریف کنید * / دو عملگر آخر، با هم، معادل زیر هستند:

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

مثال:پرستار = 22;

ptr = /* اشاره گر به پرستار * /

نتیجه تخصیص مقدار 22 به متغیر val است.

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

نمونه هایی ازشرح صحیح اشاره گرها: int * pi; char * pc;

مشخصات نوع، نوع متغیری را که نشانگر به آن ارجاع می دهد، و کاراکتر * خود متغیر را به عنوان اشاره گر تعریف می کند. شرح فرم int * pi; می گوید pi یک اشاره گر است و * پی یک int است.

زبان C امکان تعریف نام انواع داده را فراهم می کند. شما می توانید با استفاده از تعریف typedef به هر نوع داده ای یک نام اختصاص دهید و در آینده هنگام توصیف اشیا از این نام استفاده کنید.

فرمت: typedef<старый тип> <новый тип> مثال: typedef long LARGE; / * بزرگ را تعریف می کند که معادل طولانی * / است

تعریف typedef هیچ نوع جدیدی را معرفی نمی کند، فقط یک نام جدید برای نوع موجود اضافه می کند. متغیرهایی که به این روش توصیف می شوند دقیقاً همان ویژگی های متغیرهایی را دارند که به صراحت توصیف شده اند. تغییر نام نوع برای معرفی نام‌های نوع معنی‌دار یا مخفف برای بهبود درک برنامه و بهبود قابلیت حمل برنامه استفاده می‌شود (نام‌های یک نوع داده ممکن است در رایانه‌های مختلف متفاوت باشند).

عملیات.زبان C با طیف گسترده ای از عملیات (بیش از 40) متمایز می شود. در اینجا ما فقط موارد اصلی، تب را در نظر خواهیم گرفت. 3.3.

عملیات حسابی. این شامل

اضافه (+)،

تفریق (دودویی) (-)،

ضرب (*)،

بخش (/)،

باقیمانده تقسیم (%)،

تفریق (یونی) (-).

در زبان C یک قانون وجود دارد: اگر تقسیم و تقسیم کننده از نوع int باشند، تقسیم به طور کامل انجام می شود، یعنی قسمت کسری نتیجه کنار گذاشته می شود.

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

برنامه 85

#عبارتند از

5 = -3 + 4 * 5 - 6; printf ("% d \ n"، s)؛

s = -3 + 4% 5 - 6; printf ("% d \ n"، s)؛

s = -3 * 4٪ - 6/5; printf ("% d \ n"، s)؛

s = (7 + 6)% 5/2; printf ("% d \ n"، s)؛

نتیجه اجرای برنامه: 11 1 0 1

جدول 3.3 ارشدیت و ترتیب عملیات

مبانی زبان

کد برنامه و داده های دستکاری شده توسط برنامه به صورت دنباله ای از بیت ها در حافظه کامپیوتر نوشته می شود. بیت- این کوچکترین عنصر حافظه رایانه است که می تواند 0 یا 1 را ذخیره کند. در سطح فیزیکی، این مربوط به یک ولتاژ الکتریکی است که همانطور که می دانید یا وجود دارد یا نه. با نگاهی به محتویات حافظه کامپیوتر، چیزی شبیه به زیر را می بینیم:
...

درک این توالی بسیار دشوار است، اما گاهی اوقات مجبور می شویم چنین داده های بدون ساختاری را دستکاری کنیم (معمولاً هنگام برنامه نویسی درایورهای دستگاه های سخت افزاری این مورد نیاز است). C ++ مجموعه ای از عملیات را برای کار با داده های بیتی ارائه می دهد. (ما در این مورد در فصل 4 صحبت خواهیم کرد.)
به عنوان یک قاعده، ساختاری به دنباله ای از بیت ها تحمیل می شود و بیت ها را در گروه بندی می کند بایت هاو کلمات... یک بایت شامل 8 بیت و یک کلمه حاوی 4 بایت یا 32 بیت است. با این حال، تعریف یک کلمه می تواند در سیستم عامل های مختلف متفاوت باشد. اکنون انتقال به سیستم های 64 بیتی آغاز شده است و اخیراً سیستم هایی با کلمات 16 بیتی رایج بودند. اگرچه اندازه بایت در اکثریت قریب به اتفاق سیستم ها یکسان است، ما همچنان به این مقادیر به عنوان وابسته به ماشین اشاره خواهیم کرد.

حالا می‌توانیم مثلاً در مورد بایت با آدرس 1040 یا کلمه با آدرس 1024 صحبت کنیم و ادعا کنیم که بایت با آدرس 1032 با بایت آدرس 1040 برابر نیست.
با این حال، ما نمی دانیم هر بایت، هر کلمه ماشینی چیست. چگونه معنی 8 بیت خاص را بفهمیم؟ برای اینکه معنی این بایت (یا کلمه یا مجموعه دیگری از بیت ها) را بدون ابهام تفسیر کنیم، باید نوع داده های نمایش داده شده توسط این بایت را بدانیم.
C ++ مجموعه ای از انواع داده های داخلی را ارائه می دهد: کاراکتر، عدد صحیح، واقعی - و مجموعه ای از انواع ترکیبی و توسعه یافته: رشته ها، آرایه ها، اعداد مختلط. علاوه بر این، یک مجموعه اساسی از عملیات برای عملیات با این داده ها وجود دارد: مقایسه، حساب و سایر عملیات. عملگرهای پرش، حلقه و شرطی نیز وجود دارد. این عناصر زبان C ++ مجموعه‌ای از بلوک‌های ساختمانی را تشکیل می‌دهند که می‌توانید از آن‌ها سیستمی با هر پیچیدگی بسازید. اولین گام در تسلط بر C ++، مطالعه عناصر اساسی ذکر شده است، که قسمت دوم این کتاب به آن اختصاص دارد.
فصل 3 مروری بر انواع داخلی و توسعه یافته، و مکانیسم هایی که توسط آنها می توان انواع جدید ایجاد کرد، ارائه می دهد. اساساً این مکانیزم کلاسی است که در بخش 2.3 معرفی شده است. فصل 4 عبارات، عملیات داخلی و اولویت آنها و تبدیل نوع را مورد بحث قرار می دهد. فصل 5 در مورد دستورالعمل های زبان صحبت می کند. در نهایت، فصل 6 کتابخانه استاندارد C ++ و انواع کانتینر - آرایه برداری و انجمنی را معرفی می کند.

3. انواع داده C ++

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

3.1. به معنای واقعی کلمه

C ++ دارای مجموعه ای از انواع داده های داخلی برای نمایش اعداد صحیح، اعداد واقعی، نمادها و نوع داده "آرایه کاراکتر" است که برای ذخیره رشته های کاراکتر استفاده می شود. نوع char برای ذخیره کاراکترهای تک و اعداد صحیح کوچک استفاده می شود. یک بایت ماشین را اشغال می کند. انواع short، int و long برای نمایش اعداد صحیح طراحی شده اند. این انواع فقط در محدوده مقادیری که اعداد می توانند بگیرند متفاوت هستند و اندازه های خاص انواع ذکر شده به اجرا بستگی دارد. معمولا short نیمی از کلمه ماشینی است، int یک کلمه، طولانی یک یا دو کلمه است. در سیستم های 32 بیتی، int و long معمولاً یک اندازه هستند.

انواع float، double و long double برای اعداد ممیز شناور در نظر گرفته شده اند و از نظر دقت نمایش (تعداد ارقام قابل توجه) و محدوده متفاوت هستند. معمولاً شناور (تک دقت) یک کلمه ماشینی، double (دقت مضاعف) دو و long double (دقت توسعه یافته) سه کلمه را می گیرد.
char، short، int و long با هم می سازند انواع عدد صحیحکه به نوبه خود می تواند باشد نمادین(امضا) و بدون امضا(بدون امضا). در انواع علامت دار، از سمت چپ ترین بیت برای ذخیره علامت استفاده می شود (0 - به علاوه، 1 - منهای)، و بیت های باقی مانده حاوی مقدار هستند. در انواع بدون علامت، همه بیت ها برای مقدار استفاده می شوند. کاراکتر علامت دار نوع 8 بیتی می تواند مقادیر 128- تا 127 را نشان دهد و کاراکتر بدون علامت می تواند مقادیر 0 تا 255 را نشان دهد.

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

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

20 // اعشاری
024 // اکتال
0x14 // هگز

اگر حرف تحت اللفظی با 0 شروع شود، به عنوان اکتال، اگر با 0x یا 0X شروع شود، سپس به عنوان هگزادسیمال در نظر گرفته می شود. نماد معمولی به عنوان یک عدد اعشاری در نظر گرفته می شود.
به‌طور پیش‌فرض، تمام اعداد صحیح به صورت int امضا می‌شوند. شما می توانید به صراحت یک عدد صحیح را با الصاق L در انتهای عدد تعریف کنید (هر دو از L بزرگ و L کوچک استفاده می شود، اما برای خوانایی نباید از حروف کوچک استفاده کنید: به راحتی می توان آن را با حروف کوچک اشتباه گرفت.

یک). U (یا u) در انتها حرف را به صورت int بدون علامت و دو حرف UL یا LU را به صورت طولانی بدون علامت تعریف می کند. برای مثال:

128u 1024UL 1L 8Lu

لفظ هایی که اعداد واقعی را نشان می دهند را می توان با نقطه اعشار یا نماد علمی (نمایی) نوشت. به طور پیش فرض، آنها از نوع double هستند. برای نشان دادن صریح نوع شناور، باید از پسوند F یا f و برای طولانی دوبل - L یا l استفاده کنید، اما فقط در مورد نوشتن با نقطه اعشار. برای مثال:

3.14159F 0 / 1f 12.345L 0.0 3el 1.0E-3E 2.1.0L

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

"a" "2" "," "" (فاصله)

کاراکترهای ویژه (tab، carriage return) به صورت توالی فرار نوشته می شوند. دنباله های زیر تعریف شده اند (با یک کاراکتر اسلش شروع می شوند):

خط جدید \ n برگه افقی \ t بک اسپیس \ b زبانه عمودی \ v بازگشت کالسکه \ r فید \ f تماس \ یک بک اسلش \\ سوال \؟ نقل قول تک \"نقل مضاعف\"

توالی فرار کلی \ ooo است که در آن ooo یک تا سه رقم اکتال است. این عدد کد کاراکتر است. با استفاده از کد اسکی می توانیم لفظ های زیر را بنویسیم:

\ 7 (تماس) \ 14 (خط جدید) \ 0 (تهی) \ 062 ("2")

یک کاراکتر تحت اللفظی را می توان با L پیشوند (به عنوان مثال، L "a")، که به معنای یک نوع خاص wchar_t - یک نوع کاراکتر دو بایتی است که برای ذخیره کاراکترهای الفبای ملی استفاده می شود، اگر آنها را نتوان با یک نوع کاراکتر معمولی نشان داد. مانند حروف چینی یا ژاپنی.
String Literal یک رشته کاراکتری است که در دو گیومه محصور شده است. چنین لفظی می تواند چندین خط را پوشش دهد، در این صورت یک بک اسلش در انتهای خط درج می شود. کاراکترهای خاص را می توان با توالی فرار خود نشان داد. در اینجا نمونه هایی از لفظ رشته ای آورده شده است:

"" (خط خالی) "a" "\ nCC \ toptions \ tfile. \ n" "یک چند خط \ رشته تحت اللفظی ادامه آن را با یک اسلش علامت می دهد"

در واقع، یک رشته لفظی آرایه‌ای از ثابت‌های کاراکتر است که طبق قرارداد C و C ++، آخرین عنصر همیشه کاراکتر ویژه با کد 0 (\ 0) است.
حرف "A" یک کاراکتر واحد A را مشخص می کند و رشته تحت اللفظی "A" آرایه ای از دو عنصر است: "A" و \ 0 (نویسه خالی).
از آنجایی که یک نوع wchar_t وجود دارد، لفظ هایی از این نوع وجود دارد که مانند کاراکترهای منفرد، با پیشوند L نشان داده می شوند:

L "یک رشته گسترده به معنای واقعی کلمه"

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

"دو" "بعضی"

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

// این ایده خوبی نیست "دو" L "بعضی"

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

تمرین 3.1

تفاوت تعاریف لفظ های زیر را توضیح دهید:

(a) "a"، L "a"، "a"، L "a" (b) 10، 10u، 10L، 10uL، 012، 0 * C (c) 3.14، 3.14f، 3.14L

تمرین 3.2

در مثال های زیر چه اشتباهاتی مرتکب شده اند؟

(الف) "چه کسی با F \ 144rgus می رود؟ \ 014" (ب) 3.14e1L (ج) "دو" L "بعضی" (د) 1024f (ه) 3.14UL (f) "نظر چند خطی"

3.2. متغیرها

بیایید تصور کنیم که در حال حل مشکل افزایش 2 به توان 10 هستیم.

#عبارتند از
int main () (
// اولین راه حل
کوت<< "2 raised to the power of 10: ";
کوت<< 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2;
کوت<< endl;
بازگشت 0;
}

مشکل حل شده است، اگرچه ما مجبور بودیم مکررا بررسی کنیم که آیا 2 واقعاً 10 بار تکرار می شود یا خیر. ما در نوشتن این دنباله طولانی دوتایی اشتباه نکردیم و برنامه نتیجه صحیح - 1024 را برگرداند.
اما اکنون از ما خواسته شد که 2 را به توان 17 و سپس به 23 برسانیم. تغییر دادن متن برنامه در هر بار بسیار ناخوشایند است! و حتی بدتر از آن، اشتباه کردن با نوشتن دو اضافی یا حذف آن بسیار آسان است... اما اگر نیاز به چاپ جدول توان های دو از 0 تا 15 داشته باشید، چه؟ 16 بار دو خط را که ظاهر کلی دارند تکرار کنید:

کوت<< "2 в степени X\t"; cout << 2 * ... * 2;

که در آن X به ترتیب 1 افزایش می یابد و به جای بیضی تعداد لفظ مورد نیاز جایگزین می شود؟

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

در این صورت روش brute-force پاسخ صحیح را می دهد، اما چقدر ناخوشایند و خسته کننده است که یک مشکل را به این شکل حل کنید! ما دقیقا می دانیم که چه مراحلی باید طی شود، اما خود مراحل ساده و یکنواخت هستند.

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

#عبارتند از
int main ()
{
// اشیاء از نوع int
مقدار int = 2;
بین قدرت = 10;
کوت<< value << " в степени "
<< pow << ": \t";
int res = 1;
// عملگر حلقه:
// محاسبه res را تکرار کنید
// تا زمانی که cnt از pow بیشتر شود
برای (int cnt = 1; cnt<= pow; ++cnt)
res = res * value;
کوت<< res << endl;
}

value، pow، res و cnt متغیرهایی هستند که به شما امکان ذخیره، تغییر و بازیابی مقادیر را می دهند. دستور حلقه for خط ارزیابی زمان‌های pow نتیجه را تکرار می‌کند.
بدون شک ما برنامه بسیار انعطاف پذیرتری ایجاد کرده ایم. با این حال، این هنوز یک تابع نیست. برای به دست آوردن یک تابع واقعی که می تواند در هر برنامه ای برای محاسبه توان یک عدد استفاده شود، باید قسمت کلی محاسبات را انتخاب کنید و مقادیر خاصی را با پارامترها تنظیم کنید.

Int pow (int val، int exp) (برای (int res = 1; exp> 0; --exp) res = res * val; return res;)

اکنون به دست آوردن هر درجه ای از عدد مورد نظر دشوار نخواهد بود. در اینجا نحوه اجرای آخرین کار ما آمده است - چاپ جدولی از دو توان از 0 تا 15:

#عبارتند از extern int pow (int, int); int main () (int val = 2; int exp = 15;
کوت<< "Степени 2\n";
برای (int cnt = 0; cnt<= exp; ++cnt)
کوت<< cnt << ": "
<< pow(val, cnt) << endl;
بازگشت 0;
}

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

3.2.1. متغیر چیست

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

تعداد_دانشجوی داخلی; دو برابر حقوق؛ bool on_loan; strins street_address; جدا کننده char;

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

• مقدار واقعی یا مقدار r (از مقدار خوانده شده - مقدار برای خواندن) که در این ناحیه حافظه ذخیره می شود و هم در متغیر و هم در کلمه ذاتی است.
• مقدار آدرس ناحیه حافظه مرتبط با متغیر یا l-value (از مقدار مکان) - مکانی که r-value در آن ذخیره می شود. فقط در شیء ذاتی است.

در بیان

Ch = ch - "0"؛

متغیر ch هم در سمت چپ و هم در سمت راست نماد تخصیص قرار دارد. در سمت راست مقدار خوانده شده است (ch و کاراکتر تحت اللفظی "0"): داده های مرتبط با متغیر از ناحیه حافظه مربوطه خوانده می شود. در سمت چپ مقدار مکان است: نتیجه تفریق در ناحیه حافظه مرتبط با متغیر ch قرار می گیرد. به طور کلی، عملوند سمت چپ یک انتساب باید یک مقدار l باشد. ما نمی توانیم عبارات زیر را بنویسیم:

// خطاهای کامپایل: مقادیر سمت چپ l-value نیستند // خطا: به معنای واقعی کلمه l-value نیست 0 = 1؛ // خطا: عبارت حسابی حقوق و دستمزد l-value نیست + حقوق * 0.10 = new_salary;

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

// file module0.C // یک شیء را تعریف می‌کند. // ... یک مقدار به fileName اختصاص دهید
// فایل module1.C
// از شی fileName استفاده می کند
// افسوس که کامپایل نمی کند:
// نام فایل در module1.C تعریف نشده است
ifstream input_file (نام فایل)؛

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

// file module1.C // از شی fileName استفاده می کند // fileName اعلام می شود، یعنی برنامه دریافت می کند
// اطلاعاتی در مورد این شی بدون تعریف ثانویه آن
نام فایل رشته خارجی; ifstream input_file (نام فایل)

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

3.2.2. نام متغیر

نام متغیر یا مشخص کننده، می تواند از حروف لاتین، اعداد و کاراکتر زیرخط تشکیل شده باشد. حروف بزرگ و کوچک در نام ها متفاوت است. زبان C ++ طول شناسه را محدود نمی کند، اما استفاده از نام های بسیار طولانی مانند gosh_this_is_an_impossibly_name_to_type ناخوشایند است.
برخی از کلمات کلیدواژه C ++ هستند و نمی توانند به عنوان شناسه استفاده شوند. جدول 3.1 فهرست کاملی از آنها را ارائه می دهد.

جدول 3.1. کلمات کلیدی C ++

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

• نام متغیر معمولا با حروف کوچک نوشته می شود، به عنوان مثال index (برای مقایسه: Index یک نام نوع است و INDEX یک ثابت است که با استفاده از دستور #define preprocessor تعریف می شود).
• شناسه باید دارای معنایی باشد که هدف شی را در برنامه توضیح دهد، به عنوان مثال: تولد_تاریخ یا حقوق.

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

3.2.3. تعریف شی

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

حقوق مضاعف؛ دستمزد دو برابر؛ ماه بین المللی; روز بین المللی; سال بین المللی مسافت طولانی بدون علامت؛

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

دو برابر حقوق، دستمزد; بین ماه، روز، سال؛ مسافت طولانی بدون علامت؛

تعریف ساده یک متغیر مقدار اولیه آن را تعیین نمی کند. اگر یک شی به عنوان جهانی تعریف شود، مشخصات C ++ تضمین می کند که مقدار اولیه آن به صفر می رسد. اگر متغیر محلی باشد یا به صورت پویا (با استفاده از عملگر جدید) تخصیص داده شود، مقدار اولیه آن تعریف نشده است، یعنی می تواند حاوی مقداری تصادفی باشد.
استفاده از متغیرهایی مانند این یک اشتباه بسیار رایج است و تشخیص آن دشوار است. توصیه می شود حداقل در مواردی که نمی دانید آیا شی می تواند خود را مقداردهی اولیه کند یا خیر، به صراحت مقدار اولیه یک شی را مشخص کنید. مکانیسم کلاس مفهوم سازنده پیش فرض را معرفی می کند که برای تخصیص مقادیر پیش فرض استفاده می شود. (ما قبلاً در این مورد در بخش 2.3 صحبت کردیم. کمی بعد در مورد سازنده های پیش فرض صحبت خواهیم کرد، در بخش های 3.11 و 3.15، جایی که رشته ها و کلاس های پیچیده را از کتابخانه استاندارد تجزیه می کنیم.)

Int main () (// شی محلی بدون مقدار اولیه int ival;
// شی از نوع رشته مقداردهی اولیه می شود
// سازنده پیش فرض
پروژه رشته;
// ...
}

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

Int ival = 1024; string project = "Fantasia 2000";

و ضمنی، با مقدار اولیه در پرانتز:

Int ival (1024); پروژه رشته ("فانتازیا 2000")؛

هر دو گزینه معادل هستند و عدد صحیح ival را به 1024 و رشته پروژه را به "Fantasia 2000" مقداردهی اولیه می کنند.
هنگام تعریف متغیرها با لیست می توان از مقداردهی اولیه صریح نیز استفاده کرد:

حقوق دو برابر = 9999.99، دستمزد = حقوق + 0.01; int month = 08; روز = 07، سال = 1955;

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

// صحیح، اما بی معنی int bizarre = عجیب و غریب;

از نظر نحوی معتبر است، هرچند بی معنی.
انواع داده های داخلی دارای دستور خاصی برای تعیین مقدار تهی هستند:

// ival مقدار 0 و dval 0.0 int ival = int (); double dval = double ();

در تعریف زیر:

// int () برای هر یک از 10 عنصر برداری اعمال می شود< int >ivec (10)؛

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

#عبارتند از #عبارتند از
قیمت دو برابر = 109.99، تخفیف = 0.16;
دو برابر فروش_قیمت (قیمت * تخفیف);
حیوان خانگی رشته ای ("چروک")؛ extern int get_value (); int val = get_value ();
بدون علامت abs_val = abs (val);

abs () یک تابع استاندارد است که مقدار مطلق یک پارامتر را برمی گرداند.
get_value () یک تابع سفارشی است که یک مقدار صحیح را برمی گرداند.

تمرین 3.3

کدام یک از تعاریف متغیر زیر حاوی خطاهای نحوی است؟

(الف) int car = 1024، auto = 2048; (ب) int ival = ival; (ج) int ival (int ()); (د) دو برابر حقوق = دستمزد = 9999.99; (e) cin >> int_value;

تمرین 3.4

تفاوت بین l-value و r-value را توضیح دهید. مثال بزن.

تمرین 3.5

تفاوت استفاده از متغیرهای name و student را در خط اول و دوم هر مثال بیابید:

(الف) نام رشته خارجی؛ نام رشته ("تمرین 3.5a")؛ (ب) بردار خارجی دانش آموزان؛ بردار دانش آموزان؛

تمرین 3.6

چه نام اشیایی در C ++ نامعتبر است؟ آنها را طوری تغییر دهید که از نظر نحوی صحیح باشند:

(الف) int double = 3.14159; (ب) بردار< int >_؛ (ج) فضای نام رشته; (د) رشته catch-22; (ه) char 1_or_2 = "1"; (f) float Float = 3.14f;

تمرین 3.7

تفاوت بین تعاریف متغیر جهانی و محلی زیر چیست؟

رشته global_class. int global_int; int main () (
int local_int;
رشته local_class; //...
}

3.3. اشاره گرها

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

• یک اشاره گر به یک int حاوی مقدار آدرس 1000 به ناحیه حافظه 1000-1003 هدایت می شود (در یک سیستم 32 بیتی).
• یک اشاره گر به یک دوبل حاوی مقدار آدرس 1000 به ناحیه حافظه 1000-1007 هدایت می شود (در یک سیستم 32 بیتی).

در اینجا چند نمونه آورده شده است:

Int * ip1, * ip2; مجتمع * cp; رشته * pstring; بردار * pvec؛ دو برابر * dp;

نمایه با یک ستاره جلوی نام نشان داده می شود. در تعریف متغیرهای دارای لیست، یک ستاره باید قبل از هر نشانگر بیاید (به بالا مراجعه کنید: ip1 و ip2). در مثال زیر، lp یک اشاره گر به یک شی طولانی است، و lp2 یک شی طولانی است:

طولانی * lp، lp2;

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

Float fp، * fp2;

عملگر حذف ارجاع (*) را می توان با فاصله از نام و حتی مستقیماً در مجاورت کلمه کلیدی نوع جدا کرد. بنابراین، تعاریف فوق از نظر نحوی صحیح و کاملاً معادل هستند:

// توجه: ps2 یک اشاره گر به یک رشته نیست! رشته * ps, ps2;

می توان فرض کرد که هر دو ps و ps2 اشاره گر هستند، اگرچه اشاره گر تنها اولین آنهاست.
اگر مقدار اشاره گر 0 باشد، آنگاه هیچ آدرس شی ای وجود ندارد.
اجازه دهید یک متغیر از نوع int داده شود:

Int ival = 1024;

در زیر نمونه هایی از تعریف و استفاده از اشاره گر به int pi و pi2 آورده شده است:

// پی به صفر int مقداردهی اولیه می شود * pi = 0;
// pi2 با آدرس ival مقداردهی اولیه می شود
int * pi2 =
// صحیح: pi و pi2 حاوی آدرس ival هستند
pi = pi2;
// pi2 حاوی یک آدرس صفر است
pi2 = 0;

به یک اشاره گر نمی توان مقداری را که آدرس نیست اختصاص داد:

// خطا: pi نمی تواند int pi = ival باشد

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

دو dval; دو برابر * ps =

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

// خطاهای کامپایل // انتساب نامعتبر انواع داده ها: int *<== double* pi = pd pi = &dval;

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

// صحیح: void * می تواند حاوی // آدرس های هر نوع void * pv = pi; pv = pd;

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

Int ival = 1024 ;, ival2 = 2048; int * pi =

// نسبت دادن غیر مستقیم مقدار ival2 به متغیر ival * pi = ival2;
// استفاده غیر مستقیم از ival به عنوان rvalue و lvalue
* pi = abs (* pi)؛ // ival = abs (ival);
* پی = * پی + 1; // ival = ival + 1;

وقتی عملیات گرفتن آدرس (&) را به یک شی از نوع int اعمال می کنیم، نتیجه نوع int * را دریافت می کنیم.
int * pi =
اگر همان عملیات را روی یک شی از نوع int * (اشاره‌گر به int) اعمال کنیم، یک اشاره‌گر به اشاره‌گر به int می‌گیریم، یعنی. int **. int ** آدرس یک شی است که حاوی آدرس یک شی از نوع int است. با عدم ارجاع ppi، یک شی int * حاوی آدرس ival دریافت می کنیم. برای به دست آوردن خود شی ival، باید دو بار عملیات dereference ppi اعمال شود.

Int ** ppi = π int * pi2 = * ppi;
کوت<< "Значение ival\n" << "явное значение: " << ival << "\n"
<< "косвенная адресация: " << *pi << "\n"
<< "дважды косвенная адресация: " << **ppi << "\n"

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

int i, j, k; int * pi = // i = i + 2
* پی = * پی + 2; // آدرس موجود در پی را 2 افزایش دهید
پی = پی + 2;

شما می توانید یک مقدار صحیح به اشاره گر اضافه کنید، همچنین می توانید از آن کم کنید. افزودن 1 به یک اشاره گر، مقدار موجود در آن را با اندازه ناحیه حافظه اختصاص داده شده به یک شی از نوع مربوطه افزایش می دهد. اگر نوع کاراکتر 1 بایت، int - 4 و double - 8 را اشغال کند، با افزودن 2 به اشاره گرها به char، int و double مقدار آنها 2، 8 و 16 افزایش می یابد. چگونه می توان این را تفسیر کرد؟ اگر اشیایی از همان نوع یکی پس از دیگری در حافظه قرار گیرند، افزایش نشانگر به میزان 1 باعث می شود که به شی بعدی اشاره کند. بنابراین، عملیات محاسباتی با اشاره گر اغلب در هنگام پردازش آرایه ها استفاده می شود. در هر مورد دیگر، آنها به سختی قابل توجیه هستند.
این همان چیزی است که یک مثال معمولی از استفاده از حساب آدرس هنگام تکرار روی عناصر یک آرایه با استفاده از یک تکرار کننده به نظر می رسد:

Int ia; int * iter = int * iter_end =
در حالی که (iter! = iter_end) (
do_something_with_value (* iter);
++ iter;
}

تمرین 3.8

تعاریف متغیر ارائه شده است:

Int ival = 1024، ival2 = 2048; int * pi1 = & ival، * pi2 = & ival2، ** pi3 = 0;

وقتی عملیات تخصیص زیر را انجام می دهید چه اتفاقی می افتد؟ آیا در این مثال ها اشتباهی وجود دارد؟

(a) ival = * pi3; (e) pi1 = * pi3; (ب) * pi2 = * pi3; (f) ival = * pi1; (ج) ival = pi2; (g) pi1 = ival; (د) pi2 = * pi1; (h) pi3 =

تمرین 3.9

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

پی = پی = پی + 1024;

تقریباً مطمئناً باعث می شود که پی به یک منطقه تصادفی از حافظه اشاره کند. این اپراتور تخصیص چه کاری انجام می دهد و در چه صورت با خطا مواجه نمی شود؟

تمرین 3.10

این برنامه حاوی یک خطای مربوط به استفاده نادرست از نشانگرها است:

Int foobar (int * pi) (* pi = 1024; return * pi;)
int main () (
int * pi2 = 0;
int ival = foobar (pi2);
بازگشت 0;
}

اشتباه چیست؟ چگونه می توانید آن را تعمیر کنید؟

تمرین 3.11

خطاهای دو تمرین قبلی خود را نشان می دهد و به دلیل عدم اعتبارسنجی مقادیر اشاره گر در C ++ در حین اجرای برنامه منجر به عواقب مرگبار می شود. به نظر شما چرا چنین چکی اجرا نشد؟ آیا می توانید چند دستورالعمل کلی برای ایمن تر کردن اشاره گرها ارائه دهید؟

3.4. انواع رشته

C ++ از دو نوع رشته پشتیبانی می کند - نوع داخلی که از C به ارث رسیده و کلاس رشته از کتابخانه استاندارد C ++. کلاس string امکانات بسیار بیشتری را فراهم می کند و بنابراین استفاده از آن راحت تر است، اما در عمل اغلب موقعیت هایی وجود دارد که شما نیاز به استفاده از یک نوع داخلی دارید یا درک خوبی از نحوه کار آن دارید. (یک مثال تجزیه پارامترهای خط فرمان است که به main () منتقل می شود. ما آن را در فصل 7 پوشش خواهیم داد.)

3.4.1. نوع رشته داخلی

همانطور که قبلا ذکر شد، نوع رشته داخلی با ارث بردن از C به C ++ منتقل می شود. یک رشته کاراکتر به عنوان یک آرایه در حافظه ذخیره می شود و با استفاده از یک اشاره گر char * قابل دسترسی است. کتابخانه استاندارد C مجموعه ای از توابع را برای دستکاری رشته ها فراهم می کند. برای مثال:

// طول رشته int strlen را برمی گرداند (const char *);
// دو رشته را با هم مقایسه می کند
int strcmp (const char *, const char *);
// یک خط را به خط دیگر کپی می کند
char * strcpy (char *، const char *);

کتابخانه استاندارد C بخشی از کتابخانه C ++ است. برای استفاده از آن، باید یک فایل هدر اضافه کنیم:

#عبارتند از

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

Const char * st = "قیمت یک بطری شراب \ n";

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

در حالی که (* st ++) (...)

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

int string_length (const char * st) (int cnt = 0; if (st) while (* st ++) ++ cnt؛ return cnt;)

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

// pc1 هیچ آرایه کاراکتری را آدرس نمی دهد * pc1 = 0; // pc2 یک کاراکتر تهی را آدرس می دهد const char * pc2 = "";

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

#عبارتند از const char * st = "قیمت یک بطری شراب \ n"; int main () (
int len ​​= 0;
while (st ++) ++ len; کوت<< len << ": " << st;
بازگشت 0;
}

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

#عبارتند از const char * st = "قیمت یک بطری شراب \ n"; int main ()
{
int len ​​= 0;
در حالی که (* st ++) ++ len; کوت<< len << ": " << st << endl;
بازگشت 0;
}

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

St = st - len; کوت<< len << ": " << st;

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

18: بطری های شراب ena

فراموش کردیم در نظر بگیریم که کاراکتر تهی انتهایی در طول محاسبه شده لحاظ نشده است. st باید با طول رشته به اضافه 1 جبران شود. در نهایت عملگر صحیح اینجاست:

St = st - len - 1;

و در اینجا نتیجه صحیح است:

18: قیمت یک بطری شراب

با این حال، نمی توانیم بگوییم که برنامه ما زیبا به نظر می رسد. اپراتور

St = st - len - 1;

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

Const char * p = st;

اکنون p را می توان در یک حلقه طول استفاده کرد و st را بدون تغییر باقی گذاشت:

در حالی که (* p ++)

3.4.2. کلاس رشته

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

• مقداردهی اولیه با آرایه ای از کاراکترها (رشته ای از نوع داخلی) یا شی دیگری از نوع رشته. نوع داخلی گزینه دوم را ندارد.
• کپی کردن یک خط به خط دیگر برای یک نوع داخلی، باید از تابع strcpy () استفاده کنید.
• دسترسی به کاراکترهای تک رشته برای خواندن و نوشتن. در آرایه داخلی، این کار با استفاده از عملیات گرفتن نمایه یا آدرس دهی غیر مستقیم انجام می شود.
• مقایسه دو رشته برای برابری برای یک نوع داخلی، تابع strcmp () استفاده می شود.
• الحاق دو رشته، به دست آوردن نتیجه یا به عنوان رشته سوم، یا به جای یکی از رشته های اصلی. برای یک نوع داخلی، از تابع strcat () استفاده می شود، اما برای دریافت نتیجه در یک خط جدید، باید به طور متوالی از توابع strcpy () و strcat () استفاده کنید.
• محاسبه طول رشته با استفاده از تابع strlen () می توانید طول یک رشته از نوع داخلی را پیدا کنید.
• توانایی یافتن خالی بودن یک رشته. برای این منظور، رشته های داخلی باید دو شرط را بررسی کنند: char str = 0; // ... اگر (! str ||! * str) بازگشت;

کلاس رشته C ++ Standard Library همه این عملیات را اجرا می کند (و خیلی بیشتر، همانطور که در فصل 6 خواهیم دید). در این قسمت با نحوه استفاده از عملیات پایه این کلاس آشنا می شویم.
برای استفاده از اشیاء کلاس رشته، باید فایل هدر مربوطه را وارد کنید:

#عبارتند از

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

#عبارتند از string st ("قیمت یک بطری شراب \ n")؛

طول رشته توسط تابع عضو اندازه () برگردانده می شود (طول شامل کاراکتر تهی پایانی نمی شود).

کوت<< "Длина " << st << ": " << st.size() << " символов, включая символ новой строки\n";

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

رشته st2; // خط خالی

چگونه بفهمیم یک خط خالی است؟ البته می توانید طول آن را با 0 مقایسه کنید:

اگر (! St.size ()) // صحیح: خالی

با این حال، یک متد خالی () ویژه نیز وجود دارد که مقدار true را برای یک رشته خالی و false را برای یک رشته غیر خالی برمی گرداند:

اگر (st.empty ()) // صحیح: خالی

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

رشته st3 (st);

رشته st3 با رشته st مقدار دهی اولیه می شود. چگونه می توانیم مطمئن شویم که این خطوط یکسان هستند؟ بیایید از عملگر مقایسه (==):

اگر (st == st3) // مقداردهی اولیه کار کرد

چگونه می توانم یک خط را به خط دیگر کپی کنم؟ با عملیات انتساب معمول:

St2 = st3; // st3 را در st2 کپی کنید

برای به هم پیوستن رشته ها، از عملیات جمع (+) یا جمع و انتساب (+ =) استفاده کنید. بگذارید دو خط داده شود:

رشته s1 ("سلام"); رشته s2 ("جهان \ n")؛

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

رشته s3 = s1 + s2;

اگر بخواهیم s2 را به انتهای s1 اضافه کنیم باید بنویسیم:

S1 + = s2;

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

Const char * pc = ","; رشته s1 ("سلام"); رشته s2 ("جهان")؛
رشته s3 = s1 + pc + s2 + "\ n";

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

رشته s1; const char * pc = "یک آرایه کاراکتر"; s1 = pc; // درست

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

Char * str = s1; // خطای کامپایل

برای انجام این تبدیل، باید یک تابع عضو با نام کمی عجیب c_str ():

Char * str = s1.c_str (); // تقریبا درست است

تابع c_str () یک اشاره گر را به یک آرایه کاراکتری که شامل رشته شی رشته است، همانطور که در یک نوع رشته داخلی وجود دارد، برمی گرداند.
مثال بالا در مورد مقداردهی اولیه نشانگر char * str هنوز کاملاً صحیح نیست. c_str () یک اشاره گر را به یک آرایه ثابت برمی گرداند تا از امکان تغییر مستقیم محتویات یک شی از طریق این اشاره گر نوع جلوگیری کند.

کاراکتر Const *

(ما کلمه کلیدی const را در بخش بعدی پوشش خواهیم داد.) گزینه صحیح اولیه به صورت زیر است:

Const char * str = s1.c_str (); // درست

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

String str ("fa.disney.com"); int size = str.size (); برای (int ix = 0; ix< size; ++ix) if (str[ ix ] == ".")
str [ix] = "_";

این تمام چیزی است که می‌خواستیم در مورد کلاس رشته بگوییم. در واقع این کلاس ویژگی ها و قابلیت های جالب تری دارد. فرض کنید مثال قبلی نیز با فراخوانی یک تابع () جایگزین پیاده سازی شده است:

جایگزین (str.begin ()، str.end ()، "."، "_");

جایگزین () یکی از الگوریتم‌های عمومی است که در بخش 2.8 دیدیم و در فصل 12 به تفصیل توضیح داده خواهد شد. عناصر برابر با پارامتر سوم خود را با پارامتر چهارم جایگزین می کند.

تمرین 3.12

به دنبال اشتباهات در عبارات زیر بگردید:

(a) char ch = "جاده طولانی و پر پیچ و خم"; (ب) int ival = (c) char * pc = (d) string st (& ch); (ه) pc = 0; (i) pc = "0"؛
(f) st = pc; (j) st =
(g) ch = pc; (k) ch = * pc;
(h) pc = st; (l) * pc = ival;

تمرین 3.13

تفاوت رفتار عبارات حلقه زیر را توضیح دهید:

در حالی که (st ++) ++ cnt;
در حالی که (* st ++)
++ cnt;

تمرین 3.14

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