Пешгуфтор 
 Ҳамқадам бо асру бо даврон мебояд будан, 
 Бо хабар аз илму аз ирфон мебояд шудан. 
 Ҳеҷ роҳе нест, ки бепоён бошад дар ҷаҳон, 
 Бо ирода бо ҳавас бо ҷон мебояд шудан. 
 (Муллошараф Арабов) 
 Барномасозӣ низ ҳунар буда, барои бартараф намудани баъзе 
 мушкилоти ҷомеа бо истифода аз ягон забони барноманависӣ барнома 
 навишта мешавад. Ҳангоме ки шахс барнома менависад, метавонад ба 
 компютер ҳамчун раис (роҳбар) муомила кунад. Барои навиштани барнома 
 забонҳои барноманависии зиёде мавҷуданд, ки аз байни онҳо якчанд забон 
 маъмулу машҳур ва пурқудрат буда, мавриди писанди барноманависон ва 
 омӯзандагон қарор дорад. Забони С++ аз зумраи чунин забонҳост. Забонҳои 
 барноманависӣ бо гузашти замон такмилу густариш меёбанд. Забони С++ низ 
 дар айни ҳол дар ҳолати рушд ва густариш мебошад. 
 Забони С++ дорои қудрати зиёд буда, метавонад ҳам дар муҳити 
 Windows ва ҳам дар муҳити дигар системаҳои омилӣ кор кунад. 
 Забони С++ ҳамаи имкониятҳои забони С-ро доро буда, илова бар ин, 
 қудрати БОН-ро низ соҳиб аст. Баъзеҳо то кунун ҳарчанд аз забони С исти- 
 фода баранд ҳам, вале забони С++ дар айни ҳол густариш меёбад. 
 Пас аз соҳибистиқлол гардидани Тоҷикистон чи дар мактабҳои миёна ва 
 чи дар коллеҷу донишгоҳҳо омӯзиши компютер ва барноманависӣ ба роҳ 
 монда шудааст, вале мутаассифона то кунун дар Тоҷикистон адабиёти фаро- 
 гири ин соҳа бо забони давлатӣ вуҷуд надорад. Бинобар ин муаллифон кӯшиш 
 ба харҷ додем, ки бо забони модарӣ барои хонандагон чунин дастуреро пеш- 
 каш намоем. 
 Ин китоб тарзе таълиф шудааст,ки дар он сохторҳои додаҳо, БОН, им- 
 кониятҳои графикӣ ва коркарди ҳолатҳои истисноӣ ба таври комил маврии 
 баҳс қарор дода шудаанд. Бинобар ин, барои хонандагон зарур аст, ки ибтидо
 асосҳои барноманависиро азбар кунанд. Барои асосҳои забони С++-ро аз худ 
 кардан метавон аз китоби қаблан навиштаи муаллиф Арабов М.К. истифода 
 намоянд. Пас аз омӯхтани асосҳои барномасозӣ хонандагон метавонанд, ба 
 таври сода барноманависии ба объектҳо нигаронидашуда(БОН)-ро пурра 
 омӯзанд. Барои ин зарур аст, ки ҳар мавзӯъро бодиққат хонда, барномаҳои 
 Арабов М.Қ. Асосҳои барноманависӣ дар C++. -Душанбе. РТСУ,. - с.
 овардашударо таҳлил кунанд. Дар поёни ҳар боб барои мустаҳкамкунӣ са- 
 волҳо ва дар охир мисолҳои мувофиқ барои намуна ва барои кори му- 
 стақилона дода шудааст. Мақсади овардани ин мисолҳо аз он иборат аст, ки 
 хонанда дониши омӯхтаашро санҷида, маҳорати барноманависиашро сайқал 
 диҳад. 
 Китоби мазкур бобро дар бар гирифта, ҳамчун воситаи муҳиме барои 
 худомӯзии БОН дар C++ ба ҳисоб меравад. Аз ин китоб хонандагон 
 метавонанд, дар як муддати кӯтоҳ асосҳои БОН-ро ба таври комил омӯхта, 
 заминае барои омӯзиши забонҳои C# ва Java пайдо намоянд, зеро забонҳои 
 C# ва Java пурра забони БОН мебошанд. 
 Бояд қайд кард, ки ин китоб на танҳо ҳамчун воситаи худомӯзӣ, балки 
 воситаи методиву таълимӣ низ мебошад. Ҳамаи барномаҳои он дар компютер 
 иҷро ва тест карда шудаанд. 
 Инак, дастур пешкаши хонандагон мегардад, ки он нахустин таълифоти 
 муаллифон буда, аз нуқсону ғалатҳо орӣ нест. Аз ин рӯ, муаллифон аз ҳамаи
 хонандагон эҳтиромона хоҳиш менамояд, ки ҳама гуна фикру мулоҳизоту 
 дархости хешро оид ба ин дастур ба нишонии электронии cool.araby@mail.ru 
 ирсол намоянд. 
 Мо умедворем, ки фикру дархости беғаразонаи Шумо барои беҳтар 
 шудани сифати китоб дар оянда кумак хоҳанд кард. 
 Муаллифон ба шахсоне, ки фикру мулоҳизаҳои худро оид ба мазмуни 
 китоб беғаразона ба онҳо мерасонанд, қаблан миннатдории худро баён 
 месозанд. 
 Муаллифон ба муқарризон Гулов А.М.,________, муҳаррир Саидолимов 
 К. ва шахсоне, ки дар рафти навиштани китоб маслиҳатҳои муфид дода, 
 таваҷҷуҳ зоҳир намуданд, изҳори сипос менамоянд. 
 Мундариҷа 
 Пешгуфтор............................................................................................................ 
 БОБИ. СОХТОРҲО (STRUCTURES)............................................................... 
 Муқаддима............................................................................................................ 
 Муаррификунии навъи сохтор............................................................................ 
 Дастрасӣ ба майдонҳои сохтор......................................................................... 
 Ба ҳамдигар бахшидани сохторҳо.................................................................... 
 Дохил ва хориҷ намудани тағйирёбандаҳои сохтор....................................... 
 Ба аъзои сохтор бахшидани қимати аввала..................................................... 
 Методҳо. Муаррифӣ намудани методҳо.......................................................... 
 Конструктор. Истифодаи конструктор............................................................ 
 Массивҳо аз навъи сохтор................................................................................. 
 Таҳлилияксохтор................................................................................................ 
 Ишорагар ба сохтор (pointer to struct).............................................................. 
 Равон кардани аъзоҳои сохтор ба функсия..................................................... 
 Ишорагари сохторро баргардонидани функсия.............................................. 
 Ба сифати аргументи функсия равон кардани сохтор.................................... 
 Навъи додаҳое, ки ба воситаи корбар муаррифи мегарданд (user-defined data
 types).................................................................................................................... 
 Сохтори додаҳо ва ишорагарҳо........................................................................ 
 Ишорагарҳо ба сифати элементи сохтор......................................................... 
 Иттиҳодҳо (Unions)............................................................................................ 
 Додаҳои навъишуморишӣ................................................................................. 
 Саволҳо барои мустаҳкамкунӣ......................................................................... 
 Мисолҳои барои кори мустақилона................................................................. 
 БАРНОМАНАВИСИИ БА ОБЪЕКТҲО НИГАРОНИДАШУДА........................ 
 БОБИ. КЛАССҲО, ОБЪЕКТҲО ВА МЕТОДҲО........................................... 
 Муқаддима.......................................................................................................... 
 Муаррификунии class-ҳо................................................................................... 
 Методҳо............................................................................................................... 
 Пешнамунасозии методҳо................................................................................. 
 Қимати аввала бахшидан ба майдонҳои класс тавассути методҳо............... 
 Калимаи калидӣ ё ишорагари this..................................................................... 
 Конструктор ва деструктор............................................................................... 
 Сохтан ва истифода намудани конструктор................................................ 
 Конструктори параметрдор............................................................................ 
 Конструктори дорои як аргумент.................................................................. 
 Классҳои локалӣ................................................................................................. 
 Функсияҳои дохилихаттӣ (inline functions)..................................................... 
 Истифодаи функсияҳои дохилихаттӣ дар класс............................................. 
 Функсияҳои бо миқдори параметрҳои тағйирёбанда..................................... 
 Сарборӣ намудани конструкторҳо................................................................... 
 Истифодаи деструктор....................................................................................... 
 Аъзоҳои кушода ва пушидаи class................................................................... 
 Аъзоҳои статикии класс.................................................................................... 
 Функсияҳои виртуалӣ........................................................................................ 
 Сарборигузории методҳо................................................................................... 
 Саволҳо барои мустаҳкамкунӣ......................................................................... 
 БОБИ. КОР БО ОБЪЕКТҲО............................................................................. 
 Равон кардани объектҳо ба функсия ба сифати аргумент............................. 
 Қимат объект баргардонидани метод.............................................................. 
 Истинодҳо (reference)......................................................................................... 
 Равон кардани параметрҳо бо ёрии истинод................................................ 
 Хосиятҳои истинодҳо..................................................................................... 
 Истиноди новобаста........................................................................................ 
 Ишорагар ба объектҳо....................................................................................... 
 Ишорагар ба аъзоҳои class................................................................................ 
 Истифодаи истинод барои объектҳо................................................................ 
 Объектҳо аз навъи массив................................................................................. 
 Ба таври динамики ишғол кардани хотира барои объектҳо.......................... 
 Функсия ва классҳои дӯст................................................................................. 
 Функсияҳои виртуалӣ...................................................................................... 
 Хосияти Варосат............................................................................................... 
 Мафҳуми умумии варосат ва корбурди он................................................. 
 Варосати мураккаб........................................................................................ 
 Шаблонҳо барои варосат.............................................................................. 
 Саволҳо барои мустаҳкамкунӣ....................................................................... 
 БОБИ. САРБОРӢ НАМУДАНИ ОПЕРАТОРҲО......................................... 
 Муқаддима........................................................................................................ 
 Сарборӣ кардани операторҳо бо истифода аз функсия-аъзоҳо................... 
 Сарборӣ кардани операторҳои ягона (унарӣ) бо ёрии функсия-аъзоҳо.... 
 Сарбори гузоштани операторҳои мантиқӣ ва муносибат............................ 
 Сарборӣ намудани оператори дугонаи «-».................................................... 
 Сарборӣ намудани оператори зернависи массив «[]».................................. 
 Сарборӣ кардани оператори «()».................................................................... 
 Сарборӣ намудани операторҳо бо истифода аз функсияҳое, ки аъзои Class 
 намебошанд....................................................................................................... 
 Сарборӣ намудани операторҳои «<<»ва«>>»............................................... 
 Саволҳо барои мустаҳкамкунӣ....................................................................... 
 БОБИ. ИСЛОҲИ ХАТОГИҲО ВА КОРКАРДИ ҲОЛАТҲОИ ИСТИСНОӢ............................................................................................................................... 
 Муқаддима........................................................................................................ 
 Ҳассосият ба регистр....................................................................................... 
 Сарфи назар кардани нуқта вергул дар охири сатрҳо.................................. 
 Навиштани Main ба ҷои main дар функсияи асосӣ....................................... 
 Сарфи назар кардани ишорагар ба номи библиотека................................... 
 Сарфи назар кардани қавс дар дастури if...................................................... 
 Истифодаи оператори бахшиш дар ҷойи оператори муқоисакунӣ............ 
 Сарфи назар кардани қавсҳои системавӣ...................................................... 
 Сарфи назар кардани навъ барои функсия.................................................... 
 Нодуруст қимат баргардонидани функсия.................................................... 
 Дар функсияҳои навъи холӣ истифода намудани дастури return............... 
 Сарфи назар кардани оператори return дар функсияҳое, ки қимат 
 бармегардонанд................................................................................................ 
 Хатогӣ ҳангоми сарборӣ ниҳодан ба функсияҳо.......................................... 
 Хатогӣ дар пайваст кардани китобхонаи математикӣ................................. 
 Хатогиҳои ҳангоми иҷроиш ва мантиқӣ........................................................ 
 Сарфи назар кардани қимати аввала бахшидан ба тағйирёбандаҳо........... 
 Сарфи назар кардани оператори break дар сохтори switch.......................... 
 Тақсим ба нол................................................................................................... 
 Аз реша баровардани адади манфӣ................................................................ 
 Ислоҳи хатогиҳо............................................................................................... 
 Блоки try............................................................................................................ 
 Блоки catch........................................................................................................ 
 Оператори throw............................................................................................... 
 Намунаи ҳалли мисолҳо.................................................................................. 
 Саволҳо барои мустаҳкамкунӣ....................................................................... 
 Мисолҳо барои мустаҳкамкунӣ:........................................................................ 
 Классҳо, объектҳо. Конструктор ва деструктор........................................... 
 Хосияти меросӣ................................................................................................ 
 Функсияҳои виртуалӣ. Классҳои абстрактӣ.................................................. 
 Сарборигузории амалҳо................................................................................... 
 Коркарди ҳолатҳои истисноӣ.......................................................................... 
 Аъзоҳои доимӣ ва статикии классҳо.............................................................. 
 Китобхонаи стандартии қолабҳо - STL......................................................... 
 БОБИ. ИМКОНИЯТҲОИ ГРАФИКИИ С++................................................. 
 Муқаддима........................................................................................................ 
 Функсияҳои графикӣ дар муҳити Dev C++................................................... 
 Баромадан аз ҳолати графикӣ......................................................................... 
 Истифодаи рангҳо дар график........................................................................ 
 Функсияи initwindow(int width, int height, const char *title=”Windows BGI”)............................................................................................................................ 
 Функсияи arc(int x, int y, int start, int end, int radius)..................................... 
 Функсияи bar(int left, int top, int right, int bottom)......................................... 
 Функсияи bard(int left, int top, int right, int bottom, int depth, int topflag)... 
 Функсияи circle (int x, int y, int radius)........................................................... 
 Функсияи ellipse(int x, int y, int start, int end, int xradius, int yradius)........... 
 Функсияҳои line(int startx, int starty, int endx, int endy), lineto(int x, int y) ва
 linerel(int dx, int dy).......................................................................................... 
 Функсияи rectangle (int left, int top, int right, int bottom)............................... 
 Функсияи void fillellipse( int x, int y, int xradius, int yradius)........................ 
 Функсияи pieslice(int x, int y, int start, int end, int radius)............................. 
 Функсияи sector(int x, int y, int start, int end, int xradius, int yradius ).......... 
 Функсияи drawpoly(int numpoints, int *points)............................................... 
 Функсияи fillpoly (int num points, int *points)................................................ 
 Функсияи putpixel (int x, int y, int color)......................................................... 
 Функсияи getpixel(int x, int y)......................................................................... 
 Функсияи getimage(int left, int top, int right, int bottom, void *buf)............. 
 Функсияи putimage(int x, int y, void *buf, int op)........................................... 
 Функсияи imagesize(int left, int top, int right, int bottom).............................. 
 Функсияи floodfill (int x, int y, int border)....................................................... 
 Функсияҳои getmaxx(void) ва getmaxy(void)................................................. 
 Функсияҳои getx() ва gety()............................................................................. 
 Функсияҳои gotoxy(int x, int y) ва moveto(int x, int y)................................. 
 Функсияҳои outtext(char *str) ва outtextxy(int x, int y, char *str).................. 
 Функсияи settextstyle(int font, int direction, int charsize)............................... 
 Функсияи setcolor (int color)............................................................................ 
 Функсияи setttextjustifi (int horiz, int vert)...................................................... 
 Функсияи setfillstyle(int pattern, int color ).................................................... 
 Функсияи setlinestyle (int style, unsigned pattern, int width).......................... 
 Функсияи delay (unsigned del)......................................................................... 
 Функсияҳоикорбосаҳифаитасвир................................................................... 
 Функсияи textcolor()...................................................................................... 
 Функсияи textbackground()........................................................................... 
 Саволҳо барои мустаҳкамкунӣ:...................................................................... 
 Масъалаҳо барои кори мустақилона.............................................................. 
 Манбаъҳои истифодашуда...................... Ошибка! Закладка не определена.
 БОБИ. СОХТОРҲО (STRUCTURES) 
 Муқаддима 
 Массивҳо ба сохторҳое сарукор гирифтем, ки онҳо аз маҷмӯи 
 элементҳои якҷинса ва дорои сифати якхела таркиб ёфтаанд. Масалан, 
 дастури int a[] муаррифгари як маҷмӯи элементҳои бутун мебошад, ки дар 
 он метавон адади бутунро захира кард. Ба ҳамин монанд массивҳои 
 навъҳои дигар муаррифӣ карда мешаванд. Акнун фарз мекунем, маҷмӯи 
 додаҳои гуногуннавъе дода шуда бошанд. Барои ин навъ маҷмӯи додаҳо аз 
 массивҳо истифода бурда намешавад, зеро ки массивҳо барои элементҳои аз 
 ҷиҳати навъ якхела пешбинӣ шудаанд ва дар онҳо элементҳои якнавъ нигоҳ 
 дошта мешаванд. 
 Масалан, мехоҳем иттилооти як нафар коргарро, ки иборат аз насаб, ном,
 синну сол ва маош мебошанд, дар зери як ном муаррифӣ кунем. Барои ин аз 
 сохтмони додаҳое, ки сохтор ном доранд, истифода бурда мешавад. Сохторҳо 
 маҷмӯи додаҳое мебошанд, ки ба онҳо дар зери як ном муроҷиат карда 
 мешавад. Сохторҳо имконият медиҳанд, ки бо роҳи сода додаҳои гуногунавъ 
 дар зери як ном гирд оварда шаванд. Ин навъ маҷмӯи додаҳо дар забонҳои 
 Паскал, Cobol ва PL/I record номида мешаванд. 
 Ба ибораи дигар, сохторҳо навъи наве мебошанд, ки тавассути корбар 
 муаррифӣ карда мешаванд. Додаҳои ин навъ як тағйирёбанда нубуда, балки 
 метавонанд гурӯҳи тағйирёбандаҳо бошанд. 
 Пас аз пайдоиши БОН аз сохторҳо ҳарчанд, ки камтар истифода бурда 
 мешавад, вале ба ин нигоҳ накарда, онҳо дар баъзе корбурдҳо корбасти васеъ
 доранд. Омӯхтани сохторҳо заминаи омӯхтани БОН-ро фароҳам меоранд. 
 Муаррификунии навъи сохтор 
 Барои истифода аз сохтмони додаҳои сохтор аввал навъи сохтор эҷод 
 карда шуда, сипас, тағйирёбандаҳои лозимӣ аз ин навъ муаррифӣ карда 
 мешаванд. 
 Тарзи умумии муаррификунии як сохтор шакли зеринро дорад: 
 struct struct_name{ 
 Var; 
 Var; 
 ⋯ 
 Var n 
 }; 
 Дар ин ҷо struct-калимаи калидӣ буда, struct_name номи сохтор, var, var,...,
 varn аъзо ё тағйирёбандаҳои сохтор мебошанд, ки онҳоро майдон (field) низ
 меноманд. Дар дохили сохтор барои ҳар як майдон навъи он низ нишон дода 
 мешавад. Барои номгузории сохторҳо, аз қонуни номгузории 
 идентификаторҳо истифода бурда мешавад. Ҳамаи майдонҳои сохтор дар 
 дохили қавси бонизом навишта шуда, рамзи «;» интиҳо ё баохиррасии 
 сохторро муайян мекунад. 
 Бояд қайд кард, ки сохтор пеш аз функсияи асосӣ муаррифӣ карда 
 мешавад.Пас аз он ки сохтор муаррифӣ шуд, тағйирёбандаҳои лозимиро 
 метавон аз навъи он муаррифӣ кард. 
 Азои сохтор метавонанд, тағйирёбандаҳои маъмулӣ, ишорагарҳо, 
 массивҳо ва ҳатто сохторҳои дигар бошанд. Ба ғайр аз ин, номи аъзоҳои 
 сохтор низ метавонанд, тағйирёбандаҳое бошанд, ки дар ҷойи дигар муаррифӣ
 ва истифода шудаанд, вале маслиҳат он аст, ки аз ин кор даст кашем. Сабабаш
 дар он аст, ки бо ин амал метавон гоҳе ба хатогӣ рӯ ба рӯ шуд. 
 Бигзор додаҳои як донишҷӯ ба сурати зерин пешниҳод шуда бошанд: 
 № Насаб Ном Синну сол Маош 
 Алиев Валӣ, 
 Аз ин ҷо сохтори донишҷӯ ба сурати зерин муаррифӣ карда мешавад: 
 struct Student { 
 int no; 
 string Fname; 
 string Lname; 
 int age; 
 float balance; 
 }; 
 Пас аз он ки сохтор бо номи Student муаррифӣ шуд, зарурати 
 муаррифиии тағйирёбандаҳои навъи сохтор пеш меояд, ки онҳо ба сурати 
 зерин муаррифӣ карда мешаванд: 
 Student S,S,S,…Sn; 
 Дарин ҷо ба сифатинавъбароитағйирёбандаҳои S, S, S,… Sn номи 
 сохтор истифода шудааст. Тағйирёбандаҳои сохтор низ тавассути вергул аз 
 ҳамдигар ҷудо карда мешаванд. 
 Илова бар ин, тағйирёбандаҳои навъи сохторро метавон ҳангоми 
 муаррифии сохтор дарҳол ошно кард. Амали мазкур ба шакли зерин иҷро 
 карда мешавад: 
 struct Student { 
 int no; 
 string Fname; 
 string Lname; 
 int age; 
 float balance; 
 } S,S,S,…Sn; 
 Ба ҳамин монанд, аз навъи сохтор метавон ба миқдори лозимии 
 тағйирёбанда муаррифӣ кард. Илова бар ин, як сохтор метавонад дар дохили 
 функсияи асосӣ муаррифӣ гардад. Ин навъ сохторҳоро сохторҳои локалӣ 
 меноманд. 
 Дастрасӣ ба майдонҳои сохтор 
 Пас аз оне, ки тағйирёбандаҳо аз навъи сохтор муаррифӣ шуданд, 
 зарурати дастрасӣ ба онҳо пеш меояд, ба монанди қимат бахшидан ба 
 майдонҳо, дохил ва хориҷ намудани қимати майдонҳо ва ғайра. Тавассути 
 тағйирёбандаи навъи сохтор ва оператори нуқта (dot) ба майдонҳои сохтор 
 дастрас шудан мумкин аст. Наҳви дастрасшавӣ ба майдонҳои сохтор шакли 
 зеринро дорад. 
 Тағйирёбандаи_навъи_сохтор, майдони_сохтор; 
 Ба ин тартиб барои дастрас шудан ба майдонҳои сохтори Student 
 тавасссути тағйирёбандаи S, ки қаблан муаррифӣ шуда буд, ба сурати зерин 
 амал карда мешавад: 
 S.no; 
 S.Fname; 
 S.Lname; 
 S.age; 
 S.balance; 
 Ба ҳамин монанд низ метавон ба майдонҳои сохтори Student қимат 
 бахшид: 
 S.no=; 
 S.Fname="Aliev"; 
 S.Lname="Vali"; 
 S.age=; 
 S.balance=.; 
 Ба ҳамдигар бахшидани сохторҳо 
 Монанди тағйирёбандаҳои муқаррарӣ як тағйирёбандаи сохторро 
 метавон ба тағйирёбандаи дигаре аз ҳамин навъи сохтор бахшид. Масалан, 
 фарз мекунем, ки тағйирёбандаҳои S ва S аз навъи сохтори Student мебошанд.
 Аз ин ҷо навишти дастурҳои зерин қобили қабул мебошад: 
 S.no=; 
 S.Fname="Aliev"; 
 S.Lname="Vali"; 
 S.age=; 
 S.balance=.; 
 …… 
 S=S; 
 Пас аз ин майдонҳои тағйирёбандаи S низ дорои қимати ба майдонҳои 
 S монанд мешавад. 
 Дохил ва хориҷ намудани тағйирёбандаҳои сохтор 
 Пас аз муаррификунии тағйирёбандаҳои навъи сохтор зарурати дохил 
 ва хориҷ намудани онҳо пеш меояд. Имконияти яку якбора дохил ва хориҷ 
 намудани тағйирёбандаҳои сохтор вуҷуд надорад. Аз ин ҷо ҳар як майдони 
 сохтор алоҳида-алоҳида дохил ва хориҷ карда мешаванд. 
 Мисол. Барномае нависед, ки маълумоти n нафар донишҷӯро, ки дар 
 сохтори Student муаррифӣ шудаанд, аз вуруди хонда, донишҷӯеро, ки аз ҳама
 balance-и зиёдтар дорад, хориҷ кунад. 
 #include <iostream> 
 #include <string.h> 
 using namespace std; 
 struct Student { 
 int no; 
 char Fname; 
 char Lname; 
 int age; 
 float balance; 
 }; 
 int main(){ 
 Student S,max; 
 int i, n; 
 cin>>n; 
 max.balance=-; 
 for (i=; i<=n; i++) 
 { 
 S.no=i; 
 cout<<"Enter Fname:"; cin>>S.Fname; 
 cout<<"Enter Lname:"; cin>>S.Lname; 
 cout<<"Enter age:"; 
 cin>>S.age; 
 cout<<"Enter balance:"; 
 cin>>S.balance; 
 if (S.balance>max.balance){ 
 max=S; 
 } 
 } 
 cout<<max.no<<"\t"<<max.Fname<<"\t"<<max.Lname<<"\t"<< 
 max.age<<" \t "<<max.balance; 
 return; 
 } 
 Дар ин ҷо ду тағйирёбанда бо номи S ва max аз навъи Student муаррифӣ
 карда шудааст, сипас, ба майдони balance-и max қимати - бахшида шудааст.
 Пас аз ин, дар дохили ҳалқаи такрорӣ маълумоти n нафар донишҷӯ аз 
 клавиатура дохил карда мешаванд. Пас аз ҳар дохилкунӣ қимати balance-и S 
 ба қимати balance-и max муқоиса карда мешавад. Агар қимати balance-и S аз
 қимати balance-и max калон бошад, ҳамаи майдонҳои S ба max бахшида 
 мешаванд. Баъди ба охиррасии давр ҳамаи маълумоти донишҷӯи мавриди 
 назар хориҷ карда мешаванд. 
 Ба аъзои сохтор бахшидани қимати аввала 
 Ҳангоми муаррификунии сохтор якбора наметавон ба ягон аъзои он 
 қимати аввала бахшид. Барои ба майдонҳои сохтор бахшидани қимати аввала 
 тағйирёбандае аз навъи сохтор муаррифӣ карда мешавад ва сипас тавассути 
 он ба тағйирёбандаҳои сохтор қимати аввала бахшида мешавад. Қимати 
 ибтидоӣ бояд ба тартиби ҷойгиршавии аъзоҳои сохтор дар дохили қавси 
 системавӣ навишта шавад. Ба барномаи зерин диққат диҳед: 
 #include <iostream> 
 #include <string.h> 
 using namespace std; 
 int main(){ 
 double x; 
 struct rec { 
 int a; 
 float b; 
 double c; 
 }; 
 static struct rec d={,.,.}; 
 x=d.a+d.b+d.c; 
 cout<<"x="<<x; 
 return; 
 } 
 Дар ин ҷо d як тағйирёбандаи доимии навъи сохтор мебошад, ки бо ёрии
 он ба тағйирёбандаҳои сохтор қимати авввала бахшида мешавад, яъне ба 
 аъзои якум ба аъзои дуюм, ва ба аъзои охирон,. Агар дар дохили
 функсияе, ки дар он сохтор муаррифӣ шудааст, ба аъзоҳои сохтор қимати 
 аввала бахшем, навиштани калимаи калидии struct лозим намебошад. Аз ин ҷо
 метавонем бо таври зерин ба аъзои сохтор қимати аввала бахшем: 
 static rec d={,.,.}; 
 ва ҳатто метавонем калимаи static-ро низ истифода набарем, яъне 
 recd={,.,.} нависем. 
 Методҳо. Муаррифӣ намудани методҳо 
 Метод ин функсияе мебошад, ки дар дохили сохтор муаррифӣ гардида, 
 метавонад амали муносиберо анҷом диҳад. Тамоми сигнатурҳои метод айнан 
 ба функсия монанд буда, фарқияташ дар он аст, ки метод тавассути 
 тағйирёбандаҳои навъи сохтор даъват карда мешавад. Барои даъвати функсия 
 бошад, амали алоҳидае вуҷуд надорад, яъне метод қисми сохтор буда, барои 
 даъвати он бояд объект сохта шавад. Аз ин рӯ, методҳоро инчунин функсия -
 аъзо низ меноманд.. Натиҷаи ба даст омадаи метод аз намуди даъвати он 
 вобастагӣ дорад. Наҳви умумии муаррифсозии метод шакли зеринро дорад: 
 Тип номи_метод(рӯйхати аргументҳо ) 
 { 
 Тани метод 
 } 
 Барои пурратар шинос шудан ба ин матлаб мисолеро дида мебароем. 
 Мисол. Сохторе дорои ду майдони ададӣ дода шудааст. Барномае нависед, ки 
 маҷмӯи майдонҳои онро ҳисоб кунад. 
 #include <iostream> 
 #include <string.h> 
 using namespace std; 
 struct Simple { 
 float a; 
 float b; 
 float sum(){ 
 return a+b; 
 } 
 }; 
 int main() 
 { 
 Simple s; 
 s.a=.; 
 s.b=.; 
 cout<<s.sum(); 
 return; 
 } 
 Дар ин ҷо бо номи Sum() методе муаррифӣ шудааст, ки суммаи 
 майдонҳои сохторро бармегардонад. Дар функсияи асосӣ, дар дастгоҳи 
 вурудӣ тавассути тағйирёбандаи s методи мазкур даъват карда шудааст. 
 Ба ҳамин монанд, метавон методҳои дигарро низ муаррифӣ кард. 
 Конструктор. Истифодаи конструктор 
 Конструктор монанди як функсия буда, барои ба тағйирёбандаҳои 
 сохтор бахшидани қимати аввала хизмат мекунад. Конструктор дорои 
 хосиятҳои зерин мебошад: 
 намешавад. 
 Конструктор метавонад дорои аргумент бошад. 
 Вазифаи асосии коструктор ҳангоми муаррифӣ намудани тағйирёбандаи 
 навъи сохтор ба майдонҳои он қимати аввала мебахшад. Барои ба ин матлаб 
 хубтар шинос шудан ба мисоли зерин диққат диҳед: 
 #include <iostream> 
 #include <string.h> 
 using namespace std; 
 struct Student { 
 int no; 
 string Fname; 
 string Lname; 
 int age; 
 float balance; 
 //Конструктор 
 Student(){ 
 no=; 
 Fname="Aliev"; 
 Lname="Vali"; 
 age=; 
 balance=.; 
 } 
 }; 
 int main() 
 { 
 Student S; 
 cout<<S.no<<"\t"<<S.Fname<<"\t"<<S.Lname<<"\t"<<S.age< 
 <" \t "<<S.balance; 
 return; 
 } 
 Тавре аён аст, дар ин мисол конструкторе, ки номи он бо сохтор якхела
 аст, муаррифӣ гардидааст. Ин конструктор ҳамчун қимати ибтидоӣ ба 
 майдонҳои класс қимати ибтидоӣ мебахшад. Сипас, дар методи асосӣ 
 тағйирёбандаи S аз навъи Student муаррифӣ гардида, тавассути он майдонҳои
 сохтор хориҷ карда шудаанд. 
 Илова бар ин, конструктор метавонад дорои аргумент бошад. Дар ин 
 сурат, пас аз тағйирёбандаҳои навъи сохтор дар дохили қавси оддӣ қимати 
 майдонҳо навишта мешаванд. Ба мисоли зерин диққат диҳед. 
 #include <iostream> 
 using namespace std; 
 struct Student { 
 int no; 
 string Fname; 
 string Lname; 
 int age; 
 float balance; 
 Student(int n,string s, string s, int a, float b) 
 { 
 no=n; 
 Fname=s; 
 Lname=s; 
 age=a; 
 balance=b; 
 } 
 }; 
 int main(){ 
 Student S(, "Aliev", "Vali",,.); 
 cout<<S.no<<"\t"<<S.Fname<<"\t"<<S.Lname<<"\t"<<S.age< 
 <"\t " <<S.balance; 
 return; 
 } 
 Массивҳо аз навъи сохтор 
 Масивҳоро метавон аз навъи сохтор низ муаррифӣ кард. Барои ин аввал 
 сохтор ва баъд аз навъи он массив муаррифӣ карда мешавад. Элементҳои 
 чунин массив ҳамон аъзоҳои сохтор мебошанд. 
 Мисоли. Барномае нависед, ки рақами тартибӣ, ному насаб, синну сол
 ва маоши нафар коргарро барорад. Барои ин аз сохторҳо истифода баред, 
 яъне рақами тартибӣ, фамилия, ном, синну сол ва маъош аъзоҳои сохтор 
 бошанд. 
 #include <iostream> 
 using namespace std; 
 int main() { 
 struct rec 
 { 
 char firstName[]; 
 char name[]; 
 int Ss; 
 float maosh; 
 }; 
 static struct rec d[]={ 
 {"Saidov","Said",,.}, 
 {"Dodarov","Habib",,.}, 
 {"Saidov","Salim",,.}, 
 {"Younusov","Yousuf",,.}, 
 {"Aminov","Amina",,.}, 
 }; 
 cout<<"Rt "<<"first- 
 Name\t"<<"\tname\t"<<"Age\t"<<"maosh\n"; 
 for (int i=;i<;i++) 
 cout<<i+<<" "<<d[i].first- 
 Name<<"\t"<<d[i].name<<"\t"<< 
 d[i].Ss<<"\t"<<d[i].maosh<<endl; 
 return; 
 } 
 Дар ин ҷо сохторе бо номи rec муаррифӣ шудааст, ки аъзоҳои он 
 тағйирёбандаҳои Rt, firstName, name, Ss ва maosh мебошанд, яъне 
 struct rec{ 
 char firstName[]; 
 char name[]; 
 int Ss; 
 float maosh; 
 }; 
 Баъд аз ин, массиве бо номи d, ки андозаи он пешакӣ муайян нест, аз 
 навъи сохтор муаррифӣ шуда, ба сифати қимати аввала ба элементҳои он 
 қимати аъзоҳоҳои сохтор бахшида шудаанд, яъне 
 static struct rec d[]={ 
 {"Saidov","Said",,.}, 
 {"Dodarov","Habib",,.}, 
 {"Saidov","Salim",,.}, 
 {"Younusov","Yousuf",,.}, 
 {"Aminova","Amina",,.}, 
 }; 
 Дар ин мисол индекси калонтари массив баробари мебошад, чунки 
 массив дорои чор сатр аст ва аз то рақамгузорӣ карда мешавад. Агар 
 пешакӣ қимати сатрҳо муайян бошанд, метавонем дар вақти муаррификунӣ 
 андозаи массивро нависем, яъне d[]. Дар қисмати баъдӣ бо ёрии оператори 
 хориҷкунӣ элементҳои массив, ки аз навъи сохтор буданд, хориҷ карда 
 шудаанд. 
 for (int i=;i<;i++) 
 cout<<i+<<"\t"<<d[i].firstName<<"\t"<<d[i].name<<"\t"<< 
 d[i].Ss<<"\t"<<d[i].maosh<<endl; 
 Натиҷаи барнома шакли зайлро соҳиб мешавад. 
 Rt firstName name Age maosh 
 Saidov Said 
 Dodarov Habib. 
 Saidov Salim. 
 Younusov Yousuf. 
 Таҳлилияксохтор 
 Ҳар як аъзои сохтор додаест мустақил ва метавон бо ҳар як аъзо амали
 алоҳидаеро анҷом дод. Барои дастрасшавӣ ба аъзоҳои сохтор аз оператори 
 (dot) истифода бурда мешавад. Масалан, бигзор сохтори зерин муаррифӣ шуда
 бошад: 
 struct Time { 
 int soat; 
 int mi- 
 nute; 
 int 
 second; 
 }; 
 Пас аз ин, бигзор тағйирёбандаи t-ро аз навъи сохтор муаррифӣ кунем.
 он гоҳ аз оператори зерин истифода мебарем. 
 Time t; 
 Барои қимате аъзоҳои сохторро аз клавиатура ворид кардан аз оператори
 dot(.) ба сурати зерин истифода бурда мешавад. 
 cin>>t.soat; 
 cin>>t.minute; 
 cin>>t.secont 
 Тавре ки қайд кардем, ҳар як аъзои сохтор мустақил буда, аз дигар 
 аъзоҳо вобастагӣ надорад ва мо метавонем, болои ҳар кадом аъзо амали 
 ҷудогонаеро анҷом диҳем. Мисол. Cохтор дода шудааст, барои ҳар кадом 
 аъзои он амали муайянеро анҷом диҳед. 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 struct pard { 
 int a; 
 float f; 
 double d; 
 }; 
 pard P; 
 cout<<"a=";cin>>P.a; 
 cout<<"f=";cin>>P.f; 
 cout<<"d=";cin>>P.d; 
 P.a++; 
 P.f+=; 
 P.d--; 
 cout<<"a="<<P.a<<"\tf= "<<P.f <<"\t d= "<<P.d; 
 return; 
 } 
 Тавре ки дида мешавад, дар ин мисол барои ҳар як аъзои сохтор амали 
 муайяне иҷро шудааст, яъне барои аъзои бутуни сохтор амали инкремент, 
 барои аъзои ҳақиқии сохтор амали ҷамъи ҳунарӣ ва барои аъзои ҳақиқии 
 калони сохтор бошад, амали декримент иҷро карда шуда, сипас, бо ёрии 
 оператори хориҷкунӣ қиматҳои аъзоҳо хориҷ карда шудаанд. 
 Сохторҳои дохилиҳам 
 Ба ғайр аз ин, як майдони сохтор метавонад, ки худ сохтор бошад. Ин 
 навъ сохторҳоро сохторҳои дохилиҳам мегӯянд. Дар ин ҳолат бояд аввал 
 сохтори беруна ва баъд сохтори даруна муаррифӣ гардад. 
 Мисол. Барномае нависед, ки ному насаб, рақами тартибӣ, рақами 
 телефон ва суроғаи донишҷӯёнро аз рӯй алифбо мураттаб намуда, ҳамчун 
 ҳисобот хориҷ кунад. Ба ғайр аз ин, дар барнома имконияти ҷустуҷӯи 
 маълумот дар бораи як донишҷӯ аз рӯй рақами тартибии он мавҷуд бошад, 
 яъне рақами тартибии як донишҷӯ аз оператори хориҷкунӣ дохил карда 
 мешавад, агар донишҷӯ бо ин рақам мавҷуд бошад, тамоми маълумоти он 
 хориҷ карда шаванд ва дар сурати акс пайғоми муносибе хориҷ гардад. 
 Маълумоти як донишҷӯ ба сурати зерин дода мешаванд: 
 Rt Ном(name) Телефон (tel) Суроға 
 Фамилия Ном Насаб (adddres) 
 (lastname) (firstname) 
 (middLename) 
 Тавре ки аз ин ҷадвал дида мешавад, додаҳои як донишҷӯ сохторест, ки
 дорои чор майдон rt, name, tel ва address. Илова бар ин ҷо боз майдони name
 сохторест, ки дорои ду узв аст. Барои ҳалли ин масъала аз сохторҳои 
 дохилиҳам истифода мебарем. Агар номи сохтори аслиро donishJu гузорем, 
 пас метавонем, ба ҳар як аъзои он ба сурати: donishJu.rt, donishJu.name, 
 donishJu.tel ва donishJu.address муроҷиат кунем. Ба ҳамин монанд барои ба
 аъзоҳои сохтори name дастрас шудан аз оператори ДОТ ду маротиба 
 истифода карда мешавад. Барои сохтори name номе ихтисос медиҳем. 
 Масалан, name ва сипас, бо аъзоҳои он ба шакли зерин дастрас шудан 
 мумкин аст. 
 donishJu.name.lastname, 
 donishJu.name.firstname 
 donishJu.name.middle.name 
 Ҳал. Коди барномаи мавриди назар ба сурати зерин аст. 
 #include <iostream> 
 using namespace std; 
 int main() { 
 struct rec { 
 int st_no; 
 struct name { 
 char l_name[]; 
 char f_name[]; 
 char m_name[]; 
 }name; 
 char tel[]; 
 char addr[]; 
 }; 
 int i,j,n,s_no; 
 struct rec donishJu[],temp; 
 cout<<"n=";cin>>n; 
 for(i=;i<n;i++) { 
 cout<<"st_no="; cin>>donishJu[i].st_no; 
 cout<<"l_name="; cin>>don- 
 ishJu[i].name.l_name; 
 cout<<"f_name="; cin>>donishJu[i].name.f_name; 
 cout<<"m_name="; cin>>don- 
 ishJu[i].name.m_name; 
 cout<<"tel="; cin>>donishJu[i].tel; 
 cout<<"addr="; cin>>donishJu[i].addr; 
 } 
 cout<<"Murattab nishon dodani donishjuyon az rui 
 raqam\n"; 
 for (i=;i<n;i++) 
 for (j=i+;j<n;j++) 
 if(donishJu[i].st_no>donishJu[j].st_no) { 
 temp=donishJu[i]; 
 donishJu[i]=donishJu[j]; 
 donishJu[j]=temp; 
 } 
 cout<<"st_no "<<" firstNameilya\t"<<" 
 name\t" <<" LastName "<<" telphon\t" <<" Address\n"; 
 for (i=;i<n;i++) { 
 cout<<donishJu[i].st_no<<"\t"; 
 cout<<donishJu[i].name.l_name<<" "; 
 cout<<donishJu[i].name.f_name<<" "; 
 cout<<donishJu[i].name.m_name<<" "; 
 cout<<donishJu[i].tel<<" "; 
 cout<<donishJu[i].addr <<" "; 
 cout<<endl; 
 } 
 cout<<"\n raqami tartibii donishjuro baroi 
 justuju vorid kuned"<<endl; 
 cout<<"st_no="; cin>>s_no; 
 for (i=;i<n;++i) 
 if(s_no== donishJu[i].st_no) 
 break; 
 if (i<n) { 
 cout<<"firstName="<<don- 
 ishJu[i].name.l_name<<endl; 
 cout<< "name="<<don- 
 ishJu[i].name.f_name<<endl; 
 cout<< "LastName="<<don- 
 ishJu[i].name.m_name<<endl; 
 cout<< "tel="<<donishJu[i].tel<<endl; 
 cout<< "Address="<<donishJu[i].addr 
 <<endl; 
 } 
 else 
 cout<<"Bo in raqam donishju vujud 
 nadorad!!"<<endl; 
 return; 
 } 
 Ишорагар ба сохтор (pointer to struct) 
 Дар забони С++ ишорагар ба сохтор монанди ишорагар ба дигар навъҳои 
 стандартӣ мебошад.Монанди ишорагарҳои дигар барои муаррифӣ намудани 
 ишорагар ба сохтор аз опереатори ситорача (*) истифода бурда мешавад. 
 Оператори мазкур дар вақти муаррификунӣ пеш аз номи ишорагар навишта 
 мешавад. Масалан, барои муаррифӣ намудани ишорагар барои класси Student, 
 ки пештар муаррифӣ ва истифода шуда буд, дастури зерин кифоягӣ мекунад. 
 struct Student *addr_pointer; 
 Ишорагар ба сохторҳо дар ду ҳолат истифода бурда мешавад: 
 ) Барои ба сифати аргументи функсия равон кардани суроғаи сохтор. 
 ) Кор бо додаҳои динамикӣ. 
 Барои дастрас намудани суроғаи тағйирёбандаи сохтор аз оператори & 
 истифода бурда мешавад, ба қитъаи барномаи зерин диққат диҳед. 
 char firstName[]; 
 char name[]; 
 int Ss; 
 float maosh; 
 struct Student *p; /* муаррифиишорагарбасохтор*/ 
 Барои суроғаи сохтори Student -ро ба тағйирёбандаи ишорагари p 
 бахшидан аз дастури зерин истифода бурда мешавад: 
 p = & firstName; 
 Барои тавассути ишорагар дастрас шудан ба ягон аъзои сохтор бошад, 
 аз оператори “->” истифода бурда мешавад, ки наҳви он шакли зеринро дорад:
 ишорагар->майдон. 
 Барои пурратар ба ин матлаб шинос шудан барномаи зеринро дида 
 мебароем. 
 #include <iostream> 
 using namespace std; 
 struct adad{ 
 int I; 
 float f; 
 char chr; 
 }; 
 int main() { 
 adad a,b; 
 adad *x,*y; 
 x=&a; y=&b; 
 x->I=; 
 x->f =.; 
 x->chr ='a'; 
 (*y).I =; 
 (*y).f =.; 
 (*y).chr='b'; 
 cout<<"I="<<x->I <<endl; 
 cout<<"f="<<x->f<<endl; 
 cout<<"chr="<<x->chr<<endl<<endl; 
 cout<<"I="<<(*y).I <<endl; 
 cout<<"f="<<(*y).f <<endl; 
 cout<<"chr="<<(*y).chr<<endl; 
 return; 
 } 
 Тавре ки дида мешавад, дар ин ҷо сохторе муаррифӣ гардидааст, ки 
 дорои се аъзо мебошад, яъне 
 struct adad{ 
 int I; 
 float f; 
 char chr; 
 }; 
 Баъд аз ин, дар функсияи аслӣ ду тағйирёбандаи одӣ ва ду тағйирёбандаи
 ишорагар аз навъи сохтор муаррифӣ гардидаанд. Дар тағйирёбандаҳои 
 ишоргар суроғаи он ду тағйирёбандаи оддӣ ҷой дода шуда, сипас бо ду тарз 
 ба аъзоҳои сохтор қимате бахшида шудааст. 
 x->I=; 
 x->f =.; 
 x->chr ='a'; 
 Дар ин тарз оператори “->” истифода бурда шудааст. Баъд аз ин, бо ёрии
 оператори ишорагар ва оператори dot бори дигар ба аъзоҳои сохтор қимат 
 бахшида шудааст. 
 (*y).I =; 
 (*y).f =.; 
 (*y).chr='b'; 
 Баъд аз ин қиматҳои додашуда хориҷ карда шудаанд. 
 cout<<"I="<<x->I <<endl; 
 cout<<"f="<<x->f<<endl; 
 cout<<"chr="<<x->chr<<endl<<endl; 
 cout<<"I="<<(*y).I <<endl; 
 cout<<"f="<<(*y).f <<endl; 
 cout<<"chr="<<(*y).chr<<endl; 
 Натиҷаи барнома шакли зеринро дорад: 
 i= 
 f=. 
 chr=a 
 i= 
 f=. 
 chr=b 
 Равон кардани аъзоҳои сохтор ба функсия 
 Ҳар як майдони сохтор ё як сохторро ба таври комил метавон ба сифати
 параметр ба зербарномаҳо равон кард ва ё ҳамчун қимати интиҳои аз 
 зербарнома ба функсияи асосӣ баргардонд. Равон кардани майдонҳои сохтор 
 ба зербарнома ва баръакс монанди тағйирёбандаҳои маъмулӣ иҷро карда 
 мешавад. 
 Барои ин матлабро беҳтар фаҳмидан ва ба моҳияти он сарфаҳи рафтан 
 мисолеро дида мебароем. 
 struct SimpleStruct{ 
 char x; 
 int y; 
 float z; 
 char s[]; 
 } mike; 
 Пас аз муаррифӣ гардидани сохтор барои ба сифати аргументи 
 зербарнома равон кардани аъзоҳо яке аз дастурҳои зерин истифода бурда 
 мешавад: 
 func(mike.x); /* Қимати символии х равон карда мешавад */ 
 func(mike.y); /* Қимати аъзои бутуни у равон карда мешавад */ 
 func(mike.z); /* Қимати аъзои ҳақиқии z равон карда мешавад */ 
 func(mike.s); /* Суроғаи аъзои сатрии s равон карда мешавад. */ 
 func(mike.s[]); /*Қимати символи s[] равон карда мешавад. */ 
 Дар ҳар як аз ин ҳолатҳо ба функсия қимати элементи муайян равон 
 карда мешавад.Баъзан лозим мегардад, ки суроғаи элементи муайяне равон 
 карда шавад, барои иҷрои ин амал пеш аз номи аъзои сохтор оператори & 
 навишта мешавад. Ба сифати мисол ба дастурҳои зерин диққат диҳед: 
 func(&mike.x); /* Суроғаи символии х равон карда мешавад */ 
 func(&mike.y); /* Суроғаи аъзои бутуни у равон карда мешавад */ 
 func(&mike.z); /* Суроғаи аъзои ҳақиқии z равон карда мешавад */ 
 func(mike.s); /* Суроғаи аъзои сатрии s равон карда мешавад. */ 
 func(&mike.s[]); /* суроғаи символи s[] равон карда мешавад. */ 
 Тавре ки дида мешавад, символи & пеш аз номи сохтор навишта 
 мешавад, на пеш аз аъзоҳо. Ба ғайр аз ин, s худаш суроғаи сатрро муайян 
 мекунад, аз ин ҷо пеш аз ин аъзо оператори & навишта намешавад. 
 Мисоли дигар. Барномае нависед, ин бо истифода аз зербарнома суммаи 
 ду адади комплексӣ ҳисоб карда шаванд. 
 Қайд. Аз нуқтаи назари риёзӣ медонем, ки адади комплекси намуди 
 зеринро дорад: 
 𝑧 = 𝑥 + 𝑖𝑦 
 Дар ин ҷо х=Re(z) –қисми ҳақиқии адади комплексӣ буда, y=Im(z)– қисми 
 мавҳум мебошад. Барои ҷамъ намудани ду адади комплексӣ қисмҳои ҳақиқӣ 
 бо ҳақиқӣ ва қисмҳои мавҳум бо мавҳум ҷамъ карда мешаванд. 
 #include <iostream> 
 using namespace std; 
 struct Complex { 
 float Re; 
 float Im; 
 }; 
 void InputComolex(Complex &X){ 
 cout<<"Enter Real part, unReal part \n"; 
 cin>>X.Re>>X.Im; 
 } 
 int main() 
 { 
 Complex x,y,z; 
 InputComolex(x); 
 InputComolex(y); 
 freopen("output.txt","w",stdout); 
 z.Re =x.Re+y.Re; 
 z.Im =x.Im +y.Im; 
 cout<<"Summa Real part="<<z.Re <<" Summ unreal 
 part="<<z.Im; 
 return; 
 } 
 Натиҷаи барнома шакли зеринро дорад: 
 Enter Real part, unReal part 
 -.. 
 Summa Real part=-. Summ unreal part=. 
 Ишорагари сохторро баргардонидани функсия 
 Як функсия метавонад, ишорагареро ба як сохтор баргардонад. Мисоли 
 зерин ин амалро нишон медиҳад. 
 Мисол. Барномае нависед, ки бо даъват кардани функсияи бо номи 
 search массиве аз сохторро, ки аъзоҳои он маълумотҳои донишҷӯён мебошанд,
 баргардонад. Ин барнома бояд дорои чунин имкониятҳо бошад: бо дохил 
 намудани рақами тартибии як нафар донишҷӯ маълумотҳои боқимондаи 
 донишҷӯро барорад. Агар рақами воридшуда ба рақами тартибии ягон 
 донишҷӯ мувофиқат накунад, пайғоми муносибе хориҷ кунад. Амали дохил 
 намудани қимат барои ҷустуҷӯ то ҳангоме ки адад ғайринулӣ аст, идома ёбад
 ва ҳангоми ворид намудан сифр барнома кори худро қатъ намояд. 
 #include <iostream> 
 #include <string> 
 using namespace std; 
 #define Null 
 const int n=; 
 struct student { 
 int st_no; 
 char *l_name; 
 char *f_name; 
 char *m_name; 
 long recordbook; 
 char *tel; 
 }; 
 student *search(student table[],int s_no){ 
 int k; 
 for(k=; k<n;k++) 
 if(table[k].st_no ==s_no) 
 return (&table[k]); 
 return Null; 
 } 
 int main() { 
 static student customer[]={ 
 {,"Saidov","Umar","Kurbonovich",,"---"}, 
 {,"Dodarov","Habib","Kurbonovich",,"---"}, 
 {,"Aliev","Vali","Saidovich",,"---"}, 
 }; 
 int s_no; 
 student*pt; 
 cout<<"s_no=";cin>>s_no; 
 while( s_no!=){ 
 pt=search(customer, s_no); 
 if(pt!=Null) { 
 cout<<"l_name="<<pt->l_name <<endl; 
 cout<<"f_name="<<pt->f_name <<endl; 
 cout<<"m_name="<<pt->m_name <<endl; 
 cout<<"recordbook="<<pt->recordbook<<endl; 
 cout<<"tel="<<pt->tel<<endl; 
 } 
 else 
 cout<<"\nerror-pleas try again!!\n"; 
 cout<<"\ns_no="; cin>>s_no; 
 } 
 return; 
 } 
 Натиҷаи барнома шакли зеринро дорад: 
 s_no = 
 l_name=Saidov 
 f_name=Umar 
 m_name= Kurbonovich 
 recordbook= 
 tel=--- 
 s_no= 
 error-pleas try again!! 
 s_no= 
 Ба сифати аргументи функсия равон кардани сохтор 
 Метавон тамоми як сохторро ба функсия ба сифати аргумент низ 
 фиристод ва ё як сохторро аз функсия бо ёрии оператори return баргардонид.
 Чунин навъ равон кардани сохтор аз рӯй суроға набуда, аз рӯй миқдор 
 мебошад, яъне як сохтор батамом нусхабардорӣ шуда, ба функсия равона 
 карда мешавад. Ҳар амале, ки дар функсия болои ин сохтор иҷро мекунад, дар
 функсияҳои дигар ҳатто функсияи аслӣ низ шинохта намешавад. Танҳо 
 тағйирот дар нуқтаи фурӯхонанда фаҳмида мешаваду халос. Дар мисоли поён 
 истифодаи ин амал нишон дода шудааст. Мисол. 
 #include <iostream> 
 #include <string> 
 using namespace std; 
 struct student { 
 int st_no; 
 char *l_name; 
 char *f_name; 
 char *m_name; 
 long recordbook; 
 char *tel; 
 }; 
 void func(student inf){ 
 inf.st_no =; 
 inf.l_name ="Saidov"; 
 inf.f_name ="Umar"; 
 inf.m_name ="Kurbonovich"; 
 inf.recordbook =; 
 inf.tel ="---"; 
 } 
 int main(){ 
 static student inform={,"Dodarov","Habib","Kurbono- 
 vich",,"---"}; 
 cout<<"st_no="<<inform.st_no <<endl; 
 cout<<"l_name="<<inform.l_name <<endl; 
 cout<<"f_name="<<inform.f_name <<endl; 
 cout<<"m_name="<<inform.m_name<<endl; 
 cout<<"recordbook="<<inform.recordbook<<endl; 
 cout<<"tel="<<inform.tel <<endl<<endl; 
 func(inform); 
 cout<<"st_no="<<inform.st_no <<endl; 
 cout<<"l_name="<<inform.l_name <<endl; 
 cout<<"f_name="<<inform.f_name <<endl; 
 cout<<"m_name="<<inform.m_name<<endl; 
 cout<<"recordbook="<<inform.recordbook<<endl; 
 cout<<"tel="<<inform.tel <<endl<<endl; 
 return; 
 } 
 Барномаи мазкур як сохторро нусхабардорӣ намуда, ба функсия равон 
 мекунад. Функсия бошад, сохтори фиристодашударо дарёфт карда, ба он 
 қимат мебахшад. Аз сабаби он ки дар ин ҷо ба функсияи аслӣ чизе 
 баргардонида нашудааст, натиҷаи барнома фақат додаҳои дохили худи сохтор 
 мебошанд. Қимате, ки дар функсия ба аъзоҳои сохтор бахшида шуда буд, дар 
 функсияи аслӣ шинохта намешавад. Натиҷаи барнома шакли зеринро дорад: 
 s_no = 
 l_name=Dodarov 
 f_name=Habib 
 m_name= Kurbonovich 
 recordbook= 
 tel=--- 
 s_no= 
 l_name=Dodarov 
 f_name=Habib 
 m_name= Kurbonovich 
 recordbook= 
 tel=--- 
 Илова бар ин, як функсия метавонад, ба сифати натиҷа як сохторро 
 баргардонад. Барои намуна барномаи қаблиро камтар тағйир медиҳем. 
 #include <iostream> 
 #include <string> 
 using namespace std; 
 struct student { 
 int st_no; 
 char *l_name; 
 char *f_name; 
 char *m_name; 
 long recordbook; 
 char *tel; 
 }; 
 student func(student inf){ 
 inf.st_no =; 
 inf.l_name ="Saidov"; 
 inf.f_name ="Umar"; 
 inf.m_name ="Kurbonovich"; 
 inf.recordbook =; 
 inf.tel ="---"; 
 return (inf); 
 } 
 int main(){ 
 static student inform={,"Dodarov","Habib","Kurbonovich",,"--- 
 "}; 
 cout<<"st_no="<<inform.st_no <<endl; 
 cout<<"l_name="<<inform.l_name <<endl; 
 cout<<"f_name="<<inform.f_name <<endl; 
 cout<<"m_name="<<inform.m_name<<endl; 
 cout<<"recordbook="<<inform.recordbook<<endl; 
 cout<<"tel="<<inform.tel <<endl<<endl; 
 inform= func(inform); 
 cout<<"st_no="<<inform.st_no <<endl; 
 cout<<"l_name="<<inform.l_name <<endl; 
 cout<<"f_name="<<inform.f_name <<endl; 
 cout<<"m_name="<<inform.m_name<<endl; 
 cout<<"recordbook="<<inform.recordbook<<endl; 
 cout<<"tel="<<inform.tel <<endl<<endl; 
 return; 
 } 
 Дар ин намуди барнома, ки функсияро аз навъи сохтор муаррифӣ кардем 
 ва бо ёрии оператори бахшиш ба аъзоҳои сохтор майдонҳои тағйирёбандаи 
 inf бахшида шудааст. Дар ин ҳолат натиҷаи барнома шакли зеринро мегирад: 
 s_no= 
 f_name=Habib 
 m_name= Kurbonovich 
 recordbook= 
 tel=--- 
 s_no= 
 l_name=Saidov 
 f_name=Umar 
 m_name= Kurbonovich 
 recordbook= 
 tel=--- 
 Ҳангоми равон кардани сохтор ба функсия ва даъвати функсия бояд 
 навъи сохторҳо ҳам дар функсияи даъваткунанда ва ҳам дар функсияи 
 даъватшаванда якхела бошад. Дар сурати риоя накардани ин қонуният, 
 барнома ба хатогӣ рӯ ба рӯ мешавад. Новобаста аз он ки ду сохтори дорои 
 аъзоҳои якхела бошанд, ба барномаи зерин диққат диҳед: 
 #include <iostream> 
 #include <stdio.h> 
 using namespace std; 
 /* Муайянкарданинавъисохтор */ 
 struct Simple_Struct { 
 int a, b; 
 charch; 
 }; 
 /* Муайян намудани сохтор ба сохтори пешина монанд, вале бо 
 дигар ном. */ 
 struct Simple_Struct { 
 int a, b; 
 char ch; 
 }; 
 void f(struct struct_type parm); 
 int main(){ 
 struct struct_type arg; 
 arg.a =; 
 f(arg); /* Навъиномувофиқ */ 
 return; 
 } 
 void f(struct struct_type parm){ 
 printf("%d", parm.a); 
 } 
 Навъи додаҳое, ки ба воситаи корбар муаррифи мегарданд (user- 
 defined data types) 
 Дар забони С++/С истифодабарандагон (корбарон) имконият доранд, ки 
 номи нав барои навъи додаҳо, яъне ба ягон навъи дода эк-вивилент муаррифӣ
 карда истифода барад. Ин амал ба ёрии калимаи калидии typedef анҷом 
 меёбад. Агар ба мантиқи барнома нигарем, навъи нав пайдо нагардида, балки
 ба ягон навъ номи нав дода мешавад. Вақте ки номи нав пайдо шуд, метавонем
 тағйирёбндаҳои лозимӣ, ҳатто массивҳо ва сохторҳоро низ аз он навъ 
 муаррифӣ кунем. Наҳви оператори typedef ба намуди зерин аст: 
 typedef type new_type 
 Дар ин ҷо type навъи дода буда, метавонад дилхоҳ навъи стандартӣ 
 бошад, ба монанди int, float, double, char ва ғайра. Масалан, барои навъи int
 метавон ба таври зерин номи нав гузошт, яъне 
 typedef int butun; 
 Дар ин ҷо барои навъи int номи нав butun муаррифӣ шудааст. Пас аз ин,
 дар ҳар ҷойи барнома метавонем, тағйирёбандаҳои навъи бутунро ба номи 
 butun ба таври муаррифӣ кунем: 
 betun a,b; ё int a,b; 
 Ба ҳамин монанд метавонем, барои дилхоҳ навъи додаҳо номи нав 
 гузошта истифода барем. Мисол: 
 #include <iostream> 
 #include <stdio.h> 
 using namespace std; 
 typedef int butun; 
 typedef float haqiqi; 
 int main(){ 
 butun i,n=; 
 haqiqi S=,P; 
 for (i=;i<=n;i++) 
 S+=i; 
 P=S/n; 
 cout<<"P="<<P<<endl; 
 return; 
 } 
 Дар ин ҷо дида мешавад, ки барои навъи int номи butun ва барои навъи
 float номи haqiqi муаррифӣ шудааст ва дар барномаи тағйирёбандаҳои i ва n
 аз навъи butun ва тағйирёбандаҳои S ва P аз навъи haqiqi муаррифӣ шудааст.
 Истифодаи typedef бахусус барои муаррифӣ намудани сохторҳо корро 
 осон мекунад, яъне аз такроршавии калимаи struct озод мешавем. Мисол: 
 typedef struct{ 
 var; 
 var;.... 
 Var n; 
 } new_type; 
 Дар ин ҷо new_type навъи сохторро муаррифӣ мекунад. Аз ин ҷо 
 метавонем аъзоҳо ё тағйирёбандаҳои навъи сохторро бо чунин навъ муаррифӣ 
 кард. Мисол: 
 typedef struct{ 
 int st_no; 
 char f_name[]; 
 float balance; 
 } record; 
 record new_balance, l_name[], m_name[]; 
 Дар ин ҷо record аз навъи сохтор муаррифӣ шудааст. Тағйирёбандаҳои 
 new_balance, l_name[] ва m_name[] тағйирёбандаҳои сохторӣ буда, аз 
 навъи record муаррифӣ гардидаанд. 
 Сохтори додаҳо ва ишорагарҳо 
 Ба монанди тағйирёбандаҳои дигар барои дастрас шудан ба як сохтор аз
 оператори амперсанд «&» истифода бурда мешавад. Масалан, бигзор 
 тағйирёбандаи variable аз навъи сохтор бошад, ифодаи &variable суроғаи 
 ибтидоии онро нишон медиҳад. Тағйирёбандаҳои ишорагарро метавонем ба 
 намуди зерин муаррифӣ кунем: 
 type*ptvariable 
 Дар ин ҷо type навъи додае аз таркиби сохтор буда, ptvariable 
 муайянкунандаи номи ишорагар мебошад. Мисол: 
 typedef struct{ 
 int st_no; 
 char l_name[]; 
 char f_name[]; 
 char m_name[]; 
 float balance; 
 } record; 
 record cust,*ptcust; 
 Дар ин ҷо cust тағйирёбандае аз навъи record буда, ptcust бошад, 
 тағйирёбандаи ишорагар аст, ки дар худ суроғаи сохторро нигоҳ медорад. 
 ptcust=&cust; 
 Ба ғайр аз ин, тағйирёбандаҳои навъи ишорагар метавонанд ба сурати 
 зерин муаррифӣ гарданд. 
 struct { 
 member; 
 member... 
 member n 
 } var,*ptvar; 
 Дар ин ҷо var тағйирёбандаи навъи сохтор буда, *ptvar бошад, ишорагаре
 ба сохтор мебошад. 
 Барои дастрасшавӣ ба аъзои сохтор аз оператори «->«истифода бурда 
 мешавад. Барои дастрасшавӣ ба элементи як сохторе, ки худаш аъзои сохтор 
 аст, оператори мазкур ба оператори дот якҷоя истифода бурда мешавад. 
 ptvar->member.submember; 
 Агар элементи сохтор массив бошад, барои дастрас шудан ба 
 элементҳои массив номи массив ва зернависи он истифода бурда мешавад, 
 яъне 
 ptvar->member[expression]; 
 Мисол: 
 typedef struct{ 
 int st_no; 
 char l_name[]; 
 char f_name[]; 
 char m_name[]; 
 float balance; 
 } student, *ps=& student; 
 Тавре ки дар ин ҷо дида мешавад, ба тағйирёбандаи ишорагари ps 
 суроғаи аввалаи тағйирёбандаи student, ки аз навъи сохтор аст, ҳамчун аъзои
 аввала нисбат дода шудааст, яъне тағйирёбандаи ps барои тағйирёбандаи 
 student ишорагар мебошад. Барои дастрасшавӣ ба рақами тартибии ягон 
 донишҷӯ се роҳ мавҷуд аст: 
 ) student.st_no; 
 ) ps->st_no; 
 ) (*ps).st_no; 
 Дар ифодаи охирон навиштани қавс ҳатмист, зеро оператори дот аз 
 оператори «*» пурқудраттар аст. Дар сурати нагузоштани қавс шояд 
 компилятор хатогӣ диҳад ва барнома кор накунад. Ба ҳамин монанд ба 
 аъзоҳои дигар дастрас шудан мумкин аст. Ҳамин тавр, ба номи донишҷӯйи n- 
 ум дастрас шудан аз ифодаҳои зерин истифода кардан мумкин аст. 
 student.f_name[n] ps->f_name[], (*ps).f_name[] 
 *(student.f_name+)ps->(name+) *((*ps).name+) 
 Ишорагарҳо ба сифати элементи сохтор 
 Як тағйирёбандаи ишорагар метавонад, элементи як сохтор бошад. 
 Масалан, метавонем насаб, ном ва номи падари як нафар донишҷӯро ба 
 сурати сохтор ба намуди зерин эълон кунем. 
 struct names{ 
 char *l_name; 
 char *f_name; 
 char *m_name; 
 } 
 Дар ин ҷо l_name, f_name ва m_name се тағйирёбандаи ишорагари рамзӣ 
 ҳастанд, ки мувофиқан насаб, ном ва номи падар як донишҷӯро нишон 
 медиҳанд. 
 Ҳамин тариқ аъзои як сохтор метавонад як ишорагар ё суроғаи сохтори 
 дигарро дар худ нигоҳ дошта бошад ва ё суроғаи сохтореро аз навъи худаш 
 ногаҳдорӣ кунад. Дар ҳолати умумӣ ин сохтор намуди зеринро дорад. 
 struct rec{ 
 member 
 member.... 
 struct rec & f_name; 
 }; 
 Дар ин ҷо f_name тағйирёбандае аз навъи ишорагар мебошад, ки 
 тағйирёбандаи дигареро аз навъи сохтор дар худ бо форми rec дар он қарор 
 дод. Яке аз корбурдҳои равиши мазкур барои сохтани сохторҳое бо номи 
 linked list-иттифоқи рӯйхатҳо корбурди зиёд доранд. 
 Иттиҳодҳо (Unions) 
 Иттиҳод (union) ҷое аз ҳофиза аст, ки дар он якчанд тағйирёбанда нигоҳ
 дошта мешавад. Навъи тағйирёбандаҳо метавонанд якхела ё гуногун бошанд. 
 Дарвоқеъ, иттиҳод тағйирёбандаест, ки имконияти захира кардани 
 тағйирёбандаҳои гуногунро дар ҷойи муштараки ҳофиза фароҳам меорад. 
 Наҳви муаррификунии иттиҳодҳо монанди сохторҳо мебошад, вале 
 бартарияташ дар он аст, ки сохторҳо барои ҳар элементаш як ҷойи ҳофизаро 
 банд мекунад. Иттиҳодҳо бошанд, барои ҳамаи аъзоҳояш танҳо як ҷойе аз 
 ҳофизаро банд мекунад. Ин навъ сохтори додаҳо дар истифодабариҳо хеле 
 муфид аст, зеро дар он элементҳои чандгонаи навъҳояшон гуногун ҳастанд 
 ва дар ҳар замон метавонем, ки ба ҳар як аъзо қимате бахшем. 
 Тарзи эълон намудани иттиҳодҳо шакли зеринро дорад: 
 union номи_иттиҳод 
 { 
 Навъи_тағйирёбандаи, номи тағйирёбандаи; 
 Навъи_тағйирёбандаи, номи тағйирёбандаи;.... 
 Навъи_тағйирёбандаи N номи тағйирёбандаи N; 
 } Рӯйхати экземпиляторҳо; 
 Дар ин ҷо union калимаи калидӣ буда, барои муаррификунии иттиҳодҳо 
 истифода бурда мешавад. Мисол: 
 union union_type{ 
 int al; 
 char ch; 
 float f; 
 }; 
 Ин эълонкунӣ монанди сохторҳо сабаби муаррифӣ намудани 
 тағйирёбанда намегардад, балки таърифи як намуди дода аст. Барои 
 муаррификунии тағйирёбандаҳои навъи union пеш аз номи тағйирёбанда 
 калимаи калидии union навишта мешавад. Наҳви муаррификунии 
 тағйирёбандаҳои навъи union монанди тағйирёбандаҳои навъи struct мебошад.
 Мисол: 
 Ё 
 union union_type{ u n i o n u n i o n _type{ 
 int a; int a; 
 char ch; char ch; 
 float f; float f; 
 } b; }; 
 union union_type b; 
 Дар ин ҷо тағйирёбандаи a, ch ва f яке аз навъи int, дувум аз навъи char
 ва саввумӣ аз навъи float мебошад. Ҳарчанд ки ин тағйирёбандаҳои дар хотира
 миқдори гуногунро банд мекунанд, вале суроғаи онҳо дар якҷост. 
 Тавре ки аз расм дида мешавад, барои се тағйирёбандаи гуногунавъ як 
 ҷойи хотира банд карда шудааст. Вақте ки union муаррифӣ шуд, компилятор 
 ба таври автоматӣ як тағйирёбандае, ки бузургтарин элементи union-ро дар 
 худ нигоҳ медорад, эҷод мекунад. Ба таври умумӣ, наҳви муаррифӣ намудани 
 тағйирёбандаҳои навъи сохтор намуди зеринро дорад. 
 storage_сlass union union_type var,var,..., varN; 
 Дар ин ҷо storage_сlass як доимии ихтиёрӣ мебошад, ки агар онро 
 истифода набарем, ҳофизаи мавриди назар аз навъи автоматӣ мешавад. 
 Тавре ки баён кардем, тағйирёбандаҳои навъи union пас аз 
 муаррификунии unio, яъне пас аз қавси системавӣ навишта мешаванд ва ё дар
 алоҳидагӣ муаррифӣ карда мешаванд. Мисол: 
 union student { 
 char name[]; 
 int st_no; 
 } a,b; 
 Дар ин ҷо ду тағйирёбанда аз навъи union-е, ки ба номи student муаррифӣ
 гардидаанд, ҳар замон метавонанд муаррифгари сатри -рамза ё адади бутун
 бошанд. Дар ин ҷо аён аст, ки тағйирёбандаи name нисбат ба тағйирёбандаи 
 st_no ба ҳофизаи зиёд ниёз дорад. Дар натиҷа компилятор барои ҳар як 
 тағиёрёбанда ба миқдори тағйирёбандаи бузургтар минтақаи ҳофизаро ҷудо 
 мекунад. Мисол: 
 #include <iostream> 
 using namespace std; 
 union adad{ 
 unsigned short int a; 
 int b; 
 } x; 
 void print ( adad z){ 
 cout<<"a="<<z.a <<endl; 
 cout<<"b="<<z.b <<endl<<endl; 
 } 
 int main(){ 
 adad y; 
 x.b =; 
 print(x); 
 y.b =.; 
 print(y); 
 return; 
 } 
 Дар ин барнома тавре дида мешавад, иттиҳоде ба номи adad муаррифӣ 
 гардидааст, ки дорои ду аъзо мебошад, ки якеаш, аз навъи unsigned short int
 буда, дигараш, аз навъи int мебошад. Баъдан функсияе бо номи print муаррифӣ
 шудааст, ки аргументи он аз навъи иттиҳод мебошад, сипас, дар функсияи 
 аслӣ барои тағйирёбандаи навъи int, яъне b қимате бахшида шудааст. 
 Ҳангоми хориҷкунӣ, яъне даъвати функсияи print, дар саҳифаи тасвир қимати
 тағйирёбандаи unsigned short int низ ба он баробар ба чоп дода мешавад. 
 Як union метавонад узви як сохтор бошад ва инчунин як сохтор низ 
 метавонад узви union бошад. Мисол: 
 #include <iostream> 
 #include <stdio.h> 
 using namespace std; 
 int main(){ 
 union student { 
 int st_no; 
 char jender; 
 }; 
 struct name{ 
 char l_name[]; 
 char f_name[]; 
 char m_name[]; 
 union student kurs; 
 }; 
 static name don[]={ 
 {"Saidov","Umar","Kurbonovich",}, 
 {"Aliev","Vali","Saidovich",'D'} 
 }; 
 cout<<"firstName="<<don[].l_name<<endl; 
 cout<<"name="<<don[].f_name <<endl; 
 cout<<"LastName="<<don[].m_name <<endl; 
 cout<<"kurs="<<don[].kurs.st_no<<endl; 
 cout<<don[].kurs.jender<<endl<<endl; 
 cout<<"firstName="<<don[].l_name<<endl; 
 cout<<"name="<<don[].f_name <<endl; 
 cout<<"LastName="<<don[].m_name <<endl; 
 cout<<"kurs="<<don[].kurs.st_no<<endl; 
 cout<<don[].kurs.jender<<endl; 
 return; 
 } 
 Дар ин мисол узви аввалаи union адади бутун буда, узви дигараш 
 тағйирёбандаи рамзӣ мебошад. Унсурҳои сохтор бошанд, мувофиқан 
 фамилия, ном ва насаби донишҷӯро ифода мекунанд. Ба ғайр аз ин, унсури 
 дигари сохтор union мебошад. Дар функсияи аслӣ ба ҳар як унсури сохтор 
 миқдоре бахшида мешавад. Аз ин ҷо мулоҳиза карда мешавад, ки барои 
 дастрас шудан ба қимати унсури сохтор, ки аз навъи union буд, бо ёрии 
 операторҳои зерин амалӣ мешавад. 
 don[].kurs.st_no; 
 don[].kurs.jender; 
 Дар ин ҷо аввал ба узви унсури навъи сохтор адади бутуни ба баробар
 бахшида шудааст. Тавре ки гуфтем, дар union ҳофиза муштарак аст, бинобар ин,
 қимати don[].kurs.st_no= ва қимати don[].kurs.jender=А ба чоп дода мешавад,
 яъне ASCII-коди A= мебошад, баъдан ба узви union сим- воли ‘D‘ бахшида 
 шудааст. Дар ин ҷо низ қимати don[].kurs.st_no= ва қимати don[].kurs.jender
 =D баробар ба чоп дода мешавад. Натиҷаи барнома ба сурати зерин аст: 
 firstName=Saidov 
 name=Umar 
 LastName= Kurbonovich 
 A 
 firstName=Aliev 
 name=Vali 
 LastName= saidovich 
 D 
 Додаҳои навъишуморишӣ 
 Дар зери мафҳуми додаҳои навъи шуморишӣ дастаи додаҳои бутуни 
 доимӣ фаҳмида мешаванд, ки ҳар яке аз онҳо барои муайянкунии қимати 
 тағйирёбандаҳои навъи шуморишӣ истифода бурда мешаванд. Додаҳои навъи 
 мазкур монанди додаҳои навъи сохтор ва ё union мебошанд. 
 Пеш аз додаҳои навъи шуморишӣ ҳангоми муаррификунӣ калимаи 
 калидии enum навишта мешавад. Наҳви умумии муаррификунии додаҳои 
 навъи мазкур намуди зеринродорад: 
 enum constnum { const, const,...,constN}; 
 Дар ин ҷо enum калимаи калидӣ буда, consenum номи ихтиёрӣ мебошад, 
 ки барои додаҳои навъи шуморишӣ истифода шудааст. Пас аз муаррификунии 
 додаҳои навъи шуморишӣ метавонем дар дигар ҷойи барнома додаҳои 
 мувофиқ ба ин навъро ба сурати зерин муаррифи кард: 
 constenum var,var,...,varN; 
 Дар ин ҷо onsenum номи навъи шуморишӣ буда, var,var,...,varN 
 тағйирёбандаҳои навъи шуморишӣ мебошанд. Ба ғайр аз ин, метавон додаҳои 
 навъи шумориширо ба сурати зерин муаррифӣ кард: 
 enum constenum { const, const,...,constN}, var,var,...,varN;
 Ҳар як унсури додаҳои навъи шуморишӣ дар ҳолати умумӣ дорои 
 қимати бутун вобаста аз мавқеашон мебошанд. Дар вақти муаррификунӣ 
 метавонем ба додаҳои навъи мазкур қимати аввала бахшем. Амали мазкур пас 
 аз рамзи навъи шуморишӣ аломати «=« гузошта, иҷро карда мешавад. Мисол: 
 #include <iostream> 
 #include <stdio.h> 
 using namespace std; 
 int main() { 
 enum color{red,blue, black,green,magenta,white,yel- 
 low,cyan}; 
 cout<<red<<"\t"<<blue<<"\t"<<black<<"\t"<<green<<"\t"< 
 <magenta<<"\t"<<white<<"\t"<<yellow<<"\t"<<cyan<<endl; 
 return; 
 } 
 Қимати ин рамзҳо ба сурати зерин аст: 
 Яъне дар ин ҷо: red=; blue=; black=; grean=; magenta=; white=;
 yellow= ва cyan= мебошад. 
 Агар мо бо ягонтои ин додаҳо қимате ихтисос диҳем, он гоҳ аз он сар 
 карда, рақамгузорӣ карда мешаванд. 
 #include <iostream> 
 #include <stdio.h> 
 using namespace std; 
 int main(){ 
 enum color{red,blue, black=,green,ma- 
 genta,white=,yellow,cyan}; 
 cout<<red<<"\t"<<blue<<"\t"<<black<<"\t"<<green<<"\t"< 
 <magenta<<"\t"<<white<<"\t"<<yellow<<"\t"<<cyan<<endl; 
 return; 
 } 
 Натиҷаи ин барнома ба сурати зерин хоҳад буд. 
 Миқдори ин рамзҳо ба сурати зерин аст: red =, blue=, black=, 
 grean=, magenta=, white=, yellow= ва cyan= мебошад. 
 Саволҳо барои мустаҳкамкунӣ 
 аввала бахшид? 
 мешавад? 
 Мисолҳои барои кори мустақилона 
 харида, дар мағозаи назди хонааш аз рӯйи шарти зерин мефурӯшад: 
 Агар нархи маҳсулот аз сомонӣ кам бошад, дар болояш % и 
 нархашро илова мекунад ва агар нархи маҳсулот аз сомонӣ то сомонӣ
 бошад, дар болояш %-и нархашро илова мекунад ва агар маҳсулот аз 
 сомонӣ зиёд бошад, дар болояш % нархашро илова мекунад. Талаб карда 
 мешавад, ки барномае нависед, ки нархҳои илованамуда ва фоидаи ба даст 
 меовардаи Алиро ба намуди ҳисобот (ҷадвал) пешниҳод кунад. 
 № Номи Нархи Фоизи Нархи Фоида 
 маҳсулот харид иловашуда фурӯш 
 супорид. Агар ҳамаи баҳоҳои гирифтааш ва бошанд, аз тарафи ширкати 
 Tcell соҳиби дақиқаи бепул дар телефонаш мегардад. Гурӯҳе иборат аз 
 нафар донишҷӯ имтиҳон супориданд. Барномае нависед ва муайян кунад, ки 
 чанд нафар донишҷӯ ба мукофот сазовор мегарданд. Ному насаби онҳоро бо 
 баҳоҳои фанҳояшон ба намуди ҷадвал бароред. 
 пасандоз, шарт ё фоизи зиёдшавӣ. Барномае нависед, ки амалиёти зеринро 
 муайян кунад ва ба саҳифаи тасвир барорад: 
 ✓ Андози солонаи муштариён дар охири сол; 
 ✓ Муштариёне, ки пасандози баробар доранд; 
 падар ва зодрӯз дода шудаанд. Барномае нависед, то муайян кунад, ки оё дар
 гурӯҳ ягон нафар донишҷӯ дар рӯзи додашуда зодрӯз дорад ё не. Агар дошта 
 бошад, маълумоти онро бароред ва дар ҳолати акс пайғоми муносибе чоп 
 кунад. 
 барориш ва кишвари истеҳсолшуда дода шудаанд. Барномае нависед, ки тамға 
 аз ҳама гаронтаринро бо маълумотҳояш барорад. 
 нависед, ки бо дохил кардани таърихи рӯз санаи баъдинаро барорад. (рӯз, моҳ
 ва сол алоҳида алоҳида дода мешаванд.) 
 шудааст: тамға, рақам, соли барориш ва миқдори роҳи тайнамудаи мошин ва 
 ному насаби ронанда. Барномае нависед, ки автомобилҳое, ки роҳи баробар 
 тай кардаанд, мураттаб карда, барорад. 
 даъватшаванда ба сурати, ному насаб, дарозии қад ва вазн дода шудааст. 
 Мувофиқи фармони вазири мудофиа ҷавононеро, вазнашон аз кг зиёд, 
 қадашон аз см баланд, синнусолашон дар фосилаи --сола, ба хизмат 
 даъват карда мешаванд. 
 Барномае навшта рӯйхати даъватшавандагони ба талаботи хизмати 
 ҳарбӣ ҷавобро мураттаб намоед, ки ба сурати ҳисобот барояд. 
 иборат мебошад: вақти ҳаракат (соати ҳаракат) ва масири ҳаракат. 
 Барномае нависед, ки: 
 ✓ Бо дохил кардани масири ҳаракат соати ҳаракатро муайян кунад; 
 ✓ Бо дохил кардани соат масири ҳаракатро муайян кунад. 
 БАРНОМАНАВИСИИ БА ОБЪЕКТҲО НИГАРОНИДАШУДА 
 Дар барномаҳое, ки то ҳоло навиштем ва истифода кардем, аз равиши 
 барноманависии сохтаёфта, истифода карда будем. Ҳоло бошад, равиши 
 наверо бо номи барноманависи ба объектҳо нигаронидашуда (БОН) ё 
 барноманависии шайъгароро дида мебароем. Дар адабиётҳои англисӣ БОН-ро 
 object oriented programming (OOP) мегӯянд. БОН як равиши нави 
 барноманависӣ аст, ки дар он метавон қисмати барномаеро алоҳида навишта, 
 дар барномаҳои гуногун мавриди истифода қарор дод. Ҳадафи асосии БОН ин 
 аст, ки барномаҳоро аз қисматҳо ташкил кунад. Аз ин ҷо, дар ин равиш ҷустуҷӯ
 ва ислоҳи хатогиҳо осон шуда, суръати иҷроиши барнома тез мегардад. 
 Дар олами барноманависӣ забонҳои зиёди барноманависие мавҷуданд, 
 ки ин равишро дастгирӣ мекунанд, ба монанди: С++, Object Pascal (Turbo 
 Pascal), CLOS, Java,Ada, Smalltak, Cool ва ғайра. 
 Дар намуди барномасозии БОН структура ё блоке, ки барнома аз он 
 ташкил шудааст, объектҳо мебошанд. Дар забонҳое, ки ин равишро дастгирӣ 
 мекунанд, барномасоз метавонад, объектҳои зиёдеро эълон намуда, мавриди 
 истифода қарор диҳад. 
 Зарурати пайдоиши БОН солҳои -уми асри гузашта ҳангоми 
 тартибдиҳии забони Фортран ба миён омад. Аз ҳамин вақт сар карда, 
 имконияти навиштани барномаҳои тулонӣ то ҳазорҳо сатр пайдо шуд, вале 
 ҳангоми навиштани чунин барномаҳои дароз хатогиҳо ҳам зиёд пайдо шуданд, 
 ки ислоҳ, идоракунӣ ва иҷрокунӣ (компайлкунӣ)-и онҳо низ хеле душвор 
 гашт. Аз ин ҷо зарурате пайдо шуд, ки шеваи барноманависие эъҷод шавад, ки
 барномаҳои бузург ба қисмҳо ҷудо карда шуда, идоракунӣ ва компайли онҳо 
 осон гардад, яъне зарурати барноманависии структуравӣ пайдо шуд. Дар 
 солҳои -ум забони Паскал пайдо шуд, ки он аввалин забони структурӣ 
 (сохторӣ) ба ҳисоб мерафт. Забонҳои структурӣ имконият медоданд, ки 
 барнома ба қисматҳо тақсим карда шуда, идоракунӣ, ислоҳи хатогиҳо ва 
 иҷроиши онҳо осон гардад. Аз ин ҷо, шеваи нави барноманависӣ, ки БОН 
 мебошад, пайдо шуд. Манбаи асосии БОН забони Симуле буда, аввалин ба 
 вуҷудоии он ба таври пурраSmaltak- ба ҳисоб меравад. БОН дар нимаи 
 дувуми соли -ум ба таври пурра пайдо шудааст. Ин равиш дар забонҳои 
 С++, objective C (дигар тавсеа (расширение) –и С), Object Pascal, Turbo Pascal,
 CLOS, Eiffel, Ada ва Java ин шеваи барноманависӣ амал мекунад. 
 Барои ба равиши зикршуда шинос шудан се хосияти асосиеро, ки асоси 
 кори БОН мебошанд, дида мебароем: 
 ) Хосияти меросӣ ё варосат (Inheritance)-ин равандест, ки дар он як 
 объект хосиятҳои хоси объектҳои дигарро гирифта, дар худ илова 
 намуда, истифода мебарад. Хусусияти мазкур якчанд маротиба 
 истифодабарии объект ( хосият ё методи як class дар дигар class-ҳо)-ро
 имконият медиҳад. Ба таври дигар гӯем, ҳар объект аз дохили як class
 буда, class метавонад класси дигар хосият ва ё методи онро ворис шавад.
 Ин равиш то андозае коди барномаро кӯтоҳ мекунад. Шумо, албатта, аз 
 мафҳуми меросбарӣ дар дунёи воқеи шинос ҳастед. Дар олами 
 барноманависӣ низ мафҳуми мазкур ба он монанд ба кор бурда мешавад. 
 ) Чандшаклӣ (Polymorphizm)- ин хосияте, ки истифодабарии ҳамон як 
 номро барои якчанд масъалаҳои техникӣ имконият медихад. Хосияти 
 мазкур имконият медиҳад, ки як объект дар ҷойҳои гуногун рафторҳои 
 гуногунро иҷро кунад. Масалан, барои пурратар фаҳмо шудан фармони 
 мошинро дида мебароем. Фармони мошин барои дилҳоҳ намуди 
 мошинҳо новобаста аз он ки бо ёрии газ, бензин ва ё ин ки нури офтоб
 ҳаракат мекунанд, якхела аст. Вақте ки як нафар фармони як мошинро 
 ёд гирифт, метавонад ҳамон фармони мошинҳои дигарро низ иҷро 
 кунад. Ҳарчанд ки ранг ва намуди мошинҳо гуногун бошад. 
 ) Махфисозӣ (Incapsulation)-ин механизмест, ки хосият ва рафтори 
 объектҳоро пинҳон намуда, аз таъсири истифодаи нодуруст ҳифз 
 мекунад. Амали мазкурро бастабандӣ низ мегӯянд ва он имконият 
 медиҳад, ки объектҳо бе донистани амали объекти дигар бо он кор 
 кунад. Масалан, тормози мошинро лозим нест, ки аз чӣ гуна кор 
 кардани суръати мошин маълумот дошта бошад ва ҳангоми кор кардан 
 бояд онро аз кори худ огоҳ созад, то он низ аксуламали муносиберо 
 нишон диҳад. БОН низ кӯшиш мекунад, ки ба ин ҳолат наздик шавад. 
 Ба сурате, ки объект аз чӣ гуна амалкарди якдигар бохабар набошанд 
 ва танҳо бо ҳам иртибот намуда, мубодилаи иттилоот намоянд. 
 Барои пурратар шинос шудан биёед, мафҳуми Class ва объектро дида 
 мебароем. 
 БОБИ. КЛАССҲО, ОБЪЕКТҲО ВА МЕТОДҲО 
 Муқаддима 
 Classҳо барои сохтани модели объектҳои дунёи воқеӣ истифода бурда 
 мешаванд. Ҳар класс дорои сифат ва рафтор мебошад. Сифат-ро ба сурати 
 тағйирёбандаҳо (майдонҳо) ва рафторро бошад, ба сурати функсия узв (метод)
 муаррифӣ мекунад. Ба таври дигар гӯем, Class қолабе мебошад, ки ба 
 объектҳои гуногуни дорои хосияти якхела ба кор бурда мешавад. Ҳангоми 
 навиштани барнома ба ин равиш на танҳо як объект муаррифӣ карда мешавад, 
 балки дастаи объектҳои дорои сифати якхела муаррифӣ карда мешаванд. Ба 
 сифати мисол, бигзор Шумо бо номи дарахт як класс дошта бошед, ки он 
 хосияти тамоми дарахтонро муаррифӣ кунад: 
 Барг ва реша доранд; 
 Рушду нумӯъ мекунанд; 
 Баландӣ қад доранд; 
 Оксиген хориҷ мекунанд. 
 Ин класс барои ба мафҳуми Class-дарахт шинос шудан истифода бурда 
 мешавад. Барои объектеро дар барнома доштан ва аз он кор кардан бояд, ки 
 он намунаи дақиқи дарахтро дошта бошад. Classҳо барои эҷод намудани 
 объектҳо истифода бурда мешаванд. Класси дарахт барои эҷоди объектҳои 
 гуногун аз дарахт ба кор бурда ме-шавад, ки ҳар дарахт метавонад, дорои 
 хосиятҳои хос бошад. 
 Кӯтоҳ ё дароз бошад; 
 Паҳнбарг ё сӯзанбарг бошад; 
 Мевадор ё бемева бошад. 
 Ҳарчанд ки ин объектҳо гуногунунанд, вале дорои сифатҳои якхела 
 мебошанд. 
 Дигар хел карда гӯем, Class маҷмӯи навъи додаҳо мебошад, ки 
 элементҳои онро функсияҳо ва тағйирёбандаҳо (майдонҳо)-ро ташкил 
 медиҳанд. Барои объект метавон маҷмӯи амалҳои гуногунро ба иҷро расонид. 
 Хосияти объектҳо бо ёрии тағйирёбанда (майдон)-и classҳо ва амали объектҳо
 бо ёрии функсияҳо навишта мешавад, ки он функсияҳо метод ном доранд. 
 Class тавре ки гуфтем, аз майдон, ки аъзои class ном дорад ва функсия-методи
 class ташкил ёфтааст. Барои дастрасшавӣ ба хосият ва методи class бояд 
 нусхаи class сохта шавад, ки он низ ҳамчун объект номида мешавад. Ба як class
 дар як вақт метавонад якчанд объектҳо, ки аз ҳамдигар бо номҳояшон фарқ 
 мекунанд, таааллуқ дошта бошанд. 
 Муаррификунии class-ҳо 
 Class-ҳо аслан бо ёрии калимаи калидии class эълон карда мешаванд. Пас
 аз ин калимаи калидӣ, номи class меояд. Майдонҳо ва методҳои class бошанд,
 дар дохили блок, дар қавси фигуравӣ тасвир карда мешаванд. Объектҳои class
 метавонанд бо се роҳ ба майдон ва методҳои class дастрас шаванд, яъне бо 
 ибораи дигар, методҳо метавонанд кушода, пӯшида ва ҳимоякардашуда 
 бошанд: 
 ) Кушода –пеш аз эълон намудани ин навъ объектҳо калимаи калидии Public 
 навишта шуда, тавассути оператори dot (.) дастрас карда мешаванд. 
 ) Пӯшида-пеш аз эълон намудани ин навъ майдонҳо ё аъзоҳо калимаи 
 калидии Private навишта мешавад, ин навъ аъзоҳо танҳо ба воситаи методҳои
 кушода дастрас карда мешаванд. 
 ) Ҳимоякардашуда-дар ин бора дар мавзӯи хосияти меросӣ маълумоти 
 пурра меорем. 
 Тарзи муаррификунии як class ба сурати зерин аст: 
 classноми_Class{ 
 Додаҳо ва функсияҳои пушида 
 Спесификатори дастрасӣ: 
 Додаҳо ва функсияҳо 
 Спесификатори дастрасӣ: 
 Додаҳо ва функсияҳо 
 //.... 
 Спесификатори дастрасӣ: 
 Додаҳо ва функсияҳо 
 } Рӯйхати объектҳо; 
 Барои бо class-ҳо шинос шудан як мисолро дида мебароем. 
 Мисоли. Тарзи муаррифӣ намудани класс. 
 #include<iostream> 
 usingnamespace std; 
 classMyFirstClass { 
 public: 
 int a, b; 
 }; 
 int main() { 
 MyFirstClass Myobj; 
 Myobj.a =; 
 Myobj.b =; 
 system("pause"); 
 return; 
 } 
 Дар ин ҷо MyFirstClass номи class буда, int a ва int b майдонҳои кушодаи
 class мебошанд.Дар функсияи асосӣ бо номи Myobjобъекте аз навъи 
 MyFirstClass муаррифӣ гардидааст. Пас аз ин тавассути оператори бахшиш ба
 майдонҳои class қимат бахшида шудааст. Чи хеле ки дида мешавад, барои 
 дастрасшавӣ ба майдонҳои кушодаи class аз оператори dot (нуқта) истифода 
 бурда шудааст. 
 Илова бар ин, метавон ба майдонҳои класс аз дастгоҳи вуруди қимат 
 бахшид ва ё қимати ҷории майдонҳоро ба чоп баровард. Ин амал ба монанди 
 тағйирёбандаҳои муқаррарӣ иҷро карда мешавад. Ба мисоли зерин диққат 
 диҳед: 
 #include<iostream> 
 usingnamespace std; 
 classMyFirstClass { 
 public: 
 int a, b; 
 }; 
 int main() { 
 MyFirstClass Myobj; 
 cin >> Myobj.a >> Myobj.b; 
 cout << Myobj.a <<" "<< Myobj.b << endl; 
 system("pause"); 
 return; 
 } 
 Ҳангоми муаррифӣ намудани class метавон яку якбора барои он объект 
 сохт. Объектҳои лозимӣ пас аз қавси системавии класс ва пеш аз аломати “;”
 муаррифӣ карда мешаванд. Ба мисоли зерин диққат диҳед: 
 #include<iostream> 
 usingnamespace std; 
 classMyFirstClass { 
 public: 
 int a, b; 
 }Myobj; 
 int main() { 
 cin >> Myobj.a >> Myobj.b; 
 cout << Myobj.a <<" "<< Myobj.b << endl; 
 system("pause"); 
 return; 
 } 
 Методҳо 
 Метод ин функсияе мебошад, ки дар дохили class муаррифӣ гардида, 
 метавонад амали муносиберо анҷом диҳад. Тарзи навишти метод айнан ба 
 навишти функсия монанд буда, фарқияташ дар он аст, ки барои даъвати метод
 нусхаи класс (объект) сохта мешавад. Барои даъвати функсия бошад, амали 
 алоҳидае вуҷуд надорад, яъне метод қисми класс буда, барои даъвати он бояд
 объект сохта шавад. Дар забони C++ методҳоро асосан функсия-аъзо 
 меноманд. Натиҷаи бадастомадаи метод аз намуди даъвати объект вобастагӣ 
 дорад. Тарзи умумии муаррифсозии метод намуди зеринро дорад: 
 Тип, номи_метод(Рӯйхати аргументҳо) 
 { 
 Тани метод 
 } 
 Барои пурратар шинос шудан ба ин матлаб мисоли дигареро дида 
 мебароем. 
 Мисол. Дар класси MyFirstClass методе илова кунед, ки маҷмӯи 
 майдонҳои классро ҳисоб кунад. 
 #include<iostream> 
 usingnamespace std; 
 classMyFirstClass { 
 public: 
 int a, b; 
 int Sum() { 
 return a + b; 
 } 
 }Myobj; 
 int main() { 
 cin >> Myobj.a >> Myobj.b; 
 cout << Myobj.Sum() << endl; 
 system("pause"); 
 return; 
 } 
 Дар ин ҷо бо номи Sum() методе муаррифӣ шудааст, ки суммаи 
 майдонҳои классро бармегардонад. Дар функсияи асосӣ, дар дастгоҳи вурудӣ 
 тавассути объекти Myobj методи мазкур даъват карда шудааст. 
 Пешнамунасозии методҳо 
 Монанди функсияҳо бояд то амали даъват, метод низ муаррифӣ карда 
 шавад. Ин чунин муаррифиро пешнамунасозии (прототип)-и метод меноманд. 
 Дар аксар барномаҳо дар дохили класс метод пешнамуна карда шуда, пас аз 
 class пурра шарҳ дода мешавад. Ҳангоми шарҳи методҳои class, пеш аз ҳама,
 бояд муайян карда шавад, ки метод ба кадом class тааллуқ дорад ва барои 
 дастрасшавӣ ба метод аз оператори иҷозати ҳудудӣ фаъолият (::) истифода 
 бурда мешавад. Барои пурратар шинос шудан ба ин матлаб ба барномаи зерин 
 диққат диҳед: 
 #include<iostream> 
 usingnamespace std; 
 classMyFirstClass { 
 public: 
 int a, b; 
 int Sum(); 
 }Myobj; 
 intMyFirstClass::Sum() { 
 return a + b; 
 } 
 int main() { 
 cin >> Myobj.a >> Myobj.b; 
 cout << Myobj.Sum() << endl; 
 system("pause"); 
 return; 
 } 
 Ин мисол низ чун мисоли қаблӣ буда, фарқияташ дар он аст, ки дар ин 
 ҷо метод дар дохили класс пешнамуна карда ва пас аз функсияи асосӣ пурра 
 навишта шудааст. Методҳои дар дохили класс пешнамунашуда тавассути 
 оператори иҷозати ҳудуди фаъолият ва номӣ дастрас карда мешаванд. 
 Қимати аввала бахшидан ба майдонҳои класс тавассути 
 методҳо 
 Дар мисолҳое, ки то ҳол навиштем, барои ба майдонҳои класс 
 бахшидани қимати аввала аз дастгоҳи вурудӣ ва ё аз амалгари нуқта истифода
 кардем. Илова бар ин метавонем барои ба майдонҳои класс бахшидани қимати 
 аввала аз функсияҳо истифода барем. Барои иҷрои ин амал дар дохили класс 
 функсияе муаррифӣ карда мешавад. Ба мисоли зерин диққат диҳед: 
 #include<iostream> 
 usingnamespace std; 
 classMyFirstClass { 
 public: 
 int a, b; 
 void MyMethod(intx, inty) { 
 a = x; 
 b = y; 
 } 
 }; 
 int main() { 
 MyFirstClass Myobj; 
 Myobj.MyMethod(, ); 
 cout <<"Object a="<< Myobj.a <<" Object b="<< Myobj.b 
 << endl; 
 system("pause"); 
 return; 
 } 
 Дар ин ҷо дар дохили класс бо номи MyMethod методе муаррифӣ 
 гардидааст, ки дорои ду параметр мебошад. Қимати ин параметрҳо ҳамчун 
 қимати ибтидоӣ ба майдонҳои класс бахшида мешаванд. Дар функсияи асосӣ 
 ба сурати Myobj объекте сохта шудаааст. Сипас, тавассути он ба сурати 
 Myobj.MyMethod(,) методи сохташуда даъват гардидааст, ки дар ин 
 даъват ба параметри a қимати ва ба майдони b қимати -ро мебахшад. 
 Калимаи калидӣ ё ишорагари this 
 Дар ҳар даъвати метод ба таври худкора бо истифода аз калимаи калидии
 this ба объекте, ки ин методро даъват кардааст, ишорагар равон мекунад. 
 Тавре ки медонем, методҳо метавонанд ба майдонҳои пӯшидаи (private)-
 и классе, ки дар дохили он муаррифӣ гардидаанд, дастрасӣ дошта бошанд. 
 Масалан, бигзор классе ба сурати зерин муаррифӣ гардида бошад: 
 classMyFirstClass { 
 int a; 
 void MyFunc() 
 {... 
 } 
 }; 
 Дар дохили функсияи MyFunc () метавонем ба майдони класс қимат 
 бахшид, мисол a=; 
 Ин навишт тарзи ихтисори навишти this.a= мебошад. 
 Барои ба моҳияти ишоргари this шинос шудан мисолеро дида мебароем. 
 #include<iostream> 
 usingnamespace std; 
 classMyFirstClass { 
 public: 
 int a, b; 
 void MyFunc(intx, inty) { 
 this->a = x; 
 this->b = y; } 
 int max() { 
 if ((this->a)>(this->b)) 
 returnthis->a; 
 else 
 returnthis->b; 
 } 
 }; 
 int main() { 
 MyFirstClass obj; 
 obj.MyFunc(, ); 
 cout <<"max = "<< obj.max()<<endl; 
 system("pause"); 
 return; 
 } 
 Тавре ки дида мешавад, классе бо номи MyFirstClass муаррифӣ 
 гардидааст, ки дорои ду майдони намуди бутун мебошад. Бо ёрии функсияи 
 (методи) MyFunc() ба майдонҳои класс қимати нисбат дода шудааст. 
 Функсияи max бошад, қимати калонтарини ин майдонҳоро бармегардонад. 
 Дар функсияи аслӣ объекте аз навъи класс муаррифӣ гардидааст, сипас, бо 
 ёрии объект методҳои навишташуда даъват карда мешаванд. 
 Конструктор ва деструктор 
 Классҳо дорои ду функсияи асосӣ-конструктор (constructor) ва 
 деструктор (destructor ) мебошанд. 
 Конструктор барои ба тағйирёбандаҳо бахшидани қимати аввала хизмат 
 мекунад ва деструктор бошад, ба итмом расидани кори методро муайян 
 мекунад: ба монанди озод намудани ҳофизаро аз намуди динамикӣ. Яъне 
 мақсади деструктор ифода намудани баитмомрасии метод мебошад. 
 Сохтан ва истифода намудани конструктор 
 Чӣ тавре ки қайд кардем, конструктор асосан барои ба майдонҳои класс
 бахшидани қимати аввала сохта мешавад, ки дорои хосиятҳои зерин мебошад: 
 намешавад. 
 Конструктор метавонад дорои аргумент ва ё бе аргумент бошад. 
 Дар мисолҳои қаблӣ, тавре ки мушоҳида кардем, ба таври дасти (ручной)
 ва ё тавассути метод ба майдонҳои класс қимат бахшида мешуд. Ин равиш 
 метавонад баъзан хатогиҳо ба бор оварад. Пас, барои ба хатогӣ рӯ ба рӯ нашу-
 дан аз конструктор истифода бурда мешавад. 
 Коструктор ҳангоми муаррифӣ намудани майдонҳо, ба онҳо қимати ав- 
 вала мебахшад. Номи конструктор, тавре ки гуфтем, бояд ба номи класс як- 
 хела бошад. Наҳви муаррификунии конструктор низ монанди як метод буда, 
 фарқияташ дар он аст, ки дар конструктор барои қимат баргардонидан навъ 
 нишон дода намешавад. Барои ба ин матлаб хубтар шинос шудан ба мисоли 
 зерин диққат диҳед: 
 #include<iostream> 
 usingnamespace std; 
 classMyFirstClass { 
 public: 
 int a, b; 
 //Конструктор 
 MyFirstClass() { 
 a =; 
 b =; 
 } 
 }; 
 int main() { 
 MyFirstClass Myobj; 
 cout <<"Object a="<< Myobj.a <<" Object b="<< Myobj.b 
 << endl; 
 system("pause"); 
 return; 
 } 
 Тавре ки аён аст, дар ин мисол конструкторе, ки номи он бо класс якхела
 аст, муаррифӣ гардидааст. Ин конструктор ҳамчун қимати ибтидоӣ ба 
 майдонҳои класс адади -ро мебахшад. Сипас, дар методи асосӣ 
 тағйирёбандаи Myobj аз навъи MyFirstClass муаррифӣ гардида, тавассути он 
 майдонҳои класс ба чоп бароварда шудаанд. 
 Конструктори параметрдор 
 Барои қимати аввала бахшидан ба майдонҳои класс конструктор 
 метавонад аргументҳои лозимиро низ равона кунад. Параметрҳои 
 конаструктор ба параметрҳои функсияи муқаррарӣ монанд мебошанд. 
 Мисол. Истифодаи параметр дар конструктор 
 #include<iostream> 
 usingnamespace std; 
 classMyFirstClass { 
 public: 
 int a, b; 
 //Конструкторбопараметр 
 MyFirstClass(intx, inty) { 
 this->a = x; 
 this->b = y; 
 } 
 void show() { 
 cout <<"a = "<< a << endl; 
 cout <<"b = "<< b << endl; 
 } 
 }; 
 int main() { 
 MyFirstClass obj(,); 
 obj.show(); 
 system("pause"); 
 return; 
 } 
 Дар конструктори MyFirstClass параметрҳои x ва y барои ба майдонҳои 
 класс бахшидани қимати аввала хизмат мекунанд. Дар функсияи асосӣ бо ёрии
 дастури зерин объект сохта шудааст: 
 MyFirstClass obj(,); 
 Тавассути ин дастур қиматҳои ва мувофиқан ба аргументҳои x ва y
 - и конструктор равон карда шудаанд. Пас аз иҷрои ин дастур ба майдони a 
 дорои қимати ва майдони b дорои қимати мегардад. 
 Илова бар ин бо ёрии дастури зерин низ метавон аргументҳоро равон 
 кард: 
 MyFirstClass obj = MyFirstClass(, ); 
 Конструктори бо параметр имконият медиҳад, ки аз функсияе, ки ба 
 майдонҳои класс қимати ибтидоӣ мебахшад, пешгирӣ карда шавад. Барномае, 
 ки дар он даъвати функсия камтар аст, зудтар иҷро мегардад. 
 Конструктори дорои як аргумент 
 Агар конструктор дорои як парметр бошад, он гоҳ аз усули сеюми равон
 кардани қиматҳои ибтидоӣ истифода бурда мешавад. Мисол. 
 #include<iostream> 
 usingnamespace std; 
 classMyFirstClass { 
 public: 
 int a; 
 //Конструктори дорои як параметр 
 MyFirstClass(intx) { 
 a = x; 
 } 
 }; 
 int main(intargc, char* argv[]) { 
 MyFirstClass Myobj =; 
 cout <<"Object a="<< Myobj.a << endl; 
 system("pause"); 
 return; 
 } 
 Дар ин ҷо конструктори MyFirstClass дорои як параметр мебошад. Дар 
 функсияи асосӣ тавассути дастури MyFirstClass Myobj= объекти Myobj 
 муаррифӣ карда шудааст. Тавассути он ба таври автоматӣ қимати ба 
 параметри конструктор равон карда мешавад. Ин дастурро метавон ба сурати 
 зерин низ навишт: 
 MyFirstClass Myobj = MyFirstClass(); 
 Классҳои локалӣ 
 Дар дохили як функсия метавон як классро муаррифӣ кард. Чунин 
 классро класси локалӣ меноманд. Ба мисоли зерин диққат диҳед: 
 #include<iostream> 
 usingnamespace std; 
 void myfunc() { 
 classMyFirstClass { 
 public: 
 int a, b; 
 void init() { 
 a =; 
 b =; 
 } 
 void show() { 
 cout <<"a="<< a << endl; 
 cout <<"b="<< b << endl; 
 } 
 }; 
 MyFirstClass Myobj; 
 Myobj.init(); 
 Myobj.show(); 
 } 
 int main() { 
 myfunc(); 
 system("pause"); 
 return; 
 } 
 Тавре дида мешавад, класс дар дохили функсия муаррифӣ ва истифода 
 шудааст. Дар методи асосӣ бошад, танҳо фуексия даъват карда шудаасту 
 халос. 
 Аз сабаби оне, ки классҳои локалӣ дорои маҳдудиятҳои зерин 
 мебошанд, бинобар ин аз онҳо камтар истифода карда мешавад: 
 Ҳамаи методҳо бояд дар дохили класси локалӣ муаррифӣ гарданд. 
 класси локалӣ наметавонад, ба тағйирёбандаҳои локалие, ки дар дохилӣ 
 муаррифӣ гардидаанд, дастрасӣ дошта бошад, ба истиснои 
 тағйирёбандаҳои статикӣ (static), хориҷӣ (external). 
 Дар дохили класси локалӣ наметавон тағйирёбандаҳои статикиро 
 муаррифӣ кард. 
 Функсияҳои дохилихаттӣ (inline functions) 
 Яке аз хусусиятҳои асосии забони C++ -функсияҳои дохилихаттӣ 
 мебошанд, ки дар классҳо васеъ истифода бурда мешаванд. Функсияҳои 
 дохилихаттӣ функсияҳое мебошанд, ки даъват нагардида, балки дар ҷойи 
 лозимӣ гузошта мешаванд. Барои функсияро ба намуди дохилихаттӣ 
 муаррифӣ кардан пеш аз номи функсия калимаи калидии inline навишта 
 мешавад. Ба мисоли зерин диққат диҳед: 
 #include<iostream> 
 usingnamespace std; 
 inlineint sum(inta, intb) 
 { 
 returna + b; 
 } 
 int main() 
 { 
 cout << sum(, ) << endl; 
 cout << sum(-, ) << endl; 
 system("pause"); 
 return; 
 } 
 Дар ин ҷо функсияи sum() даъват нагардида, танҳо дар ҷойи лозимӣ 
 гузошта мешавад. Аз нуқтаи назари компилятор барнома шакли зеринро 
 дорад: 
 #include<iostream> 
 usingnamespace std; 
 int main() 
 { 
 cout << + << endl; 
 cout << - + << endl; 
 system("pause"); 
 return; 
 } 
 Функсияҳои дохилихаттӣ суръати иҷроиши барномаро тез мекунанд, 
 зеро онҳо даъват карда намешаванд. Чӣ тавре, ки медонем, дар шар даъвати 
 функсия, аргументҳо нусхабардорӣ шуда, ба функсия равон карда мешаванд 
 ва аз он ҷо натиҷа низ чунин ба функсияи асосӣ баргардонида мешавад, яъне
 нусхаи аргументҳо дар хотираи фаврӣ нусхабардорӣ гардида, пас аз 
 баргардонидани идоракунӣ ҳолати авваларо соҳиб мешаванд. Иҷрои ин амал 
 суръати иҷроиши барномаро кунд месозад. Барои функсияҳои дохилихаттӣ ин 
 амал иҷро карда намешавад. 
 Аз сабаби оне, ки тани функсияҳои дохилихаттӣ дар ҳар даъват такрор 
 мегардад, бинобар ин, андозаи барнома бузург гашта, ба суръати иҷроиши 
 барнома халал ворид мекунад. Аз ин рӯ пешниҳод карда мешавад, ки 
 функсияҳои кӯтоҳ ба ин намуд муаррифӣ карда шаванд. 
 Функсияҳои дохили хаттӣ метавонанд аъзои класс бошанд. Ба мисоли 
 зерин диққат диҳед: 
 #include<iostream> 
 usingnamespace std; 
 classMyFirstClass { 
 public: 
 int a, b; 
 void init(); 
 void show(); 
 }; 
 inlinevoidMyFirstClass::init() { 
 a =; 
 b =; 
 } 
 inlinevoidMyFirstClass::show() { 
 cout <<"a="<< a << endl; 
 cout <<"b="<< b << endl; 
 } 
 int main() 
 { 
 MyFirstClass MyObj; 
 MyObj.init(); 
 MyObj.show(); 
 system("pause"); 
 return; 
 } 
 Бояд қайд кард, ки inline қисми забони С набуда, дар стандарти С 
 муайян карда шудааст. 
 Истифодаи функсияҳои дохилихаттӣ дар класс 
 Функсияҳои кӯтоҳро метавон дар дохили класс муаррифӣ кард. Агар 
 функсия дар дохили класс пурра навишта шавад, ба таври пешфарз ҳамчун 
 дохилихаттӣ фаҳмида мешавад. Дар ин ҳолат навиштани калимаи inline муҳим 
 нест. Дар сурати навиштани он низ хатогӣ ба амал намеояд. Ба мисоли зерин
 диққат диҳед: 
 #include<iostream> 
 usingnamespace std; 
 classMyFirstClass { 
 public: 
 int a, b; 
 void init() { 
 a =; 
 b =; 
 } 
 void show() { 
 cout <<"a="<< a << endl; 
 cout <<"b="<< b << endl; 
 } 
 }; 
 int main() 
 { 
 MyFirstClass MyObj; 
 MyObj.init(); 
 MyObj.show(); 
 system("pause"); 
 return; 
 } 
 Бояд қайд кард, ки дар баъзе компилятрҳо вобаста ба маҳдудияти 
 категорияи функсияҳо ин навъ функсияҳо пешбинӣ нашудаанд. Масалан 
 баъзан ҳангоми ба ин сурат навиштани функсияҳо бозгашти хатогӣ ба амал 
 меояд. Илова бар ин, конструктор ва деструктор метавонанд, низ ҳамчун inline
 муаррифӣ гарданд. 
 Функсияҳои бо миқдори параметрҳои тағйирёбанда 
 Дар баъзе ҳолатҳо метавон чунин функсияе навишт, ки ба миқдори 
 дилхоҳ аргумент қабул кунад. Барои ба компилятор фаҳмонидани ин навъ 
 функсияҳо пас аз аргументҳои функсия се нуқта гузошта мешавад. 
 Ҳангоми муаррифӣ намудан чунин функсияҳо бояд аққалан дорои як 
 аргументи фармалӣ (маҷозӣ) бошанд. Дар сурати надоштани аргумент 
 барнома ба хатогӣ рӯ ба рӯ мешавад. 
 Дар вақти истифода аз ин навъ функсияҳо пешниҳод карда мешавад, ки 
 аз макроҳои махсусе, ки дар китобхонаи <stdarg> ҷойгиранд, истифода карда
 шавад. Ин макроҳо стандарти дастрасӣ ба ҳамаи параметрҳоро муқаррар 
 мекунанд. 
 Мисол: 
 #include<iostream> 
 usingnamespace std; 
 long LONGPARAM(intn...) 
 { 
 int *LP = &n; 
 int Sum = *LP; 
 for (; n; n--) 
 Sum += *(++LP); 
 return Sum; 
 } 
 int main(intargc, char* argv[]) 
 { 
 long CLP; //Даъвати LongParam 
 CLP = LONGPARAM(,,,, ); 
 cout <<"LONGPARAM(,,,, )="<< CLP << endl; 
 CLP = LONGPARAM(,, ); 
 cout <<"LONGPARAM(,, )="<< CLP << endl; 
 CLP = LONGPARAM(, ); 
 cout <<"(, )="<< CLP << endl; 
 system("pause"); 
 return; 
 } 
 Натиҷаи барнома шакли зеринро дорад: 
 LONGPARAM(,,,, )= 
 LONGPARAM(,, )= 
 LONGPARAM (, )= 
 Тавре ки аз натиҷа аён аст, дар ин ҷо функсияи LONGPARAM се 
 маротиба даъват карда шудааст, ки дар ҳар даъват миқдори аргументҳои он 
 гуногун мебошанд. 
 Сарборӣ намудани конструкторҳо 
 Монанди функсияҳо (методҳо) дар як барнома метавон ба конструктор 
 низ сарборӣ гузошт. Ҳамон конструкторе даъват карда мешавад, ки ҳангоми 
 сохтани объект сигнатури параметрҳо бо он мувофиқат кунанд. 
 Мисол. Сарборигузории конструктор: 
 #include<iostream> 
 usingnamespace std; 
 classMyFirstClass { 
 public: 
 int a, b; 
 //Конструктор 
 MyFirstClass() { 
 a =; 
 b =; 
 } 
 MyFirstClass(intx) { 
 a = x; 
 b = * x; 
 } 
 MyFirstClass(intx, inty) { 
 a = x; 
 b = y; 
 } 
 MyFirstClass(intx, inty, intz) { 
 a = x + y; 
 b = y + z; 
 } 
 void show() { 
 cout <<"a = "<< a <<"\t b = "<< b << endl; 
 } 
 }; 
 int main() 
 { 
 MyFirstClass obj(, ); 
 obj.show(); 
 MyFirstClass obj(); 
 obj.show(); 
 MyFirstClass obj(,, ); 
 obj.show(); 
 system("pause"); 
 return; 
 } 
 Тавре ки дида мешавад, дар ин мисол чор конструктор эълон шудааст, 
 ки якумаш бергумент, дуюмаш дорои як аргумент, сеюмаш дорои ду аргумент 
 ва чорумаш дорои се аргумент мебошад. Дар методи асосӣ ин конструкторҳо 
 даъват карда шудаанд. Қимат ба сифати аргумент ба конструктор дода шуда, 
 ҳамчун қимати майдонҳо фаҳмида мешавад. 
 Як чизро бояд қайд кард, ки конструктори class ба таври худкора 
 (автоматӣ) ҳангоми эълони class даъват карда мешавад. Барои аз сари нав 
 даъват намудани он лозим аст, ки дар методи асосӣ аз сари нав объект сохта
 шавад. Тарзи иҷрои ин амал намуди зеринро дорад: 
 Объект=конструктор(аргумент) 
 Мисол. Аз сари нав даъват намудани конструктор: 
 #include<iostream> 
 usingnamespace std; 
 classMyFirstClass { 
 public: 
 int a, b; 
 //Конструктор 
 MyFirstClass() { 
 a =; 
 b =; 
 } 
 MyFirstClass(intx) { 
 a = x; 
 b = * x; 
 } 
 MyFirstClass(intx, inty) { 
 a = x; 
 b = y; 
 } 
 MyFirstClass(intx, inty, intz) { 
 a = x + y; 
 b = y + z; 
 } 
 void show() { 
 cout <<"a = "<< a <<"\t b = "<< b << endl; 
 } 
 }; 
 int main() 
 { 
 MyFirstClass obj(, ); 
 obj.show(); 
 MyFirstClass obj = MyFirstClass(, ); 
 obj.show(); 
 system("pause"); 
 return; 
 } 
 Дар ин мисол дар методи асосӣ бо ёрии фармони 
 MyFirstClass obj = MyFirstClass(, ); 
 Конструктор аз сари нав даъват карда шудааст. Дар ин даъват 
 конструктор ба майдонҳои класс мувофиқан қиматҳои ва -ро мебахшад. 
 Пас аз ин, бо ёрии методи show() ин қиматҳо ба саҳифаи тасвир бароварда 
 мешаванд. 
 Истифодаи деструктор 
 Деструктор ҳам монанди конструктор ҳангоми сохтани class-ҳо муайян 
 карда мешавад. Деструктор низ дорои хосиятҳои зерин мебошад. 
 ) Номи деструктор бояд бо номи class мутобиқат кунад ва пеш аз номи он 
 бояд рамзи тилда (~) гузошта шавад. 
 ) Барои деструктор аргумент мавҷуд намебошад. 
 ) Ба монади конструктор якчанд деструктор бо як ном навишта намешавад. 
 Тавре ки қаблан гуфтем, деструктор баохиррасии барнома (class)-ро 
 мефаҳмонад.Тарзи эълонкунии деструктор намуди зеринро дорад: 
 ~Class_name(); 
 { 
 ///амалкарди деструктор 
 } 
 Мисол. Истифодаи деструктор. 
 #include<iostream> 
 usingnamespace std; 
 classMyFirstClass { 
 public: 
 int a, b; 
 //Конструктор 
 MyFirstClass(intx, inty) { 
 a = x; 
 b = y; 
 } 
 ~MyFirstClass() { 
 cout <<"Object has been deleted "<< endl; 
 } 
 void show() { 
 cout <<"a = "<< a <<"\t b = "<< b << endl; 
 } 
 }; 
 int main() 
 { 
 MyFirstClass obj(, ); 
 obj.show(); 
 obj.~MyFirstClass(); 
 system("pause"); 
 return; 
 } 
 Дар ин ҷо коди барнома хеле сода мебошад. Дар аввал бо номи 
 MyFirstClass як class, ки дорои як конструктор ва як деструктор мебошад 
 муаррифӣ шудааст. Дар методи асосӣ барои даъвати конструктор аз дастури 
 obj.~MyFirstClass() истифода шудааст, ки дар саҳифаи тасвир пайғоми 
 «Object has been created» -ро ба чоп медиҳад, ки он иттилооъ дар бораи 
 баохирраси ва ё нест кардани объекти класс медиҳад. 
 Аъзоҳои кушода ва пушидаи class 
 Тавре ки қаблан гуфтем, аъзоҳои class метавонанд ба намуди кушода ё 
 пӯшида бошанд. Агар аъзоҳои class пас аз public муаррифӣ шуда бошанд, он 
 гоҳ онҳо аъзоҳои кушодаи class ба ҳисоб мераванд ва агар аъзоҳои class берун
 аз public муаррифӣ шуда бошанд, он гоҳ онҳо аъзоҳои пӯшида номида 
 мешаванд. Аъзоҳои class метавонанд ҳамчун майдонӣ ё ҳамчун методӣ 
 бошанд. 
 Мисол.Classе таҳия кунед, ки дорои майдонҳо ва методҳои кушода ва 
 пӯшида бошад. 
 #include<iostream> 
 usingnamespace std; 
 #definePI. 
 classComplex { 
 public: 
 // методҳои кушода 
 void Enter(); 
 double modul(); 
 double argument(); 
 //Аъзоҳои пӯшида 
 private: 
 double Re; 
 double Im; 
 void show_Complex(); 
 }; 
 //Иҷрои методи кушодаи Enter 
 voidComplex::Enter() { 
 cout <<"Re = "; cin >> Re; 
 cout <<"IM = "; cin >> Im; 
 show_Complex(); 
 } 
 doubleComplex::modul() { 
 return sqrt(Im*Im + Re*Re); 
 } 
 doubleComplex::argument() { 
 return atan(Im, Re) * / PI; 
 } 
 voidComplex::show_Complex() 
 { 
 if (Im >= ) 
 cout << Re <<" + "<< Im <<"i"<< endl; 
 else 
 cout << Re << Im <<"i"<< endl; 
 } 
 int main() 
 { 
 Complex adad; 
 adad.Enter(); 
 cout <<"Moduli adadi Complexi = "<< adad.modul() << 
 endl; 
 cout <<"Argumenti adadi Complexi = "<< adad.argument() 
 << endl; 
 system("pause"); 
 return; 
 } 
 Тавре ки дар ин ҷо мебинем, classе бо номи Complex муаррифӣ 
 гардидааст, ки дорои методҳои кушодаи Enter(),modul(), ва argument() 
 мебошад. Ба ғайр аз ин, дар дохили class майдонҳои пӯшидаи Re ва Im аз 
 навъи ҳақиқӣ мебошанд, муаррифӣ гардидаанд. Намуди умумии класси 
 Complex шакли зеринро дорад: 
 classComplex { 
 public: 
 // методҳои кушода 
 void Enter(); 
 double modul(); 
 double argument(); 
 //Аъзоҳои пӯшида 
 private: 
 double Re; 
 double Im; 
 void show_Complex(); 
 }; 
 Берун аз class методҳои кушодаи class иҷро гардидаанд ва барои ба онҳо
 низ дастрас шудан аз оператори иҷозати ҳудуди фаъолият:: истифода карда 
 шудааст. 
 //Иҷрои методи кушодаи Enter 
 voidComplex::Enter() { 
 cout <<"Re = "; cin >> Re; 
 cout <<"IM = "; cin >> Im; 
 show_Complex(); 
 } 
 doubleComplex::modul() { 
 return sqrt(Im*Im + Re*Re); 
 } 
 doubleComplex::argument() { 
 return atan(Im, Re) * / PI; 
 } 
 voidComplex::show_Complex() 
 { 
 if (Im >= ) 
 cout << Re <<" + "<< Im <<"i"<< endl; 
 else 
 cout << Re << Im <<"i"<< endl; 
 } 
 Дар функсияи асосӣ ба сурати зерин объекте барои class муаррифӣ 
 гардида, методҳои class даъват карда шудаанд: 
 int main() 
 { 
 Complex adad; 
 adad.Enter(); 
 cout <<"Moduli adadi Complexi = "<< adad.modul() << 
 endl; 
 cout <<"Argumenti adadi Complexi = "<< adad.argument() 
 << endl; 
 system("pause"); 
 return; 
 } 
 Аъзоҳои статикии класс 
 Аъзоҳои як класс метавонанд ҳам ба таври статикӣ ва ҳам ба таври 
 муқарарӣ (тағирёбанда) муаррифӣ гарданд.То ҳол дар классҳои навиштаамон 
 аъзоҳо муқаррарӣ буданд. Барои статикӣ муаррифӣ намудани аъзоҳои класс аз
 калимаи калидии static истифода бурда мешавад. Калимаи мазкур дар вақти 
 муаррификунӣ пеш аз навъи аъзои класс навишта мешавад. Аъзоҳои доимии 
 класс аъзоҳои умумӣ буда, барои даъвати онҳо объект сохта намешавад. Пас 
 аз муаррифии аъзои статикии класс компилятор танҳо иҷозати сохтани як 
 нусхаи ин аъзоро фароҳам меораду халос. Бигзор чанд обект аз навъи класе,
 ки аъзоҳои он статикӣ мебошанд, муаррифӣ карда шуда бошад.Дар сурати 
 иваз намудани қимати яке аз обектҳо обектҳои дигар низ ин қиматро соҳиб 
 мешаванд. 
 Мисол.Истифодаи аъзоҳои статикӣ дар класс: 
 #include<iostream> 
 usingnamespace std; 
 classMyFirstClass { 
 public: 
 staticint a; 
 void show_MyFirstClass() { 
 cout <<"Static field a="<< a << endl; 
 } 
 }; 
 intMyFirstClass::a; 
 int main() { 
 MyFirstClass obj, obj; 
 obj.a =; 
 obj.a =; 
 obj.show_MyFirstClass(); 
 obj.show_MyFirstClass(); 
 system("pause"); 
 return; 
 } 
 Натиҷаи барнома: 
 Static field a= 
 Static field a=; 
 Тавре ки аз ин мисол дида мешавад, классе бо номи MyFirstClass 
 муаррифӣ гардидааст, ки дорои як майдони аз навъи static ва як метод 
 мебошад. 
 Дар фукнсияи асосӣ ду обект бо номи obj ва obj аз навъи MyFirstClass
 сохта шудааст. Пас аз ин барои майдони ҳарду методҳо мувофиқан қиматҳои 
 ва бахшида шуда, барои ҳарду объектҳо методи show_MyFirstClass() 
 даъват карда шудааст. Дар натиҷа ҳарду обектҳо қимати -ро ба чоп 
 медиҳанд. Сабаби бавуқуъоии ин амал дар он аст, ки барои майдонҳои статикӣ
 танҳо як нусхаи класс сохта мешавад. Чи тавре ки гуфтем, ҳангоми вуҷуд 
 доштани якчанд обект ҳамаи объектҳо қимати охирон бахшидашударо соҳиб 
 мегарданд. 
 Бояд қайд кард, ки аъзоҳои статикӣ ду маротиба муаррифӣ карда 
 мешаванд: дар дохили класс ва пеш аз функсияи асосӣ (метавонад дигар ҷой 
 бошад) ҳамчун тағйирёбандаи глобалӣ. 
 Ба ғайр аз майдонҳо методҳо низ метавонанд, статикӣ бошанд. 
 Мисол.Дар поён барномаи ҷадвали Пифагор (зарб) оварда шудааст. Дар 
 он ҷо методи tabpif(int n, int m); ба намуди доимӣ (статикӣ) муаррифӣ карда
 шудааст. 
 #include<iostream> 
 usingnamespace std; 
 classMyFirstClass { 
 public: 
 staticvoid tabpif(intn, intm); 
 }; 
 int main() { 
 MyFirstClass obj; 
 int a, b; 
 cin >> a >> b; 
 obj.tabpif(a, b); 
 system("pause"); 
 return; 
 } 
 voidMyFirstClass::tabpif(intn, intm) { 
 int i, j; 
 for (i =; i <= n; i++) 
 { 
 for (j =; j <= m; j++) 
 cout << i*j <<"\t"; 
 cout << endl; 
 } 
 } 
 Дар ин мисол бошад, дар дохили класси MyFirstClass методи tabpif(int n,
 int m) ба намуди статикӣ муаррифӣ карда шудааст. Калимаи static дар 
 методҳои статикӣ пеш аз навъи метод навишта мешавад. Қисматҳои дигари 
 барнома зоҳиран фаҳмо мебошанд. 
 Функсияҳои виртуалӣ 
 Функсияи виртуалӣ функсияе мебошад, ки тавассути калимаи калидии 
 virtual дар класси базавӣ муаррифӣ карда шуда, метавонад дар як ё якчанд 
 класси дилхоҳ аз нав муаррифӣ карда шаванд. Функсияи виртуалӣ функсияи 
 махсус дар забони C++ ба ҳисоб меравад. Ҳангоми даъвати объекти класси 
 дилхоҳ дар вақти иҷроиши барнома бо ёрии ишорагар ё нишонагар ба он 
 вобаста ба навъаш C++ муайян мекунад, ки кадом функсия даъват карда 
 шудааст. Барои объектҳои гуногун варианти ба он вобастаи функсия даъват 
 карда мешавад. Классе, ки аққалан дорои як функсияи виртуалӣ мебошад, 
 класси полиморфӣ (polymorphic class) номида мешавад. 
 Функсияи виртуалӣ дар класси базавӣ бо ёрии калимаи калидии virtual 
 муаррифӣ карда мешавад. Ҳангоме ки он дар класси дигар аз нав муаррифӣ 
 мегардад, навиштани калимаи мазкур зарур намебошад. Дар вақти истифодаи 
 он низ хатогӣ ба амал намеояд. 
 Ба сифати намуна мисоли кӯтоҳи зеринро дида мебароем. 
 #include<iostream> 
 usingnamespace std; 
 classBase { 
 public: 
 virtualvoid show() { // муаррифкунонии show() ва муво- 
 фиқат кардани он бо first_d 
 cout <<"show() dar classi Base\n"; 
 } 
 }; 
 classfirst_d: publicBase { 
 public: 
 void show() { // муаррифи кунонии show() ва мувофиқат 
 кардани он бо first_d 
 cout <<"show() dar classi first_d \n"; 
 } 
 }; 
 classsecond_d: publicBase { 
 public: 
 void show() { // муаррифи кунонии show() ва нисбат до- 
 дани он бо second_d 
 cout <<"show() dar classi second_d \n"; 
 } 
 }; 
 int main() 
 { 
 Base base_obj; 
 Base *p; 
 first_d first_obj; 
 second_d second_obj; 
 p = &base_obj; 
 p->show(); // дастрасӣ бо show-и класси Base 
 p = &first_obj; 
 p->show(); // дастраси бо show-и класси first_d 
 p = &second_obj; 
 p->show(); // дастрасӣ бо show-и класси second_d 
 system("pause"); 
 return; 
 } 
 Натиҷаи барнома намуди зеринро дорад: 
 show() dar classi Base 
 show() dar classi second_c 
 show() dar classi second_d 
 Акнун барномаро пурра таҳлил карда мебароем. 
 Чунон ки дида мешавад, дар объекти Base функсияи who() ҳамчун 
 виртуалӣ муаррифӣ карда шудааст. Ин маънои онро дорад, ки функсияи 
 мазкур метавонад дар класси дилхоҳ азнавмуаррифӣ гардад. Дар ҳар як класси
 first_d ва second_d who() аз нав муаррифӣ гардидааст. Дар функсияи асосӣ 
 (main()) бошад, се тағйирёбанда муаррифӣ гардидааст. Тағйирёбандаи якум, 
 ки base_obj ном дорад, аз навъи Base мебошад. Баъд аз ин, ишорагари p аз 
 класси Base ва объектҳои first_obj ва second_obj, ки мувофиқан аз ду класси
 дилхоҳ мебошанд, муаррифӣ гардидаанд. Сипас, ба ишорагари р суроғаи 
 объекти base_obj бахшида шуда, функсияи show() даъват карда шудааст. Аз 
 сабаби он ки ин функсия ҳамчун виртуалӣ муаррифӣ гардидааст, забони C++ 
 дар вақти иҷроиши барнома вобаста аз параметрҳо муайян мекунад, ки кадом 
 версияи функсия даъват карда шудааст ва ба кадом объект p ишора мекунад. 
 Дар ҳолати якум версияи дар класси Base муаррифишуда даъват карда 
 мешавад. Сабабаш дар он аст, ки ба тағйирёбандаи p суроғаи Base бахшида 
 шудааст. Баъд аз ин ба ишорагари р суроғаи объекти first_obj бахшида 
 шудааст. Ҳангоме ки функсия даъват карда мешавад, С++ аз нав навъи 
 объектеро, ки бо он ишорагари р ишора мекунад, вобаста аз параметрҳо таҳлил
 намуда, версияи лозимии функсияро даъват мекунад. Аз сабаби он ки 
 ишорагари р ба объекти навъи first_d ишора кардааст, пас, версияи ба он 
 вобастаи функсияи show() даъват карда шудааст. Ба ҳамин монанд, вақте ки 
 ба ишорагари р суроғаи объекти second_obj бахшида мешавад, он гоҳ версияе,
 ки дар класси second_d муаррифӣ шудааст, даъват карда мешавад. 
 Яке аз усулҳои дигари даъвати функсияи виртуалӣ истифодаи параметр 
 дар функсия мебошад. Ба сифати мисол шакли дигари мисоли қаблиро дида 
 мебароем. 
 /* дар ин ҷо нишонагар ба класси базавӣ барои дастрас шудан ба функсияи 
 виртуалӣ истифода шудааст. */ 
 #include<iostream> 
 usingnamespace std; 
 classBase { 
 public: 
 virtualvoid show() { // муаррифӣ намудани функсияи вир- 
 туалӣ 
 cout <<"Base\n"; 
 } 
 }; 
 classfirst_d: publicBase { 
 public: 
 // муаррифкунонии show() ва мувофиқат кардани он бо 
 first_d 
 void show() { 
 cout <<"First derivation\n"; 
 } 
 }; 
 classsecond_d: publicBase { 
 public: 
 // муаррифкунонии who() ва мувофикат кардани он бо sec- 
 ond_d 
 void show() { 
 cout <<"Second derivation\n*"; 
 } 
 }; 
 // ба сифати параметр нишонаи класси базавӣ истифода шудааст. 
 void print_show(Base&r) { 
 r.show(); 
 } 
 int main() 
 { 
 Base base_obj; 
 first_d first_obj; 
 second_d second_obj; 
 print_show(base_obj); // дастрасӣ бо show-икласси Base 
 print_show(first_obj); 
 // дастрасӣ бо who-и класси first_d 
 print_show(second_obj); // // дастрасӣ бо show-и класси 
 second_d 
 system("pause"); 
 return; 
 } 
 Натиҷаи ин барнома низ монанди натиҷаи барномаи мисоли қаблӣ 
 мебошад. Дар ин мисол функсияи print_show() дорои параметри навъи 
 нишонагар ба класси Base мебошад. Дар функсияи асосӣ main() бо истифода 
 аз объектҳои навъи Base, first_d ва second_d функсияи виртуалӣ даъват карда
 шудааст. 
 Сарборигузории методҳо 
 Монанди функсияҳои одӣ, ки то ҳоло истифода кардем, ба методҳои 
 class низ метавонем, сарборӣ гузошт. Сарборӣ гузоштан чӣ тавре ки медонем,
 ин якчанд методро бо як ном муаррифӣ кардан мебошад. Ҳоло дар поён ин 
 амалро бо мисоле дида мебароем. 
 Мисол. 
 #include<iostream> 
 usingnamespace std; 
 classMyFirstClass { 
 int a, b; 
 public: 
 void sarboriguzory(intm, intn) { 
 a = n*n; 
 b = m*m; 
 } 
 void sarboriguzory(intm) { 
 a = m*m; 
 b = m*m; 
 } 
 void sarboriguzory() { 
 cout <<"a = "<< a << endl; 
 cout <<"b = "<< b << endl; 
 } 
 }; 
 int main() { 
 MyFirstClass obj, obj; 
 obj.sarboriguzory(, ); 
 obj.sarboriguzory(); 
 obj.sarboriguzory(); 
 obj.sarboriguzory(); 
 system("pause"); 
 return; 
 } 
 Тавре ки аз ин ҷо дида мешавад, дар classе бо номи MyFirstClass ба 
 методи sarboriguzoryба сурати зерин сарборӣ гузошта шудааст, яъне методи 
 мазкур се маротиба муаррифӣ гардидааст, ки дар ма-ротибаи аввал дорои ду 
 аргумети бутун, дар маротибаи дувум дорои як аргументи бутун ва дар 
 маротибаи охирон бе аргумент мебошад. Ба қитъаи барномаи зерин диққат 
 диҳед: 
 classMyFirstClass { 
 int a, b; 
 public: 
 void sarboriguzory(intm, intn) { 
 a = n*n; 
 b = m*m; 
 } 
 void sarboriguzory(intm) { 
 a = m*m; 
 b = m*m; 
 } 
 void sarboriguzory() { 
 cout <<"a = "<< a << endl; 
 cout <<"b = "<< b << endl; 
 } 
 }; 
 Дар функсияи асосӣ бошад, ду объект барои class муаррифӣ карда 
 шудааст. Методи sarboriguzory() чор маротиба ба сурати зерин даъват карда
 шудааст. Дар ду маротибаи аввал дорои аргумент буда, ду маротибаи дигар бе
 аргумент мебошанд. 
 int main() { 
 MyFirstClass obj, obj; 
 obj.sarboriguzory(, ); 
 obj.sarboriguzory(); 
 obj.sarboriguzory(); 
 obj.sarboriguzory(); 
 system("pause"); 
 return; 
 } 
 Саволҳо барои мустаҳкамкунӣ 
 ) Класс чист ва чӣ гуна муаррифӣ карда мешавад? 
 ) Вобаста аз ҳаёти ҳаррӯзатон мисоли класс тартиб диҳед. 
 ) Методҳо чӣ гуна муаррифӣ карда мешаванд? 
 ) Амали пешнамунасозии методҳо чӣ гуна амал аст? 
 ) Калимаи this барои чӣ истифода бурда мешавад? 
 ) Функсияҳои дохилихаттӣ чӣ гуна функсияанд? 
 ) Конструктор чист ва чӣ гуна муаррифӣ карда мешавад? 
 ) Амали сарборигузорӣ чӣ гуна амал аст? 
 ) Оё мумкин аст, конструкторро низ сарборӣ гузошт? 
 ) Классҳои локалӣ чӣ гуна классанд? 
 ) Аъзоҳои пӯшида ва кушодаи класс чӣ тавр муаррифӣ карда мешаванд? 
 ) Функсияҳои виртуалӣ чӣ гуна функсияанд? 
 ) Оё миқдори параметрҳои функсия метавонанд тағйирёбанда бошанд? 
 ) Аъзоҳои статикии класс чӣ гуна аъзоянд? 
 ) Оё функсияҳои дохилихаттиро метавон дар класс истифода кард? 
 БОБИ. КОР БО ОБЪЕКТҲО 
 Равон кардани объектҳо ба функсия ба сифати аргумент 
 Ба сифати аргументҳои метод метавонад, як объект низ равон карда 
 шавад, ба монанди тағйирёбандаҳои одӣ ба сифати тип бошад, номи classs- е,
 ки дар дохили он объект эълон карда шудааст, истифода бурда мешавад. 
 Мисол. Ба метод равон кардани объект. 
 #include<iostream> 
 usingnamespace std; 
 classMyFirstClass 
 { 
 public: 
 int a; 
 int b; 
 void max(MyFirstClassobj) 
 { 
 if (obj.a >obj.b) 
 cout <<"max("<<obj.a <<", "<<obj.b <<") = 
 "<<obj.a << endl; 
 else 
 cout <<"max("<<obj.a <<", "<<obj.b <<") = 
 "<<obj.b << endl; 
 } 
 }; 
 int main() 
 { 
 MyFirstClass obj, obj; 
 cout <<"a = "; cin >> obj.a; 
 cout <<"b = "; cin >> obj.b; 
 obj.max(obj); 
 system("pause"); 
 return; 
 } 
 Тавре дида мешавад, дар ин ҷо классе бо номи MyFirstClass, ки дорои ду
 майдони ададҳои бутун мебошад ва як метод муаррифӣ шудааст. Дар методи 
 муаррифшуда ба сифати аргумент як майдони класси аввал омадааст. Дар 
 методи мазкур қимати максималии майдонҳои класс муайян гардида, ба чоп 
 дода мешаванд. Дар методи асоси ду объект сохта шудаанд, ки якеаш барои 
 ворид намудани қимати майдонҳо ва дигараш барои даъвати методи max() ба 
 кор бурда шудаанд. Як чизро бояд дар ёд дошт, ки ҳангоми равон кардан 
 объект ҳамаи майдонҳо яклухт равон карда мешавад, на якто-якто. 
 Қимат объект баргардонидани метод 
 Тавре объект ба сифати аргументи метод фиристода мешуд, инчунин 
 метавонад, ки ҳамчун натиҷаи метод баргардонида шавад. Барои 
 баргардонидани натиҷа дар функсия ё метод объекти муваққати ба ҳамон 
 навъе, ки қимат бармегардонад, сохта мешавад. 
 Мисол. Барномае нависед, ки қимати максималии майдонҳои классро 
 баргардонад. 
 #include<iostream> 
 usingnamespace std; 
 classMyFirstClass { 
 public: 
 int a; 
 int b; 
 int max(MyFirstClassobj) { 
 if (obj.a >obj.b) 
 returnobj.a; 
 else 
 returnobj.b; 
 } 
 }; 
 int main() { 
 MyFirstClass obj; 
 cout <<"a = "; cin >> obj.a; 
 cout <<"b = "; cin >> obj.b; 
 cout <<"max("<< obj.a <<", "<< obj.b <<") = "<< 
 obj.max(obj) << endl; 
 system("pause"); 
 return; 
 } 
 Ин мисол низ ҳамон мисоли пешина буда, фарқияташ дар он аст, ки дар 
 методи max()- и он дастури return барои баргардонидани қимат истифода 
 бурда шудааст. 
 Истинодҳо (reference) 
 Дар забони C++ тағйирёбандаҳое ба ишорагарҳо монанд мавҷуд аст, ки 
 истинод номида мешавад. Истинодҳо асосан барои равон кардани параметрҳо 
 ба функсия ва барои баргардонидани қимати функсия истифода бурда 
 мешаванд. Илова бар ин метавонанд ба сифати тағйирёбандаҳои мустақил 
 истифода шаванд. Ҳоло бошад, ҳар яке имкониятҳои истинодҳоро дида 
 мебароем. 
 Равон кардани параметрҳо бо ёрии истинод 
 Яке аз татбиқи асосии истинодҳо дар вақти сохтани функсия ба таври 
 автоматӣ равон кардани параметрҳо аз рӯй нишона ба он мебошад. 
 Дар ҳолати умуми C++ бо ду усул равон кардани аргументҳоро ба 
 функсия иҷозат медиҳад: 
 ✓ Аз рӯй қимат; 
 ✓ Аз рӯй суроға. 
 Агар аргумент аз рӯй қимат равон карда шавад, метод нусхаи онро ба 
 даст меорад ва ҳар тағйироте, ки болои он ба амал меояд ҳеҷ таъсире болои
 тағйирёбанда дар функсияи асосӣ намегузорад. 
 Барои равон кардани аргументҳо аз рӯи истинод ду роҳ вуҷуд дорад, ки
 иборатанд аз: 
 ✓ Равон кардани истинод ба аргумент; 
 ✓ Новобаста равон кардани ишорагар ба аргумент. 
 Дар аксар ҳолатҳо равиши аввал ба кор бурда мешавад. барои хубтар шинос
 шудан ба ин матлаб ба барномаи зерин диққат диҳед: 
 #include<iostream> 
 usingnamespace std; 
 void twoplusarg(int *a, int *b) 
 { 
 *a = *a +; 
 *b = *b +; 
 } 
 int main() 
 { 
 int x, y; 
 cin >> x >> y; 
 cout <<"x va y pesh az davati function\n"; 
 cout <<"x="<< x <<"\t y="<< y << endl; 
 twoplusarg(&x, &y); 
 cout <<"x va y pas az davati function\n"; 
 cout <<"x="<< x <<"\t y="<< y << endl; 
 system("pause"); 
 return; 
 } 
 Дар ин барнома функсияи twoplusarg() ба сифати параметр ишорагар ба 
 тағйирёбандаҳои бутунро ба даст оварда, онҳоро ду воҳид афзоиш медиҳад. 
 Оператори «*» барои ба даст овардани суроғаи параметрҳо истифода шуда, 
 оператори «&» бошад, барои ба даст овардани қимати суроғаи ишорагарҳои 
 параметри функсияи twoplusarg() истифода шудааст. Ин амал дар забони С низ
 бо ин сурат иҷро карда мешавад. Дар забони С++ механизми дигаре низ вуҷуд
 дорад, ки дар он оператори «*» истифода бурда намешавад. Дар ин равиш 
 параметрҳое, ки истинод мебошанд истифода карда мешаванд. 
 Барои сохтани истинод ба параметр пеш аз параметр оператори «&» 
 навишта мешавад. Ба мисоли зерин диққат диҳед: 
 #include<iostream> 
 usingnamespace std; 
 void twoplusarg(int&a, int&b) 
 { 
 a = a +; 
 b = b +; 
 } 
 int main() 
 { 
 int x, y; 
 cin >> x >> y; 
 cout <<"x va y pesh az davati function\n"; 
 cout <<"x="<< x <<"\t y="<< y << endl; 
 twoplusarg(&x, &y); 
 cout <<"x va y pas az davati function\n"; 
 cout <<"x="<< x <<"\t y="<< y << endl; 
 system("pause"); 
 return; 
 } 
 Бояд қайд кард, ки дар дохили функсия истинод ба параметр 
 наметавонад ба тағйирёбандаҳои дигар алоқа дошта бошад. Аз инҷост, ки 
 оператори инкримент дар дохили функсияи twoplusarg() қимати параметрҳоро 
 зиёд мекунад, на ишорагари a ва b ро ба катакчаи нав мекучонад. 
 Хосиятҳои истинодҳо 
 Истинодҳо дорои хосиятҳои зерин мебошанд. Ҳангоми кор кардан бо 
 онҳо бояд ба ин хасиятҳо эътибор дод. Ин хосиятҳо иборатанд аз: 
 аввала бахшида шавад, (initialization). 
 ки дастурҳои зерин баробарқувваанд: 
 int &a  int& a (барои ишорагарҳо низ ин амал вуҷуд дорад. int *a 
  int* a) 
 Истиноди новобаста 
 Мо ду навъ татбиқи истинодро мавриди баҳс қарор додем, ки иборат 
 буданд аз равон кардани параметрҳо ба функсия ва баргардонидани қимат. 
 Илова бар ин, истинодҳо метавонанд монанди тағйирёбандаҳо оддӣ муаррифӣ 
 карда шаванд. Ин навъ истинодҳоро истинодҳои новобаста меноманд. 
 Истиноди новобаста ҳамчун тахаллус (псевдоним)-и обектҳо ё 
 тағйирёбандаҳо хизмат мекунанд. Ба таври дигар, номи дигари тағйирёбанда ё
 обект ҳастанд. 
 Ҳангоми муаррифӣ ба истинодҳои новобаста бояд қимати аввала 
 бахшида шавад, чунки пас аз қимати аввала бахшидан онҳоро наметавон ба 
 тағйирёбандаҳои дигар алоқаманд кард. Бо суханҳои дигар усули ягонаи 
 бахшидани қимат ба истинодҳои новобаста ин ҳангоми муаррифӣ мебошад. 
 Бояд қайд кард, ки оператори бахшиш аз қимати аввала бахшидан фарқ 
 дорад. Тавассути оператори бахшиш дар дилхоҳ нуқтаи барнома метавон ба 
 обект ё тағйирёбанда қимат бахшид, вале қимати аввала танҳо ҳангоми 
 муаррифӣ бахшида мешавад. Барои ба ин матлаб пурратар шинос шудан ба 
 мисосли зерин диққат диҳед: 
 #include<iostream> 
 usingnamespace std; 
 int main() 
 { 
 int a, b; 
 int&ref = a; 
 a =; 
 cout <<"a="<< a <<" ref="<< ref << endl; 
 ref =; 
 cout <<"a="<< a <<" ref="<< ref << endl; 
 a = a *; 
 //&ref=b; //хатоӣ, як истинод наметавонад баро ду 
 тағйиёбанда 
 //истифодашавад. 
 cout <<"a="<< a <<" ref="<< ref << endl; 
 system("pause"); 
 return; 
 } 
 Натиҷаи барнома намуди зеринро дорад: 
 a= ref= 
 a= ref= 
 a= ref= 
 Тавре дида мешавад, ҳангоми тағйир додани қимати тағйирёбандаи a, ки
 истиноди ref ба он ишора кардааст, қимати ҳам тағйирёбанда ва ҳам истинод
 айнан як хел тағйир меёбанд. 
 Тавре қайд кардем, як истинод наметавонад баро ду тағйиёбанда 
 истифода шавад. Ҳангоми риоя накардани ин хосият барнома ба хатогӣ рӯ ба 
 рӯ мешавад. 
 Ишорагар ба объектҳо 
 Ишорагарҳо на танҳо барои тағйирёбандаҳои навъҳои стандартӣ, балки 
 барои обектҳо низ метавонанд, истинод (ссылка) кунанд. Дар ин маврид барои
 дастрас шудан ба аъзоҳои класс аз оператори «->» истифода бурда мешавад. 
 Илова бар ин, барои дастрас шудан ба суроғаи хотира пеш аз номи объект 
 оператори & гузошта мешавад.Ба мисоли зерин диққат диҳед: 
 #include<iostream> 
 usingnamespace std; 
 classMyFirstClass { 
 public: 
 int a, b; 
 void show() { 
 cout <<"a="<< a << endl; 
 cout <<"b="<< b << endl; 
 } 
 }; 
 int main() { 
 MyFirstClass ob; 
 MyFirstClass *p; 
 p = &ob; 
 p->a =; 
 p->b =; 
 p->show(); 
 system("pause"); 
 return; 
 } 
 Тавре мушоҳида шуд, дар ин ҷо як класс бо номи MyFirstClass, ки дорои
 ду майдони навъи бутунӣ ва як метод бо номи show() барои намоиш додани 
 қимати ин майдонҳо мебошад, муаррифӣ шудааст. Дар функсияи асосӣ 
 бошад, объекти ob ва ишорагари p аз навъи MyFirstClass муаррифӣ шудаанд. 
 Қимати ишорагари p бо фармони p=&ob муайян карда шуда, барои ба аъзоҳои 
 объект дастрас шудан аз оператори «->» истифода шудааст. 
 Тавре ки маълум аст, ҳангоми як воҳид афзоиш додани ишорагар он ба 
 элементи дигари ҳамин навъ ишора мекунад. Масалан, барномаи зерин 
 ишорагарро барои дастрас шудан ба ҳамаи элементҳои массиви навъи 
 MyFirstClass истифода мебарад. 
 #include<iostream> 
 usingnamespace std; 
 classMyFirstClass { 
 int a; 
 public: 
 MyFirstClass() { 
 a =; 
 } 
 MyFirstClass(intb) { 
 a = b; 
 } 
 void show() { 
 cout << a <<" "<< endl;; 
 } 
 }; 
 int main() { 
 MyFirstClass ob[] = {,,,, }; 
 MyFirstClass *p; 
 p = ob; 
 for (int i =; i<; i++) 
 (p + i)->show(); 
 system("pause"); 
 return; 
 } 
 Ба ғайр аз ин, барои дастрас шудан ба майдонҳои class як ишорагари 
 махсусе низ вуҷуд дорад, ки бо ёрии он метавонем низ ба аъзоҳои class 
 дастрасӣ дошта бошем. Барои гирифтани қимати ишорагар ҳангоми даъвати 
 метод дар ин ҳолат аз оператори this истифода бурда мешавад. 
 Мисоли истифодаи оператори this барои ба даст овардани қимати май- 
 донҳои class. 
 #include<iostream> 
 usingnamespace std; 
 classMyFirstClass 
 { 
 public: 
 int n; 
 int m; 
 void show() { 
 cout <<"n = "<<this->n << endl; 
 cout <<"m = "<<this->m << endl; 
 } 
 void kvad(intm, intn) { 
 this->n = n*n; 
 this->m = m*m; 
 } 
 }; 
 int main() { 
 MyFirstClass a, b; 
 a.n =; 
 a.m =; 
 b.n =; 
 b.m =; 
 a.kvad(a.n, a.m); 
 a.show(); 
 b.show(); 
 system("pause"); 
 return; 
 } 
 Тавре ки дар ин ҷо мушоҳида карда мешавад, класси MyFirstClass дорои
 ду майдони навъи бутун бо номи n, m ва як метод аз навъи холӣ бо номи show()
 мебошад. Методи мазкур барои хориҷ намудани қимати ин майдонҳо пешбинӣ 
 шудааст. Барои дар дохили метод дастрас шудани майдонҳо оператори 
 ишорагари this истифода карда шудааст. Ба ғайр аз ин, дар классимазкур 
 методе ба сурати зерин муаррифӣ гардидааст, ки барои квадрати майдонҳои 
 классро ҳисоб намудан истифода бурда мешавад. 
 void kvad(intm, intn) { 
 this->n = n*n; 
 this->m = m*m; 
 } 
 Дар ин метод, низ ишорагари this бо оператори -> истифода барда шуда-
 аст. Дар функсияи аслӣ бошад, ду объект бо номҳои a ваb муаррифӣ гардида,
 ба онҳо қимате бахшида шудааст. Баъд аз бахшидани қимати аввала методҳои 
 class даъват карда шудаанд. 
 int main() { 
 MyFirstClass a, b; 
 a.n =; 
 a.m =; 
 b.n =; 
 b.m =; 
 a.kvad(a.n, a.m); 
 a.show(); 
 b.show(); 
 system("pause"); 
 return; 
 } 
 Ишорагар ба аъзоҳои class 
 Ҳангоми ишора кардан ба объекти class дар забони С++ барои ҳар як 
 аъзои class ишорагар мавҷуд аст. Ишорагар ба ҳар як аъзо аз ишорагари 
 муқаррарӣ фарқ мекунад. Эълонкунии ишорагар ба майдони class аз 
 эълонкунии ишорагар ба методи class фарқияти зиёд дорад. Дар вақти эълон 
 кунии ишорагар ба майдони class бояд навъи ишорагар ба навъии майдони 
 class мувофиқат кунад, дар пеши ишорагар соператори ситорача (*) гузошта 
 шуда, барои ба навъи майдони class мувофиқат кардани он, оператори иҷозати
 ҳудуди фаъолият:: гузошта мешавад.Мисол: 
 Навъии class:: *ишорагар 
 Ҳангоми қимати майдонро ба тағйирёбандаи ишорагар бахшидан дар 
 тарафи рост пас аз бахшиш оператори & навишта мешавад: 
 Ишорагар=& номи синф:: майдон 
 Эълонкунии ишорагар ба методи class камтар печидатар мебошад. Дар 
 ин сурат ҳангоми эълонкунии метод дар класс бояд навъи натиҷае, ки класс 
 бармегардонад, муайян бошад.Мисол: 
 Тип (class:: ишорагар)(аргументҳо). 
 Истифодаи истинод барои объектҳо 
 Монанди тағйирёбандаҳои дигар навъҳои базавӣ, барои объектҳо низ 
 метавон аз истинодҳо истифода кард.Истинод ин тахаллуси объект ё 
 тағйирёбанда мебошад. Истифодабарии истинод чунин имкониятҳоро 
 фароҳам меоварад: 
 ✓ Бо як ё якчанд ном истифода бурдани як объект, 
 ✓ Қимати аввала бахшидан ба объект ҳангоми муаррифӣ намудани 
 истинодҳо. 
 Мисол.Истифодаи оператори суроға. 
 #include<iostream> 
 usingnamespace std; 
 classMyFirstClass { 
 public: 
 int a; 
 double b; 
 }; 
 int main() { 
 MyFirstClass obj; 
 MyFirstClass&res = obj; 
 obj.a =; 
 obj.b =.; 
 cout <<"a="<< res.a << endl; 
 cout <<"b="<< res.b << endl; 
 system("pause"); 
 return; 
 } 
 Тавре ки мушоҳида мешавад, дар ин мисол класси MyFirstClass эълон 
 карда шудааст, ки дорои ду майдон яке бутун ва дигаре ҳақиқӣ мебошад. Дар
 методи асосӣ ё функсияи асосӣ объекте аз ин класс муаррифӣ гардидааст. 
 Сипас, аз навъи ин class тағйирёбандае бо номи res муаррифӣ гардида, ба 
 сифати қимати аввала барои он суроғаи объект бахшида шудааст. Баъд бо 
 майдонҳои class қимат дода шудааст, дар дастури хориҷкунӣ бошад, аз рӯй 
 суроға, яъне тавассути оператори ишорагар қиматҳои майдон ба чоп дода 
 шуда-анд. Ин қиматҳоро метавонед ба намуди зерин низ ба чоп диҳед. 
 cout <<"a="<<obj.a << endl; 
 cout <<"b="<< obj.b << endl; 
 Тавре ки дар мавриди нишонагарҳо дида будем, ҳангоми равон кардани 
 объект ба метод (функсия) ҳам аз рӯй қимат ва ҳам аз рӯй ишораи кардаамон
 имконпазир буд.Дар ин ҷо бошад, усули нав, яъне равон кардани объектҳо ба
 метод аз рӯй суроғаро дида меба-роем. 
 Мисол. Равон кардани объектҳо ба метод аз рӯй суроға. 
 #include<iostream> 
 usingnamespace std; 
 classMyFirstClass { 
 public: 
 double a; 
 double b; 
 }; 
 double methodMax(MyFirstClassobj) 
 { 
 if (obj.a >obj.b) 
 returnobj.a; 
 else 
 returnobj.b; 
 } 
 double methodMin(MyFirstClass&obj) 
 { 
 if (obj.a <obj.b) 
 returnobj.a; 
 else 
 returnobj.b; 
 } 
 int main(intargc, char* argv[]) 
 { 
 MyFirstClass obj; 
 cout <<"Du adadi double dokhil kuned\n"; 
 cin >> obj.a; 
 cin >> obj.b; 
 cout <<"Max("<< obj.a <<","<< obj.b <<") = "<< method- 
 Max(obj) << endl; 
 cout <<"Min("<< obj.a <<","<< obj.b <<") ="<< method- 
 Min(obj) << endl; 
 system("pause"); 
 return; 
 } 
 Дар ин мисол тавре ки дида мешавад, classе бо номи MyFirstClass 
 муаррифӣ шудааст, ки дорои ду майдон аз навъи ҳақиқӣ мебошад. Пас аз 
 муаррификунии class методе ба сурати зерин муар-рифӣ шудааст: 
 double methodMax(MyFirstClassobj) 
 { 
 if (obj.a >obj.b) 
 returnobj.a; 
 else 
 returnobj.b; 
 } 
 Аргументи метод объекте аз навъи класси MyFirstClass мебошад. 
 Методи мазкур аз ду объекти class калонтаринашро бармегардонад. Пас аз он
 методи дигаре ба намуди зерин муаррифӣ шудааст, ки ба сифати аргументи 
 он нишонаи объекти класси MyFirstClass навишта шудааст: 
 double methodMin(MyFirstClass&obj) 
 { 
 if (obj.a <obj.b) 
 returnobj.a; 
 else 
 returnobj.b; 
 } 
 Оператори &тавре ки медонем, ишора ба class мекунад. Дар функсияи 
 асосӣ бошад, объекте аз навъи класси MyFirstClassмуаррифӣ гардидааст, баъд
 аз он тавассути ин объект ба майдонҳои класс қимате аз саҳифаи вурудӣ 
 бахшида шудааст. Пас аз бахшидани қимат методҳои зикркардаамон даъват 
 карда мешаванд, ки онҳо мувофиқан қимати максималӣ ва минималии классро 
 муайян намуда, ба чоп медиҳанд. 
 Бояд қайд кард, ки нишонагарҳо на танҳо ба сифати параметри функсия 
 равон карда мешаванд, балки онҳо имконияти ба сифати қимат 
 баргардонидани функсияро фароҳам меоранд. Ба барномаи зерин диққат 
 диҳед: 
 #include<iostream> 
 usingnamespace std; 
 classMyFirstClass { 
 public: 
 int x; 
 void show() { 
 cout <<"x="<< x << endl; 
 } 
 }a; 
 MyFirstClass&func() { 
 return a; 
 } 
 int main(intargc, char* argv[]) { 
 func().x =; 
 func().show(); 
 system("pause"); 
 return; 
 } 
 Объектҳо аз навъи массив 
 Як массивро низ метавон аз навъи объект низ муаррифӣ кард. Барои 
 иҷрои ин амал, пеш аз массив ба сифати навъ номи class навишта мешавад. 
 Мисол. Барномае нависед, ки дар он массиве аз навъи class истифода 
 бурда шавад: 
 #include<iostream> 
 usingnamespace std; 
 classMyFirstClass { 
 public: 
 int x; 
 void show() { 
 cout <<"x = "<< x << endl; 
 } 
 }; 
 int main() { 
 constint n =; 
 int i; 
 MyFirstClass obja[n]; 
 for (i =; i<n; i++) { 
 obja[i].x = rand() % +; 
 cout << i + <<"; "; 
 obja[i].show(); 
 } 
 system("pause"); 
 return; 
 } 
 Дар ин мисол тавре ки аён аст, class –и MyFirstClass муаррифӣ 
 гардидааст, ки дорои як майдон ва як метод мебошад. Дар методи асосӣ бошад,
 тағйирёбандаи (массиви) obja[n] аз навъи class муаррифӣ шудааст. Баъд 
 элементҳои массив аз ададҳои тасодуфӣ пур карда шудаанд. Барои ба экран 
 баровардани элементҳои массив методи show() чунин даъват карда шудааст: 
 obja[i].show(); 
 Агар дар массив конструктор истифода шавад, барои равон кардани 
 аргументҳо ҳангоми муаррификунии массив дарҳол ба он қимати аввала 
 бахшида мешавад. Конструктор дар дохили қавси фигуравӣ бо аргументҳои 
 лозимӣ даъват карда мешавад. 
 Мисол. Истифодаи конструктор барои массивҳо 
 #include<iostream> 
 usingnamespace std; 
 classMyFirstClass { 
 public: 
 int x; 
 void show() { 
 cout <<"x = "<< x << endl; 
 } 
 MyFirstClass(inty) { 
 x = y; 
 } 
 }; 
 int main() 
 { 
 int i; 
 MyFirstClass obja[] = { MyFirstClass(), 
 MyFirstClass(), MyFirstClass(), MyFirstClass(-) }; 
 for (i =; i<; i++) { 
 cout << i + <<"; "; 
 obja[i].show(); 
 } 
 system("pause"); 
 return; 
 } 
 Ба ғайр аз ин, метавонем элементҳои массивро ба намуди зерин муар- 
 рифӣ кунем: 
 MyFirstClassobja[]={,,,-}; 
 Ба таври динамики ишғол кардани хотира барои объектҳо 
 Барои ба таври динамикӣ ишғол кардани хотира барои объектҳо аз 
 оператори new истифода бурда мешавад. Дар аввал ба монанди массивҳои 
 динамикӣ нишонагаре аз навъи class –е, ки объект аз навъи он эълон мешавад,
 муаррифӣ карда мешавад. Баъд аз он, бо ёрии оператори new барои объект ба
 таври динамикӣ ҳофиза ҷудо карда мешавад. Мисол. 
 Номи class **тағйирёбандаи ишорагар 
 Тағйирёбандаи ишорагар =new номи class 
 Барои ҳофизаро озод намудан аз оператори delete ба намуди зерин 
 истифода бурда мешавад. 
 delete тағйирёбандаи ишорагар; 
 Мисол: 
 #include<iostream> 
 usingnamespace std; 
 classMyFirstClass { 
 public: 
 int x; 
 void show() { 
 cout <<"x ="<< x << endl; 
 } 
 MyFirstClass(inta, intb) { 
 if (a>b) 
 x = a; 
 else 
 x = b; 
 cout <<"Objecti x = "<< x <<" sokhta shud!\n"; 
 } 
 ~MyFirstClass() { 
 cout <<"Objecti x = "<< x <<" nest karda shud!\n"; 
 } 
 }; 
 int main() { 
 MyFirstClass *p=NULL; 
 delete p; 
 p = newMyFirstClass(, ); 
 p->show(); 
 delete p; 
 system("pause"); 
 return; 
 } 
 Функсия ва классҳои дӯст 
 Тавре ки қаблан зикр карда будем, аъзоҳои класс ду намуд мешаванд: 
 кушода ва пӯшида. Аъзоҳои пӯшидаи класс танҳо дар дохили класс дастрас 
 мебошанд. Дар баъзе ҳолатҳо зарурат мешавад, ки аъзоҳои пӯшидаи класс дар
 функсия ё методҳои берун аз класс истифода бурда шаванд. Барои иҷрои ин 
 амал, яъне истифодакунии аъзоҳои пӯшидаи класс берун аз класс 
 азфунксияҳои дӯст (friend ) истифода бурда мешаванд. 
 Ҳангоми муаррификунии ин навъ функсияҳо пеш аз пеш намунасозии 
 функсияҳо калимаи калидии friend навишта мешавад. 
 Мисоли муаррификунии метод (функсия)-ҳои дӯст. 
 #include<iostream> 
 usingnamespace std; 
 classMyFirstClass { 
 int x; 
 float y; 
 public: 
 MyFirstClass(intz) { 
 x = z; 
 y = sqrt(x); 
 } 
 friendvoid show(MyFirstClassobj); 
 }; 
 void show(MyFirstClassobj) { 
 cout <<"x = "<<obj.x << endl; 
 cout <<"x = "<<obj.y << endl; 
 } 
 int main() { 
 MyFirstClass adad(); 
 show(adad); 
 system("pause"); 
 return; 
 } 
 Тавре дида мешавад, дар ин ҷо classе бо номи MyFirstClass муаррифӣ 
 гардидааст, ки он дорои ду майдони пӯшида мебошад, ки яке аз онҳо аз навъи
 бутун ва дигараш аз навъи ҳақиқӣ мебошад. Барои ба ин майдонҳо бахшидани 
 қимат ё пур намудани ин майдонҳо аз конструкторе, ки як аргумент 
 бармегардонад, истифода шудааст. Барои дастрас шудан ба майдонҳои 
 пӯшидаи class аз методи беруна, ки он ҳамчун дӯст муаррифӣ гардадааст, 
 истифода бурда мешавад, яъне 
 friend void show(MyFirstClass obj); 
 Барои функсияе, ки дар он майдонҳои пӯшида берун аз class истифода 
 мешаванд, бояд дар дохили class ба намуди дӯст пешнамуна гардад. 
 Мисол. Бигзор ду class бо майдонҳои пӯшида мавҷуд бошанд, барои дастрас 
 шудан ба ҳар яке аз онҳо инчунин аз функсияҳои дӯст истифода бурда 
 мешавад. Ин амал бошад, истифода ва татбиқи дигари функсияҳои дӯстро 
 ифода мекунад. 
 #include<iostream> 
 usingnamespace std; 
 //Эълоннамудани class 
 classB; 
 classA { 
 double x; 
 public: 
 A(doublez) { 
 x = z; 
 } 
 frienddouble sum(Aa, Bb); 
 } a(.); 
 classB { 
 double y; 
 public: 
 B(doublez) { 
 y = z; 
 } 
 frienddouble sum(Aa, Bb); 
 } b(.); 
 double sum(Aa, Bb) { 
 returna.x + b.y; 
 } 
 void show() { 
 cout <<"Summa = "<< sum(a, b) << endl; 
 } 
 int main() { 
 show(); 
 system("pause"); 
 return; 
 } 
 Дар ин барнома ду class А ва В муаррифӣ гардидаанд, ки ҳар кадоми он
 дорои майдони пӯшидаи навъи ҳақиқӣ мебошанд. Функсияи sum() суммаи 
 майдонҳои пӯшидаи ин классҳоро ҳисоб менамояд, ки ба сифати аргумент ба 
 он равона карда шудаанд: 
 friend double sum(A a, B b ); 
 Аргументи якум объекти майдони класси А ва аргументи дувум 
 объекти класси В мебошанд. Барои ба ин объекто дастрас шудан функсияи 
 sum()ҳамчун friend муаррифӣ гардидаанд. Аҷибаш дар он аст, ки дар дохили 
 класси А то ҳол класси В муайян нест, майдони В b истифода шудааст. Барои
 ин класси В пеш аз класси А ҳамчун огоҳӣ муаррифӣ шудааст ва то расидан 
 бо класси В он огоҳӣ истифода мешавад. Баъдан дар функсияи show() натиҷаи
 ҳисобкардашудаи методи sum () намоиш дода шудааст. 
 Ба ғайр аз ин, метавонем дар класси дувум ба майдони пӯшидаи класси 
 якум тавассути оператори иҷозати ҳудуди фаъолият::дастрасӣ дошта бошем. 
 Мисол. Истифодаи оператори:: 
 #include<iostream> 
 usingnamespace std; 
 //Эълоннамудани class 
 classB; 
 classA { 
 double x; 
 public: 
 A(doublez) { 
 x = z; 
 } 
 double sum(Bb); 
 } a(.); 
 classB { 
 double y; 
 public: 
 B(doublez) { 
 y = z; 
 } 
 frienddoubleA::sum(Bb); 
 } b(.); 
 doubleA::sum(Bb) { 
 return x + b.y; 
 } 
 void show() { 
 cout <<"Summa = "<< a.sum(b) << endl; 
 } 
 int main() { 
 show(); 
 system("pause"); 
 return; 
 } 
 Ин мисол ҳам монанди мисоли гузашта буда, фарқияташ дар он аст, ки 
 суммаи майдонҳо тавассути методи класси А ҳисоб карда шудаанд. 
 Мисол. Истифодаи дигари метод (функсия)-ҳои дӯст. 
 #include<iostream> 
 usingnamespace std; 
 //Эълоннамудани class 
 classB; 
 classA { 
 double x; 
 public: 
 A(doublez) { 
 x = z; 
 } 
 double jam(Bb); 
 double zarb(Bb); 
 } a(.); 
 classB { 
 double y; 
 public: 
 B(doublez) { 
 y = z; 
 } 
 friendclassA; 
 } b(.); 
 doubleA::jam(Bb) { 
 return x + b.y; 
 } 
 doubleA::zarb(Bb) { 
 return x*b.y; 
 } 
 void show() { 
 cout <<"Hosili jam = "<< a.jam(b) << endl; 
 cout <<"Hosili zarb = "<< a.zarb(b) << endl; 
 } 
 int main() { 
 show(); 
 system("pause"); 
 return; 
 } 
 Функсияҳои виртуалӣ 
 Функсияи виртуалӣ, функсияе мебошад, ки тавассути калимаи калидии 
 virtual дар класси базавӣ муаррифӣ карда шуда, метавонад дар як ё якчанд 
 класси дилхоҳ аз нав муаррифӣ карда шаванд. Функсияи виртуалӣ функсияи 
 махсус дар забони C++ ба ҳисоб меравад. Ҳангоми даъвати объекти класси 
 дилхоҳ дар вақти иҷроиши барнома бо ёрии ишорагар ё нишонагар ба он 
 вобаста ба навъаш C++ муайян мекунад, ки кадом функсия даъват карда 
 шудааст. Барои объектҳои гуногун варианти ба он вобастаи функсия даъват 
 карда мешавад. Классе, ки аққалан дорои як функсияи виртуалӣ мебошад, 
 класси полиморфӣ (polymorphic class) номида мешавад. 
 Функсияи виртуалӣ дар класси базавӣ бо ёрии калимаи калидии virtual 
 муаррифӣ карда мешавад. Ҳангоме ки он дар класси дигар аз нав муаррифӣ 
 мегардад, навиштани калимаи мазкур зарур намебошад. Дар вақти истифодаи 
 он низ хатогӣ ба амал намеояд. 
 Ба сифати мисол барномаи кӯтоҳи зеринро дида мебароем: 
 #include<iostream> 
 usingnamespace std; 
 //Эълон намудани class 
 classBase { 
 public: 
 virtualvoid show() { // муаррифӣ гардидани функсияи вир- 
 туали 
 cout <<"show dar Base\n"; 
 } 
 }; 
 classfirst_d: publicBase { 
 public: 
 void show() { // муаррификунонии show() ва мувофикат 
 кардани он бо first_d 
 cout <<"show dar first_d\n"; 
 } 
 }; 
 classsecond_d: publicBase { 
 public: 
 void show() { // муаррификунонии who() ва нисбат додани 
 он бо second_d 
 cout <<"show dar second_d\n"; 
 } 
 }; 
 int main() 
 { 
 Base base_obj; 
 Base *p; 
 first_d first_obj; 
 second_d second_obj; 
 p = &base_obj; 
 p->show(); // дастрасӣ бо show-и класси Base 
 p = &first_obj; 
 p->show(); // дастрасӣ бо show-и класси first_d 
 p = &second_obj; 
 p->show(); // дастрасӣ бо show-икласси second_d 
 system("pause"); 
 return; 
 } 
 Натиҷаи барнома намуди зеринро дорад: 
 show dar Base 
 show dar second_d 
 show dar first_d 
 Акнун барномаро пурра таҳлил карда мебароем. 
 Чунончи, дида мешавад, дар объекти Base функсияи show() ҳамчун 
 виртуалӣ муаррифӣ карда шудааст. Ин маънои онро дорад, ки функсияи 
 мазкур метавонад дар класси дилхоҳ аз нав муаррифӣ гардад. Дар ҳар як 
 класси first_d ва second_d show() аз нав муаррифӣ гардидааст. Дар функсияи
 асосӣ (main()) бошад, се тағйирёбанда муаррифӣ гардидааст. Тағйирёбандаи 
 якум, ки base_obj ном дорад, аз навъи Base мебошад. Баъд аз ин, ишорагари p
 аз класси Base ва объектҳои first_obj ва second_obj, ки мувофиқан аз ду класси
 дилхоҳ мебошанд, муаррифӣ гардидаанд. Сипас, ба ишорагари р суроғаи 
 объекти base_obj бахшида шуда, функсияи show() даъват карда шудааст. Аз 
 сабаби он ки ин функсия ҳамчун виртуалӣ муаррифӣ гардидааст, забони C++ 
 дар вақти иҷроиши барнома вобаста аз параметрҳо муайян мекунад, ки кадом 
 версияи функсия даъват карда шудааст ва ба кадом объект p ишора мекунад. 
 Дар ҳолати якум версияи дар класси Base муаррифишуда даъват карда 
 мешавад. Сабабаш дар он аст, ки ба тағйирёбандаи p суроғаи Base бахшида 
 шудааст. Баъд аз ин ба ишорагари р суроғаи объекти first_obj бахшида 
 шудааст. Ҳангоме ки функсия даъват карда мешавад, С++ аз нав навъи 
 объектеро, ки бо он ишорагари р ишора мекунад, вобаста аз параметрҳо таҳлил
 намуда, версияи лозимии функсияро даъват мекунад. Аз сабаби он ки 
 ишорагари р ба объекти навъи first_d ишора кардааст, пас, версияи ба он 
 вобастаи функсияи show() даъват карда шудааст. Ба ҳамин монанд, вақте ки ба
 ишорагари р суроғаи объекти second_obj бахшида мешавад, он гоҳ версияе ки
 дар класси second_d муаррифӣ шудааст, даъват карда мешавад. 
 Яке аз усулҳои дигари даъвати функсияи виртуалӣ истифодаи параметр 
 дар функсия мебошад. Ба сифати мисол намуди дигари мисоли гузаштаро дида 
 мебароем. 
 /* дар ин ҷо нишонагар ба класси базавӣ, барои дастрас шудан ба функсияи 
 виртуалӣ истифода шудааст. */ 
 #include<iostream> 
 usingnamespace std; 
 //Эълон намудани class 
 classBase { 
 public: 
 virtualvoid show() { // муаррифӣ гардидани функсияи вир- 
 туалӣ 
 cout <<"show dar Base\n"; 
 } 
 }; 
 classfirst_d: publicBase { 
 public: 
 void show() { // муаррификунонии show() ва мувофикат 
 кардани он бо first_d 
 cout <<"show dar first_d\n"; 
 } 
 }; 
 classsecond_d: publicBase { 
 public: 
 void show() { // муаррификунонииshow() ва нисбат додани 
 он бо second_d 
 cout <<"show dar second_d\n"; 
 } 
 }; 
 void print_show(Base&r) { 
 r.show(); 
 } 
 int main() 
 { 
 Base base_obj; 
 first_d first_obj; 
 second_d second_obj; 
 print_show(base_obj); // дастрасӣ бо show-икласси Base 
 print_show(second_obj); //дастрасӣ бо show-и класси 
 second_d 
 system("pause"); 
 return; 
 } 
 Натиҷаи ин барнома низ монанди натиҷаи барномаи мисоли қаблӣ 
 мебошад. Дар ин мисол функсияи show_who() дорои параметри навъи 
 нишонагар ба класси Base мебошад. Дар функсияи асосӣ main() бо истифода 
 аз объектҳои навъи Base, first_d ва second_d функсияи виртуалӣ даъват карда
 шудааст. 
 Хосияти Варосат 
 Мафҳуми умумии варосат ва корбурди он 
 Яке аз хусусиятҳои дигари БОН хосияти меросӣ ё варосат (Inheritance)
 мебошад. Варосат-ин механизимест, ки имконияти якчанд маротиба 
 истифодабарии як ё якчанд хосияти як классро ҳангоми сохтани класси нав 
 фароҳам меорад. Истифода аз ин хосият кори барномасозиро осон намуда, 
 коди барномаро кӯтоҳ мекунад. Варосат метавонад варосати сода (single 
 Inheritance) ва ё варосати мураккаб (multiple Inheritance) бошад. 
 Тавре ки қайд кардем, як синфи нав сохташуда метавонад хосиятҳои 
 синфи мавҷудбударо ба ирс гирад, яъне он хосиятҳо дар синфи нав такрор 
 нашуда, танҳо нишон ё ишора карда шаванд. Дар ин ҳолат синфи 
 мавҷудбударо синфи меросдеҳ ва синфи навсохтаро синфи меросгир ё 
 меросбар меноманд. 
 Барои ба ин хосият шинос шудан донишгоҳро пеши назар меорем. Ҳар 
 донишгоҳ дорои шахси масъул, яъне мудир мебошад, ки он ҳамаи 
 донишгоҳро идора мекунад ва донишгоҳ бошад, дорои факултетҳо мебошад, 
 ки дар ҳар факултет як роҳбар аст, ки он факултетро идора мекунад Ба ғайр аз
 ин, дар факултет кафедраҳо ва курсҳои донишҷӯён мавҷуд аст, ки ҳар кадомаш
 дорои роҳбар мебошад, яъне дар ин сурат метавон гуфт, ки ин мисоли 
 меросбарии мураккаб мебошад, зеро дар ин ҷо якчанд class-ҳо ҳам меросдеҳ 
 ва ҳам меросбар ё меросгир мебошанд. Агар инро ба намуди диаграмма тасвир
 кунем, шакли зеринро мегирад. 
 Наҳви умумии муаррифкунии класси меросбар намуди зеринро дорад: 
 Class class-и_меросбар::навъии class-и_базавӣ(меросдеҳ){ 
 //тани класси меросбар 
 } Рӯйхати объектҳо; 
 Бигзор класси В дар асоси класси А сохта шуда бошад, яъне он меросбари 
 класси А бошад. Тавре ки пештар гуфтем, агар меросбари кушода (public 
 Inheritance) бошад, онро метавон ба намуди зерин муаррифӣ кард: 
 Class A{ 
 //Тани класси А 
 } Рӯйхати объектҳо 
 //………. 
 Class B: public A{ 
 //Тани класси В 
 }//Рӯйхати объектҳо 
 Мисол: 
 #include<iostream> 
 usingnamespace std; 
 #definen 
 //Эълон намудани class 
 classA { 
 private: 
 int x; 
 public: 
 int y; 
 }; 
 //Класси меросбар( меросгир) 
 classB:publicA { 
 public: 
 int z; 
 void show() { 
 cout <<"y = "<< y << endl; 
 cout <<"z = "<< z << endl; 
 } 
 }; 
 int main() { 
 B obj; 
 obj.y =; 
 obj.z =; 
 obj.show(); 
 system("pause"); 
 return; 
 } 
 Тавре мушоҳида карда шуд, дар класси А ду майдон муаррифӣ шуд, ки 
 якеаш майдони пӯшида ва дигараш майдони кушода будаанд. Класси В бошад, 
 дорои як майдони кушода ва як метод буда, меросбари класс А ба ҳисоб 
 меравад. Дар методи show() як майдони класси А ва як майдони класси В ба 
 чоп дода шудаанд. Майдони х-и класси А бошад, наметавонад дар ин ҷо 
 иштирок кунад, зеро он ба намуди пӯшида муаррифӣ шудааст ва класси 
 пӯшида наметавонад меросбар бошад. 
 Акнун ҳолатеро мебинем, ки майдони х ҳимояшуда, яъне ҳамчун 
 protected муаррифӣ шудааст. Дар ин сурат он метавонад ба класси В меросдеҳ
 шавад. Майдони х наметавонад, ки якбора ба класси В дастрас бошад, барои 
 он бояд методи ёрирасон муаррифӣ гардад. Мисол. 
 #include<iostream> 
 usingnamespace std; 
 #definen 
 classA { 
 protected: 
 int x; 
 public: 
 int y; 
 void set(intk) { 
 x = k; 
 } 
 }; 
 //Классимеросбар( меросгир) 
 classB:publicA { 
 public: 
 int z; 
 void show() { 
 cout <<"x = "<< x << endl; 
 cout <<"y = "<< y << endl; 
 cout <<"z = "<< z << endl; 
 } 
 }; 
 int main() 
 { 
 B obj; 
 obj.set(); 
 obj.y =; 
 obj.z =; 
 obj.show(); 
 system("pause"); 
 return; 
 } 
 Варосати мураккаб 
 Тавре ки ишора карда будем, варосат сода ва мураккаб мешавад. 
 Варосати сода варосатест, ки дар он як класс танҳо аз як класси базавӣ мерос
 мегирад. Мисолҳои боло варосати сода ба ҳисоб мераванд. Варосати мураккаб
 бошад, варосатест, ки як класс на аз якто класси базавӣ мерос мегирад, балки
 он аз якчанд class мерос мегирад. Дар ин ҳолат наҳви муаррификунии чунин 
 классҳо намуди зеринро дорад: 
 Class_Nav: class A, class B, …, class Z 
 { 
 //тани класси нав 
 } 
 Ҳоло классро мебинем, ки дар асоси ду класси базавӣ сохта 
 шудааст.Мисол. 
 #include<iostream> 
 usingnamespace std; 
 #definen 
 classA 
 { 
 public: 
 int x; 
 void showx() { 
 cout <<"x = "<< x << endl; 
 } 
 }; 
 classB { 
 public: 
 int y; 
 void showy() 
 { 
 cout <<"y = "<< y << endl; 
 } 
 }; 
 classC:publicA, publicB { 
 public: 
 void show() { 
 showx(); 
 showy(); 
 } 
 }; 
 int main() 
 { 
 C obj; 
 obj.x =; 
 obj.y =; 
 obj.show(); 
 system("pause"); 
 return; 
 } 
 Чунон ки дида мешавад, дар ин ҷо се класс муаррифӣ шудааст, ки 
 дутоаш класси базавӣ ва яктоаш класси меросбар мебошад. Дар класси якум 
 як майдони адади бутун ва як метод барои намоиш додани он муаррифӣ 
 шудааст. Дар класси В низ айнан монанди класси А майдон ва метод мавҷуд 
 аст. Класси С дар асоси классҳои А ва В сохта шудааст, дар ин class чӣ хеле
 ки мушоҳида кардед, методи show() муаррифӣ шудааст, ки дар он методҳои 
 classси А ва В даъват карда мешаванд. 
 Шаблонҳо барои варосат 
 Ба монанди функсияҳо барои варосат низ шаблонҳо вуҷуд доранд ва 
 истифодабаранда метавонад, ки аз шаблонҳо истифода барад. Дар ин ҷо низ 
 шаблонҳо бо ёрии калимаи калидии template муаррифӣ мегарданд. Наҳви 
 муаррификунии як қолаби класс ба сурати зерин аст: 
 template <class A> class First 
 Дар ин ҷо template калимаи калиди, class A навъ (объект)-и класс ва class
 First номи класс мебошад. 
 Мисол: 
 #include<iostream> 
 usingnamespace std; 
 template<classA>classFirst { 
 public: 
 A x; 
 First(Aarg) { 
 x = arg; 
 } 
 }; 
 template<classA, classB>classSecond: publicFirst<A> { 
 public: 
 B y; 
 void show() { 
 cout <<"x = "<< x << endl; 
 cout <<"y = "<< y << endl; 
 } 
 Second(Aarg, Barg):First<A>(arg) { 
 y = arg; 
 } 
 }; 
 int main(int) { 
 Second<int, char> obj(, 'w'); 
 obj.show(); 
 system("pause"); 
 return; 
 } 
 Саволҳо барои мустаҳкамкунӣ 
 БОБИ. САРБОРӢ НАМУДАНИ ОПЕРАТОРҲО 
 Муқаддима 
 Дар забони С++ на танҳо функсияҳо, инчунин операторҳоро метавонем 
 низ сарборӣ кунем. Барои иҷрои ин амал бояд дар дохили class функсияи 
 махсус, ки метод номида мешавад, сохта шавад. Барои иҷрои амали сарборӣ 
 бояд ба шартҳои зерин эътибор дод: 
 кунад. 
 ҷадвали зерин қобилияти сарборишавӣ доранд. 
 Дар ҷадвали зерин операторҳое, ки бо онҳо сарборӣ карда мешавад, 
 оварда шудаанд: 
 + - * / % ^ & | 
 ~! = < > += -= *= 
 /= %= ^= &= |= << >> >>= 
 <<= ==!= <= >= && || ++ 
 -- ->*, -> [] () new delete 
 new[] delete [] 
 Дар ҷадвали зерин бошад, он операторҳое, ки онҳоро сарборӣ карда 
 ғайриимкон аст, оварда шудаанд...*::?: 
 Барои сарборӣ кардани операторҳо функсия-operator сохта мешаванд. 
 Тарзи умумии муарррификунии як функсия-operator намуди зеринро дорад: 
 Навъ, номи класс::operator # (Рӯйхати аргументҳо) 
 { 
 Амалиёт бо класс 
 } 
 Дар ин ҷо рамзи # оператори сарборӣ мекардашударо ифода мекунад. 
 Тавре аз ин қолаб мушоҳида карда мешавад, операторҳои бинорӣ дар 
 дохили синф меоянд ва баъд аз онҳо дар дохили қавс аргументҳои он нишон 
 дода мешаванд. Аргументҳои метод операнд номида мешаванд. Аз ин рӯ, 
 ҳангоми истифода операторҳои бинарӣ ду операнд ва барои операторҳои 
 унарӣ бошад, як операнд истифода бурда мешавад. Операндҳо аз ҳамдигар бо 
 оператори “,” ҷудо карда мешаванд. Пеш аз ҳар кадом операнд навъи он 
 нишон дода мешавад. 
 Сарборӣ кардани операторҳо бо истифода аз функсия-аъзоҳо 
 Дар аввал кори худро аз мисоли содае оғоз мекунем. Дар мисоли мазкур
 тарзи сарборигузории операторҳои «+» ва «=« барои бо ҳамдигар ҷамъ 
 намудани ду адади комплексӣ нишон дода шудааст. 
 Аз нуқтаи назари математика (НФТК) медонем, ки адади комплексӣ 
 намуди зеринро дорад: 
 z=x+iy 
 дар инҳо х=Re(z) –қисми ҳақиқии адади комплексӣ буда, y=Im(z) –қисми 
 мавҳум мебошад. Барои ҷамъ намудани ду адади комплексӣ қисмҳои ҳақиқӣ 
 бо ҳақиқӣ ва қисмҳои мавҳум бо мавҳум ҷамъ карда мешаванд. 
 Мисоли: 
 #include<iostream> 
 usingnamespace std; 
 classComplex { 
 float Re; 
 float Im; 
 public: 
 Complex(){ 
 Im = Re =; 
 } 
 Complex(floata, floatb) { 
 Re = a; 
 Im = b; 
 } 
 Complexoperator +(Complexob); 
 Complexoperator =(Complexob); 
 void print(); 
 }; 
 ComplexComplex::operator +(Complexob) { 
 Complex z; 
 z.Re = Re + ob.Re; 
 z.Im = Im + ob.Im; 
 return z; 
 } 
 ComplexComplex::operator =(Complexob) { 
 Re = ob.Re; 
 Im = ob.Im; 
 return *this; 
 } 
 voidComplex::print() { 
 if (Im>) 
 cout <<"z = "<< Re <<" + "<< Im <<"i"<< endl; 
 else 
 cout <<"z = "<< Re << Im <<"i"<< endl; 
 cout <<"**********"<< endl; 
 } 
 int main() { 
 Complex a(., -.), b(-.,.), c; 
 cout <<"adadi:"<< endl; 
 a.print(); 
 cout <<"adadi:"<< endl; 
 b.print(); 
 c = a + b; 
 cout <<"Summai adadho:"<< endl; 
 c.print(); 
 system("pause"); 
 return; 
 } 
 Дар ин ҷо дар аввал классе бо номи Complex, ки дорои ду майдони 
 пӯшидае бо номҳои Re ва Im мебошанд, муаррифӣ гардидаанд. Баъдан, 
 конструктор барои ба майдонҳо қимат бахшидан даъват карда шудааст. Сипас,
 метод-operator-ҳои зарурӣ ба намуди зерин пешнамуна карда шудаанд: 
 Complex operator +(Complex ob); 
 Complex operator =(Complex ob); 
 void print (); 
 Пас аз ин барои дастрасшавӣ ба ин метод-operator-ҳо аз оператори «::»
 истифода бурда шудааст. Дар дохили метод-operator-и аввала, ки дар он 
 оператори «+» сарборӣ карда шудааст, суммаи қисмҳои ҳақиқӣ ва мавҳуми ду 
 адади комплексии додашуда ҳисоб карда шуда, қимати он баргардонида 
 мешавад. Дар метод-operator-и дувум ба адади комплексӣқимате нисбат дода 
 шуда, натиҷа тавассути ишорагари this баргардонида мешавад. Методи print()
 бошад, барои адади комплексиро ба чоп додан хизмат мекунад. Дар функсияи 
 асосӣ бошад, се объект аз навъи class муаррифӣ гардида, ба дутои онҳо 
 қимати аввала нисбат дода шудааст. Объекти сеюм бошад, барои суммаи ин 
 қисматҳоро ҳисоб намудан истифода бурда мешавад. Аҷибаш дар он аст, ки ба
 ҷойи даъвати функсия дар функсияи асосӣ оператори “+” истифода шудааст. 
 Ибораи c=a+b суммаи қисмҳои ҳақиқӣ ва мавҳуми ададҳои комплексии 
 додашударо ҳисоб мекунад. 
 Натиҷаи барнома намуди зеринро дорад: 
 adadi 
 z=.-.i 
 *********** 
 adadi 
 z=.+.i 
 *********** 
 Summai adadi bar adadi: 
 z=.-.i 
 *********** 
 z=.+.i 
 Сарборӣ кардани операторҳои ягона (унарӣ) бо ёрии функсия-аъзоҳо 
 Операторҳои як воҳид афзоиш (инкремент) ва як воҳид коҳиш 
 (дикремент) низ қобилияти сарборӣ гузоштанро доранд. Ҳоло дар мисоли 
 зерин тарзи сарборӣ шудани оператори як воҳид афзоишро дида мебароем. 
 Азбаски ин мисолро низ дар класси Complex дида мебароем, пас мисоли 
 намуди зеринро мегирад. 
 Мисоли: 
 #include<iostream> 
 usingnamespace std; 
 classComplex { 
 float Re; 
 float Im; 
 public: 
 Complex() { 
 Im = Re =; 
 } 
 Complex(floata, floatb) { 
 Re = a; 
 Im = b; 
 } 
 Complexoperator +(Complexob); 
 Complexoperator =(Complexob); 
 Complexoperator ++(); 
 void print(); 
 }; 
 ComplexComplex::operator +(Complexob) { 
 Complex z; 
 z.Re = Re + ob.Re; 
 z.Im = Im + ob.Im; 
 return z; 
 } 
 ComplexComplex::operator =(Complexob) { 
 Re = ob.Re; 
 Im = ob.Im; 
 return *this; 
 } 
 ComplexComplex::operator ++() { 
 Re++; 
 Im++; 
 return *this; 
 } 
 voidComplex::print() { 
 if (Im>) 
 cout <<"z = "<< Re <<" + "<< Im <<"i"<< endl; 
 else 
 cout <<"z = "<< Re << Im <<"i"<< endl; 
 cout <<"**********"<< endl; 
 } 
 int main(intargc, char* argv[]) { 
 Complex a(., -.), b(-.,.), c; 
 cout <<"Adadi:"<< endl; 
 a.print(); 
 cout <<"Adadi:"<< endl; 
 b.print(); 
 c = a + b; 
 cout <<"Summai adadho:"<< endl; 
 c.print(); 
 cout <<"Qimati adadi Z pas az amali increment:"<< endl; 
 ++c; 
 c.print(); 
 system("pause"); 
 return; 
 } 
 Натиҷаи барнома: 
 adadi 
 z=.-.i 
 *********** 
 adadi 
 z=-.+.i 
 *********** 
 Summai adadi bar adadi: 
 z=.+.i 
 *********** 
 Qimati adadi Z pas azamali Increment: 
 z=.+.i 
 *********** 
 Операторҳои ягонаи як воҳид афзоиш ва як воҳид коҳиш дорои хосияти 
 пешвандӣ ва пасвандӣ буда, ба сурати зерин истифода бурда мешаванд: 
 ++ob ва ob++ 
 Дар мисоли қаблӣ ҳолати пешвандии оператори як воҳид афзоиш 
 мавриди баҳс қарор ёфта буд. Наҳви пасвандии оператори мазкур бошад, 
 намуди зеринро дорад: 
 Complex operator ++(int unised); 
 Параметри unised дар функсия истифода бурда намешавад. Он танҳо ни- 
 шонае мебошад, ки барои гузоштани фарқият байни ҳолати пешвандӣ ва 
 пасвандӣ ба кор бурда мешавад. Дар қитъаи барномаи зерин тарзи истифодаи 
 ҳолати пасвандии оператори мазкур оварда шудааст: 
 ComplexComplex::operator++(intunised) { 
 Complex Z = *this; 
 Re++; 
 Im++; 
 return Z; 
 } 
 Дастури Complex Z=*this қимати ҷории амалвандро нигоҳ медорад. Бо 
 ёрии дастури return ин қимат баргардонида мешавад. Аз инҳо метавонем 
 мисоли -ро ба намуди зерин нависем. 
 Мисоли: 
 #include<iostream> 
 usingnamespace std; 
 classComplex { 
 float Re; 
 float Im; 
 public: 
 Complex() { 
 Im = Re =; 
 } 
 Complex(floata, floatb) { 
 Re = a; 
 Im = b; 
 } 
 Complexoperator +(Complexob); 
 Complexoperator =(Complexob); 
 Complexoperator ++(); 
 Complexoperator++(intunised); 
 void print(); 
 }; 
 ComplexComplex::operator +(Complexob) { 
 Complex z; 
 z.Re = Re + ob.Re; 
 z.Im = Im + ob.Im; 
 return z; 
 } 
 ComplexComplex::operator =(Complexob) { 
 Re = ob.Re; 
 Im = ob.Im; 
 return *this; 
 } 
 ComplexComplex::operator ++() { 
 Re++; 
 Im++; 
 return *this; 
 } 
 ComplexComplex::operator++(intunised) { 
 Complex Z = *this; 
 Re++; 
 Im++; 
 return Z; 
 } 
 voidComplex::print() { 
 if (Im>) 
 cout <<"z = "<< Re <<" + "<< Im <<"i"<< endl; 
 else 
 cout <<"z = "<< Re << Im <<"i"<< endl; 
 cout <<"**********"<< endl; 
 } 
 int main(intargc, char* argv[]) { 
 Complex a(., -.), b(-.,.), c; 
 cout <<"Adadi:"<< endl; 
 a.print(); 
 cout <<"Adadi:"<< endl; 
 b.print(); 
 c = a + b; 
 cout <<"Summai adadho:"<< endl; 
 c.print(); 
 cout <<"Qimatia dadi Z pesh az ijroi amali peshvandii 
 Increment: "<< endl; 
 ++c; 
 c.print(); 
 cout <<"Qimatia dadi Z pas az ijroi amali peshvandii 
 Increment: "<< endl; 
 c++; 
 c.print(); 
 system("pause"); 
 return; 
 } 
 Ба ҳамин монанд оператори як воҳид коҳиш низ сарборӣ карда мешаванд. 
 Сарбори гузоштани операторҳои мантиқӣ ва муносибат 
 Монанди дигар операторҳо операторҳои муносибат ва мантиқӣ (масалан 
 операторҳои «&&» ва «||») ва муносибат (масалан опе-раторҳои «==« ё «<«) 
 низ метавонанд сарборӣ карда шаванд. Тавре ки медонем, операторҳои мазкур
 яке аз қиматҳои true ё false бармегардонанд. Барои пурратар шинос шудан би-
 ёед, мисолеро дида мебароем, ки дар он операторҳои мазкур сарборӣ карда 
 шудаанд. 
 Мисоли: 
 #include<iostream> 
 usingnamespace std; 
 classComplex { 
 float Re; 
 float Im; 
 public: 
 Complex() { 
 Im = Re =; 
 } 
 Complex(floata, floatb) { 
 Re = a; 
 Im = b; 
 } 
 booloperator ==(Complexob); 
 booloperator >(Complexob); 
 Complexoperator =(Complexob); 
 void print(); 
 }; 
 ComplexComplex::operator =(Complexob) { 
 Re = ob.Re; 
 Im = ob.Im; 
 return *this; 
 } 
 boolComplex::operator==(Complexob) 
 { 
 if ((Re == ob.Re) && (Im == ob.Im)) 
 returntrue; 
 else 
 returnfalse; 
 } 
 boolComplex::operator >(Complexob) { 
 if ((Re>ob.Re) && (Im>ob.Im)) 
 returntrue; 
 else 
 returnfalse; 
 } 
 voidComplex::print() { 
 if (Im > ) 
 cout <<"z = "<< Re <<" + "<< Im <<"i"<< endl; 
 else 
 cout <<"z = "<< Re << Im <<"i"<< endl; 
 cout <<"**********"<< endl; 
 } 
 int main() 
 { 
 Complex a(., -.), b(-.,.), c; 
 cout <<"adadi a: "<< endl; 
 a.print(); 
 cout <<"adadi b: "<< endl; 
 b.print(); 
 if (a == b) 
 cout <<"Adadi a bo adadi b barobarast: "<< endl; 
 else 
 cout <<"Adadi a bo adadi b barobar nest: "<< endl 
 << endl; 
 if (a>b) 
 cout <<"Adadi a az adadi b kalonast:"<< endl; 
 else 
 cout <<"Adadi b az adadi a kalonast:"<< endl; 
 system("pause"); 
 return; 
 } 
 Сарборӣ намудани оператори дугонаи «-» 
 Барои сарборӣ кардани операторҳои дугона тартиби ҷойгиршавии амал- 
 вандҳо шарти зарурӣ мебошад. Дар сурати риоя накардани ин низом натиҷаи 
 зарурӣ ба даст намеояд. Аз нуқтаи назари риёзӣ медонем, ки қимати ибораи 
 «A-B» ба қимати ибораи «B-A» баробар намебошад. Аз ин ҷост, ки ҳангоми 
 сарборӣ гузоштан оператори мазкур дар тарафи рости он функсияи амалванди 
 даъвандшаванда навишта мешавад. Дар тарафи чапи оператор бошад, худи 
 амалванд бетағйир навишта мешавад. Дар барномаи зерин тарзи сарборӣ 
 намудани оператори «-» оварда шудааст. 
 #include<iostream> 
 usingnamespace std; 
 classComplex { 
 float Re; 
 float Im; 
 public: 
 Complex() { 
 Im = Re =; 
 } 
 Complex(floata, floatb) { 
 Re = a; 
 Im = b; 
 } 
 Complexoperator -(Complexob); 
 Complexoperator =(Complexob); 
 void print(); 
 }; 
 ComplexComplex::operator =(Complexob) { 
 Re = ob.Re; 
 Im = ob.Im; 
 return *this; 
 } 
 ComplexComplex::operator -(Complexob) 
 { 
 Complex z; 
 z.Re = Re - ob.Re; 
 z.Im = Im - ob.Im; 
 return z; 
 } 
 voidComplex::print() { 
 if (Im > ) 
 cout <<"z = "<< Re <<" + "<< Im <<"i"<< endl; 
 else 
 cout <<"z = "<< Re << Im <<"i"<< endl; 
 cout <<"**********"<< endl; 
 } 
 int main() 
 { 
 Complex a(., -.), b(-.,.), c; 
 cout <<"adadi a: "<< endl; 
 a.print(); 
 cout <<"adadi b: "<< endl; 
 b.print(); 
 c = a - b; 
 c.print(); 
 system("pause"); 
 return; 
 } 
 Сарборӣ намудани оператори зернависи массив «[]» 
 Оператори «[]» аз нуқтаи назари сарборигузорӣ дар забони С++ ҳамчун 
 оператори ягона шинохта шудааст. Аз ин рӯ, он метавонад дар функсия-аъзоҳо
 сарборӣ карда шавад. 
 Наҳви умумии сарборигузории оператори мазкур намуди зеринро дорад: 
 Навъ номи_class:: operator [] (int зернавис ) 
 { 
 //….. 
 } 
 Дар ин ҷо шарт нест, ки параметри формалии зернавис аз навъи int 
 бошад. Аз сабаби он ки функсия-аъзоoperator[]() онро ба сифати зернависи 
 массив истифода бурдааст, пас, ба намуди умумӣ ба сифати аргументи ин 
 функсия қимати бутун равон карда мешавад. 
 Мисоли.Сарборӣ намудани оператори зернависи массив. 
 #include<iostream> 
 usingnamespace std; 
 classMass{ 
 int n; 
 int *a; 
 public: 
 //Конструктори class 
 Mass(intn) { 
 a = newint[n]; 
 registerint i; 
 for (i =; i<n; i++) 
 a[i] = * i +; 
 } 
 //Сарборӣкарданиоператори [] 
 intoperator [](intk) { 
 return a[k]; 
 } 
 void show(intn) { 
 int i; 
 for (i =; i<n; i++) 
 cout << a[i] <<" "; 
 cout << endl; 
 } 
 }; 
 int main(){ 
 Mass ob(); 
 ob.show(); 
 cout << endl; 
 cout <<"Elementi shashum = "; 
 cout << ob[]<<endl; 
 system("pause"); 
 return; 
 } 
 Дар ин мисол бошад, classе бо номи Mass муаррифӣ гардидааст, ки 
 дорои як майдони навъи массив мебошад. Пас аз муаррификунии class 
 конструктор барои ба майдони массиви class бахшидани қимат даъват карда 
 шудааст. Баъд аз ин оператори []ба намуди зерин сарборӣ карда шудааст: 
 int operator [](int k) 
 { 
 return a[k]; 
 } 
 Бо ёрии методи show() қимати майдонҳои class ба чоп дода мешаванд. 
 Сарборӣ кардани оператори «()» 
 Оператори даъвати функсия«()» низ қобилияти сарборӣ шуданро дорад. 
 Ҳангоми сарборӣ кардани оператори мазкур ҳеҷ равиши нави даъвати функсия 
 пайдо намешавад, танҳо аргументҳо дар ин ҳолат метавонанд худсарона равон
 карда шаванд. Аргументҳо дар ин сурат низ метавонанд аз дилхоҳ навъи 
 стандартӣ бошанд. 
 Мисол. Сарборӣ намудани оператори (). 
 #include<iostream> 
 usingnamespace std; 
 classComplex { 
 float Re, Im; 
 public: 
 Complex() { 
 Re = Im =; 
 } 
 Complex(floata, floatb) { 
 Re = a; 
 Im = b; 
 } 
 Complexoperator ()(floatx, floaty); 
 void Show(); 
 }; 
 ComplexComplex::operator()(floatx, floaty) { 
 Complex Z; 
 Z.Re = Re + x; 
 Z.Im = Im + y; 
 return Z; 
 } 
 voidComplex::Show() { 
 if (Im>) 
 cout <<"Z="<< Re <<"+"<< Im << endl; 
 else 
 cout <<"Z="<< Re << Im << endl; 
 } 
 int main() { 
 Complex ob(., -), ob; 
 ob = ob(-,.); 
 ob.Show(); 
 system("pause"); 
 return; 
 } 
 Сарборӣ намудани операторҳо бо истифода аз функсияҳое, ки аъзои 
 Class намебошанд 
 Амали сарборӣ намудани операторҳоро метавон бо истифода 
 азфунксияҳое, ки аъзои Classs нестанд, иҷрокард. Мо ба чунин функсияҳо, ки
 функсияҳои дӯст мебошанд, аз мавзӯъҳои гузашта шинос мебошем. Дар 
 функсияҳои мазкур операторҳои «=«, «()», «[]», «->« наметавонанд,сар- 
 борӣкардашаванд. 
 Мисол. Сарборӣ кардани операторҳо бо истифода аз функсияҳои дӯст. 
 #include<iostream> 
 usingnamespace std; 
 classComplex { 
 float Re, Im; 
 public: 
 Complex() { Re = Im =; } 
 Complex(floata, floatb) { 
 Re = a; 
 Im = b; 
 } 
 friendComplexoperator +(Complexob, Complexob); 
 Complexoperator=(Complexob); 
 void Show(); 
 }; 
 Complexoperator +(Complexob, Complexob) { 
 Complex Z; 
 Z.Re = ob.Re + ob.Re; 
 Z.Im = ob.Im + ob.Im; 
 return Z; 
 } 
 voidComplex::Show() { 
 if (Im>) 
 cout <<"Z="<< Re <<" + "<< Im << endl; 
 else 
 cout <<"Z="<< Re << Im << endl; 
 } 
 ComplexComplex:: operator=(Complexob) { 
 Re = ob.Re; 
 Im = ob.Im; 
 return *this; 
 } 
 int main() { 
 Complex a(., -), b(-,.), c; 
 c = a + b; 
 c.Show(); 
 system("pause"); 
 return; 
 } 
 Сарборӣ намудани операторҳои «<<»ва«>>» 
 Монанди дигар операторҳо дар забони С++ операторҳои «<<»ва«>>», ки 
 дар дастурҳои дохилкунӣ ва хориҷкунӣ истифода мешаванд, қобилияти сар- 
 борӣ шуданро доранд. Барои сарборӣ намудани операторҳои мазкур басифати 
 навъ, навъи ҷараёнҳои «ostream» истифода бурда мешавад. Ҳоло иҷрои ин 
 амалро дар мисоли зерин дида мебароем. 
 Мисол. Сарборӣ намудани оператори хуруҷӣ. 
 #include<iostream> 
 usingnamespace std; 
 classComplex { 
 float Re, Im; 
 public: 
 Complex() { 
 Re = Im =; 
 } 
 Complex(floata, floatb) { 
 Re = a; 
 Im = b; 
 } 
 Complexoperator=(Complexob); 
 Complexoperator+(Complexob); 
 Complexoperator-(Complexob); 
 Complexoperator*(Complexob); 
 Complexoperator/(Complexob); 
 float RealRe() { 
 return Re; 
 } 
 float ImegIm() { 
 return Im; 
 } 
 }; 
 ComplexComplex::operator=(Complexob) { 
 Re = ob.Re; 
 Im = ob.Im; 
 return *this; 
 } 
 ComplexComplex::operator +(Complexob) { 
 Complex Z; 
 Z.Re = Re + ob.Re; 
 Z.Im = Im + ob.Im; 
 return Z; 
 } 
 ComplexComplex::operator -(Complexob) { 
 Complex Z; 
 Z.Re = Re - ob.Re; 
 Z.Im = Im - ob.Im; 
 return Z; 
 } 
 ComplexComplex::operator *(Complexob) { 
 Complex Z; 
 Z.Re = Re*ob.Re - Im*ob.Im; 
 Z.Im = Re*ob.Im + Im*ob.Re; 
 return Z; 
 } 
 ComplexComplex::operator /(Complexob) { 
 Complex Z; 
 Z.Re = (Re*ob.Re + Im*ob.Im) / (ob.Re*ob.Re + 
 ob.Im*ob.Im); 
 Z.Im = (Im*ob.Re - Re*ob.Im) / (ob.Re*ob.Re + 
 ob.Im*ob.Im); 
 return Z; 
 } 
 ostream&operator <<(ostream&out, ComplexZ) { 
 out<<"("<<Z.RealRe() <<","<<Z.ImegIm() <<"i)"; 
 returnout; 
 } 
 int main(intargc, char* argv[]) { 
 Complex a(., -), b(-,.), c; 
 c = a + b; 
 cout << a <<" + "<< b <<"="<< c << endl; 
 c = a - b; 
 cout << a <<" - "<< b <<"="<< c << endl; 
 c = a*b; 
 cout << a <<" * "<< b <<"="<< c << endl; 
 c = a / b; 
 cout << a <<" /"<< b <<"="<< c << endl; 
 system("pause"); 
 return; 
 } 
 Натиҷаи барнома: 
 (., -i)+ (-,.i)-> (., -.i) 
 (., -i)- (-,.i)-> (., -.i) 
 (., -i)* (-,.i)-> (., -i) 
 (., -i)/ (-,.i)-> (-., -.i) 
 Тавре ки дидем, дар ин мисол қариб, ки ҳамаи мисолҳои пешина гирд 
 оварда шудаанд. Яке аз хусусиятҳои фарқкунандаи ин мисол аз он иборат аст,
 ки дар инҳо амалгари хориҷкунӣ ба сурати зерин сарборӣ карда шудааст: 
 ostream& operator <<(ostream& out, Complex Z) 
 { 
 out<<«(«<<Z.RealRe() <<«, «<<Z.ImegIm() <<«i)»; 
 return out; 
 } 
 Дар ин қисмати барнома тағйирёбандае бо номи out аз навъи ҷараёни 
 ostream муаррифӣ карда шудааст. Пас аз хориҷ намудани қиматҳои қисми 
 ҳақиқӣ ва мавҳуми адади комплексӣ бо ёрии дастури return натиҷаи 
 тағйирёбандаи муаррифишуда баргардонида шудааст. 
 Қисмати боқимондаи барнома шояд ба хонандагони гиромии мо фаҳмо 
 бошад, аз ин рӯ, ба шарҳи он намепардозем. 
 Дар охири ин боб барои боз ҳам фаҳмотар шудан мисолеро дида мебароем. 
 Мисол: Классе нависед, ки дар он ҳамаи амалиёт ба матрисаҳо иҷро карда 
 шаванд, ба монанди: 
 a) Ҷамъи матритса бо матритса; 
 b) Тарҳи матритса аз матритса; 
 c) Зарби матритса бо матритса; 
 d) Зарби матритса бо адад. 
 Инчунин бо ёриии ин класс қимати ифодаи зерин ҳисоб карда шавад. 
 (A*+B)*E 
 Қайд. Дар ин ҷо Е матритсаи воҳидӣ мебошад. 
 #include<iostream> 
 usingnamespace std; 
 #definen 
 classMatrix { 
 private: int matr[n][n]; 
 public: 
 int&operator()(inta, intb); 
 Matrixoperator +(Matrix); 
 Matrixoperator -(Matrix); 
 Matrixoperator *(Matrix); 
 Matrixoperator *(intNum); 
 void Enter(); 
 void Show(); 
 }; 
 ostream&operator<<(ostream&out, Matrixmatrix) { 
 out<<"\n + ------------------------ - +\n"; 
 for (int i =; i<n; i++) { 
 for (int j =; j<n; j++) { 
 out.width(); 
 out<<matrix(i, j)<<" | "; 
 } 
 out<<" \n "; 
 } 
 out<<"\n + ------------------------ - +\n"; 
 returnout; 
 }; 
 int&Matrix::operator ()(inta, intb) { 
 return matr[a][b]; 
 }; 
 MatrixMatrix::operator + (Matrixmatrix) { 
 Matrix TempMatrix; 
 for (int i =; i<n; i++) 
 for (int j =; j<n; j++) 
 TempMatrix(i, j) = (*this) (i, j) + matrix(i, 
 j); 
 return TempMatrix; 
 }; 
 MatrixMatrix::operator - (Matrixmatrix) { 
 Matrix TempMatrix; 
 for (int i =; i<n; i++) 
 for (int j =; j<n; j++) 
 TempMatrix(i, j) = (*this) (i, j) - matrix(i, 
 j); 
 return TempMatrix; 
 }; 
 MatrixMatrix::operator * (intNum) { 
 Matrix TempMatrix; 
 for (int i =; i<n; i++) 
 for (int j =; j<n; j++) 
 TempMatrix(i, j) = (*this) (i, j)*Num; 
 return TempMatrix; 
 }; 
 MatrixMatrix::operator * (Matrixmatrix) { 
 Matrix TempMatrix; 
 for (int i =; i<n; i++) 
 for (int j =; j<n; j++) { 
 TempMatrix(i, j) =; 
 for (int k =; k<n; k++) 
 TempMatrix(i, j) += (*this) (i, k) + ma- 
 trix(k, j); 
 } 
 return TempMatrix; 
 }; 
 int main(intargc, char* argv[]) { 
 Matrix A, B, E; 
 for (int i =; i<n; i++) 
 for (int j =; j<n; j++) 
 if (i == j) 
 E(i, j) =; 
 else 
 E(i, j) =; 
 for (int i =; i<n; i++) 
 { 
 for (int j =; j<n; j++) { 
 A(i, j) = i + j; 
 B(i, j) = rand() %; 
 } 
 } 
 cout <<"\n"<<"A="<< A << endl; 
 cout <<"\n"<<"B="<< B << endl; 
 cout <<"\n"<<"E="<< E << endl; 
 cout <<"\n"<<"A+B="<< A+B << endl; 
 cout <<"\n"<<"A*B="<< A * B << endl; 
 cout <<"\n"<<"( * A + B)*E="<< (A * + B)*E << endl; 
 system("pause"); 
 return; 
 } 
 Саволҳо барои мустаҳкамкунӣ 
 дорад? 
 даъвати функсия ба вуҷуд меояд? 
 БОБИ. ИСЛОҲИ ХАТОГИҲО ВА КОРКАРДИ ҲОЛАТҲОИ 
 ИСТИСНОӢ 
 Муқаддима 
 Ҳангоми навиштани барнома, гоҳо барнома иҷро намешавад ва ё 
 натиҷаи дилхоҳ дода наметавонад, яъне он ба хатогӣ рӯ ба рӯ мешавад. Аз ин
 ҷо ба барноманавис лозим мешавад, ки хатогиҳои бавуқуъомадаро ислоҳ 
 намояд. Хатогиҳо аслан се хел мешаванд: 
 Хатогиҳои наҳвӣ ҳангоми нодуруст навиштани ягон қисмати коди барнома, ба 
 монанди нагузоштани нуқта, вергул дар охири ҳар сатр, нодуруст пайваст кар-
 дани китобхона ва ғайра. 
 Дар вақти ба амал омадани ин навъ хатогиҳо пайғоми муносибе чоп ме- 
 шавад ва ё барнома иҷро намешавад. Ислоҳи ин навъ хатогиҳо душвор наме- 
 бошад. 
 Хатогиҳои мантиқӣ бошанд, хатогиҳои ҳастанд, ки дар вақти ба вуҷуд 
 омадани онҳо пайғоми чоп намегардад, танҳо онҳоро аз натиҷаи барнома му- 
 шоҳида кардан мумкин аст. Дигархелтар карда гӯем, дар вақти ба- вуҷудоии 
 ин навъ хатогиҳо барнома иҷро мегардад ва натиҷаи дилхоҳро намедиҳад. Ис-
 лоҳи ин навъ хатогиҳо душвор буда, вуҷуди онҳоро дар натиҷаи гузаронидани
 санҷиш фаҳмидан мумкин аст. 
 Хатогиҳои техникӣ аз мошина ё дастгоҳ вобастагӣ доранд. Хатогиҳои 
 мазкурро мутахассисони техникӣ бартараф мекунанд. Дар поён якчанд хато- 
 гиҳоеро, ки ҳангоми навиштани як барнома ба вуҷуд меоянд, мухтасаран дида
 мебароем. 
 Ҳассосият ба регистр 
 Тавре қаблан низ тазаккур дода будем, забони С++ ба регист ҳассос 
 буда, байни ҳарфҳои калон ва хурд фарқ мегузорад. Бахусус дар номи классҳо,
 функсияҳо, тағйирёбандаҳо ва ғайра. Масалан, бигзор, шумо тағйирёбандаеро
 бо номи h муаррифӣ карда, ҳангоми истифодабари аз H к, дар ин ҳолат хатогӣ
 ба амал меояд. 
 Мисол. 
 #include<iostream> 
 usingnamespace std; 
 int main() { 
 int h, y; 
 cout <<"Qimati h-ro vorid kuned\n"; 
 cin >> h; 
 y = * H; 
 cout << y; 
 return; 
 } 
 Агар барномаро иҷро карданӣ шавем, пайғоми «Undefined sym-bol ‘H’ – 
 рамзи H номуайян аст» пайдо мегардад. 
 Сарфи назар кардани нуқта вергул дар охири сатрҳо 
 Ҳар сатр дар забони С++ бояд ба аломати нуқтавергул ба итмом расад. 
 Баъзан ҳангоми сарфи назар кардани ин аломат барнома ба хатогӣ рӯ ба рӯ 
 мешавад. 
 Мисол. 
 #include<iostream> 
 usingnamespace std; 
 int main() { 
 int h, y; 
 cout <<"Qimati h-ro vorid kuned\n"; 
 cin >> h; 
 y = * h; 
 cout << y 
 return; 
 } 
 Агар барномаро иҷро карданӣ шавем, пайғоми “Statement missing– 
 “Нуқтавергул дар дастур сарфи назар карда шудааст” пайдо мегардад. 
 Навиштани Main ба ҷои main дар функсияи асосӣ 
 Ҳангоми ба ҳарфи калон навиштани номи функсияи аслӣ (main) барнома 
 низ иҷро нагардида, ба хатогӣ рӯ ба рӯ мешавад. Дар бисёр компиляторҳои 
 С/С++ номи функсияи аслӣ ба намуди пешфарз вуҷуд дорад, вале агар фаразан
 дар компиляторе вуҷуд надошта бошад ва ё истифодабаранда хоҳад, ки худаш 
 функсияи аслиро нависад, бояд ки огоҳ бошад, то ин ки баъд ин хатогӣ роҳ 
 надиҳад. 
 Мисол. 
 #include<iostream> 
 usingnamespace std; 
 int Main() { 
 int h, y; 
 cout <<"Qimati h-ro vorid kuned\n"; 
 cin >> h; 
 y = * h; 
 cout << y; 
 return; 
 } 
 Агар барномаро иҷро карданӣ шавем, пайғоми “[Linker Error] Unresolved
 external referenced–нишонагари хориҷӣ иҷозат дода нашудааст” пайдо 
 мегардад. 
 Сарфи назар кардани ишорагар ба номи библиотека 
 Қариб ҳамаи объектҳо, операторҳо ва функсияҳои стандартӣ, ки дар 
 забони С++ истифода бурда мешаванд, дар файлҳои беруна, ки китобхона ном 
 доранд, нигоҳ дошта мешаванд. Масалан, барои дохил ва хориҷ кардани 
 маълумотҳо китобхонаи <iostream>, барои истифода аз функсияҳои 
 математикӣ китобхонаи <math> ва ғайра истифода бурда мешаванд. Барои он 
 ки функсия ё объектҳое, ки дар китобхона мавҷуданд, ба барномасоз дастрас
 бошанд, бояд ки пас аз номи китобхона нишонаи “.h” ё сатри using namespace
 std ва ё пеш аз истифодаи ҳар объект std:: номи объект навишта шавад. Баъзе
 аз донишҷӯён аз фаромӯшӣ ё таҷрибаи кам доштанашон ин чизҳоро сарфи 
 назар мекунанд ва дар натиҷа барнома ба хатогӣ рӯ ба рӯ мешавад. 
 Мисол. 
 #include<iostream> 
 int main() { 
 cout <<"Barnameai nahustini man dar C++\n"; 
 return; 
 } 
 Агар барномаро иҷро карданӣ шавем, пайғоми “undefined symbol cin – 
 Рамзи cin муаррифӣ нашудаааст“ пайдо мегардад. 
 Сарфи назар кардани қавс дар дастури if 
 Дар забони C++ ибораи мантиқии дастури if дар дохили қавс навишта 
 мешавад. Ашхосе, ки дар забони Vb ё Delphi/Pascal барнома навишта, одат 
 кардаанд ё ашхосе, ки таҷрибаи барноманависӣ надоранд, баъзан вақт 
 навиштани қавсро дар дастури шартӣ сарфи назар мекунанд. Аз ин рӯ, барнома
 иҷро нагардида, ба хатогӣ рӯ ба рӯ мешавад. Мисол: 
 #include<iostream> 
 usingnamespace std; 
 int main() { 
 int x, y, max; 
 cout <<"x = "; cin >> x; 
 cout <<"y = "; cin >> y; 
 if x>y 
 max = x; 
 else 
 max = y; 
 cout <<"max = "<< max; 
 return; 
 } 
 Агар барномаро иҷро карданӣ шавем, пайғоми “if statement missing- 
 кушодани қавс дар дастури if сарфи назар шудааст“ пайдо мегардад. 
 Истифодаи оператори бахшиш дар ҷойи оператори муқоисакунӣ 
 Оператори муқоисакунӣ асосан дар дохили дастурҳои шартӣ ба кор 
 бурда мешавад. Баъзе аз фаромӯшӣ ба ҷойи оператори муқоисакунӣ (таносуб) 
 оператори бахшишро истифода мебаранд. Биёед, аввал ба ин операторҳо 
 шинос мешавем. 
 Оператори бахшиш барои бахшидани қимате ба тағйирёбанда истифода 
 бурда мешавад. 
 Мисол. int y=; 
 Ин ибора тағйирёбандаи у ро аз навъи бутун муаррифӣ намуда, ба он 
 қимати -ро мебахшад. 
 Оператори муқоисакунӣ бошад, барои санҷиши шарт ба кор меравад. 
 Мисол. 
 if( a==) 
 Агар қимати а айнан ба баробар бошад.Мисол: 
 #include<iostream> 
 usingnamespace std; 
 int main() { 
 int a; 
 cout <<"a = "; cin >> a; 
 if (a = ) 
 cout <<"Qimati a ba barobar ast.\n"; 
 return; 
 } 
 Агар барномаро иҷро кардани шавем, пайғоми “Possibly incorrect 
 assignment-муқоисакунии ноқулай“ пайдо мегардад. 
 Сарфи назар кардани қавсҳои системавӣ 
 Яке аз хусусиятҳои С дар он аст, ки бояд миқдори қавсҳои системавии 
 кушодашуда ба миқдори қавсҳои системавии басташуда баробар бошанд, яъне 
 ҳар қавсе, ки кушода шуд, бояд ки маҳкам гардад. Дар сурати баробар набудан
 барнома ба хатогӣ рӯ ба рӯ мешавад. 
 Мисол. 
 #include<iostream> 
 usingnamespace std; 
 int max(inta, intb) { 
 returna>b? a: b; 
 int main() { 
 int x, y; 
 cout <<"x = "; cin >> x; 
 cout <<"y = "; cin >> y; 
 cout <<"max("<< x <<","<< y <<") = "<< max(x, y); 
 return; 
 } 
 Агар барномаро иҷро карданӣ шавем, пайғоми “Compound sta-tement 
 missing }-оператори мураккаби қавси сиcтемавии маҳкамкунӣ надорад. “ 
 пайдо мегардад. 
 Сарфи назар кардани навъ барои функсия 
 Ҳар функсияе, ки барномасоз муаррифӣ мекунад, бояд дорои навъ 
 бошад. Дар сурати нишон надодани навъ, барнома ба хатогӣ рӯ ба рӯ мешавад.
 Навъи функсия инчунин бояд ба навъи қимат баргардонидани функсия 
 мувофиқат кунад, дар сурати мувофиқат накар-дан низ хатогӣ ба амал 
 меояд.Мисол. 
 #include<iostream> 
 usingnamespace std; 
 int max(int a, int b) { 
 return a>b? a: b; 
 print(); //Пешнамунасозиифунксия 
 int main() { 
 print(); 
 system("pause"); 
 return; 
 } 
 print() { 
 cout <<"Barnameai nahustini man dar C++"<< endl; 
 } 
 Агар барномаро иҷро карданӣ шавем, пайғоми “Function should return a
 value-функсия бояд барои қимат баргардонидан навъ дошта бошад“ пайдо 
 мегардад. 
 Нодуруст қимат баргардонидани функсия 
 Тавре ки қайд кардем, бояд ки ба функсия навъи он қиматеро, ки 
 бармегардонад, нишон дода шавад. Агар навъи функсия ба навъи қимате, ки 
 бармегардонад, мувофиқат накунад, он гоҳ барнома ба хатогӣ рӯ ба рӯ 
 мешавад. Масалан, бигзор функсияе аз навъи бутун муаррифӣ гардад ва дар 
 дастури return, ки дар дохили функсия аст, қимати сатрӣ навишта шавад. 
 Мисол: 
 #include<iostream> 
 usingnamespace std; 
 int test() { 
 return"C++"; 
 } 
 int main() { 
 cout << test(); 
 system("pause"); 
 return; 
 } 
 Тавре ки дида шуд, функсия аз навъи бутун муаррифӣ гардидааст ва дар
 дастури return бошад, калимаи «C++» навишта шудааст. Барои ин пайғоми 
 “cannot convert-табдилдиҳӣ имконнопазир аст” пайдо мегардад. 
 Дар функсияҳои навъи холӣ истифода намудани дастури return 
 Функсияҳое, ки аз навъи холи муаррифӣ мегарданд, дастури return 
 наметавонад, дар онҳо амалеро иҷро кунад,аз ин рӯ истифодаи он ғайриимкон
 аст. Фаразан агар навомӯзе онро дар ин навъ функсияҳо истифода кунад, 
 барнома ба хатогӣ рубарӯ мешавад. 
 Мисол. 
 #include<iostream> 
 #include<cmath> 
 usingnamespace std; 
 void test(floata) { 
 return sqrt(a); 
 } 
 int main() { 
 float a; 
 cin >> a; 
 cout << test(a); 
 system("pause"); 
 return; 
 } 
 Ҳангоми иҷроиши барнома пайғоми “Cannot return a value-қимат 
 баргардонидан имконнопазир аст” пайдо мегардад. 
 Сарфи назар кардани оператори return дар функсияҳое, ки қимат 
 бармегардонанд 
 Ҳар як функсияеро, ки барномасоз муаррифӣ мекунад (ба ғайр аз 
 функсияи навъи void), бояд ки ба функсияи аслӣ қиматеро баргардонанд. 
 Барои баргардонидани қимат аз оператори return истифода бурда мешавад. 
 Сарфи назар кардани оператори мазкур барномаро ба хатогӣ рӯ ба рӯ 
 мегардонад. 
 Мисол: 
 #include<iostream> 
 usingnamespace std; 
 int max(inta, intb) { 
 int m; 
 m = a>b? a: b; 
 } 
 int main() { 
 int x, y; 
 cout <<"x = "; cin >> x; 
 cout <<"y = "; cin >> y; 
 cout <<"max("<< x <<", "<< y <<")="<< max(x, y); 
 system("pause"); 
 return; 
 } 
 Ҳангоми иҷроиши барнома пайғоми “Function should return a value- 
 функсия бояд қимат баргардонад” пайдо мегардад. 
 Хатогӣ ҳангоми сарборӣ ниҳодан ба функсияҳо 
 Тавре ки қаблан низ қайд карда будем, ҳангоми муаррифӣ намудани 
 функсияҳо метавонем, якчанд функсияро, ки аргументҳои онҳо аз ҷиҳати 
 миқдор ва навъ аз ҳамдигар фарқ карда, инчунин навъи қиматашон низ 
 гуногун аст, зери як ном муаррифӣ кунем. Ин амалро сарборигузории функсия
 меноманд. 
 Мисол: 
 #include<iostream> 
 usingnamespace std; 
 int max(inta, intb) { 
 returna>b? a: b; 
 } 
 float max(floata, floatb) { 
 returna>b? a: b; 
 } 
 int main(intargc, char* argv[]) { 
 int a, b; 
 float x, y; 
 cout <<"Du adadi int dokhil kuned:\n"; 
 cin >> a >> b; 
 cout <<"Du adadi float dokhil kuned:\n"; 
 cin >> x >> y; 
 cout <<"max("<< a <<","<< b <<")="<< max(a, b); 
 cout << endl; 
 cout <<"max("<< x <<","<< y <<")"<< max(x, y); 
 system("pause"); 
 return; 
 } 
 Агар рафту ду функсияеро бо як ном муаррифӣ кунем, ки дар он 
 қонунияти сарборигузорӣ риоя карда нашавад, барнома ба хатогӣ рӯ ба рӯ 
 мешавад. 
 Мисол: 
 #include<iostream> 
 usingnamespace std; 
 int max(inta, intb) { 
 returna>b? a: b; 
 } 
 float max(inta, intb) { 
 returna>b? a: b; 
 } 
 int main(intargc, char* argv[]) { 
 int a, b; 
 int x, y; 
 cout <<"Du adadi int dokhil kuned:\n"; 
 cin >> a >> b; 
 cout <<"Du adadi int dokhil kuned:\n"; 
 cin >> x >> y; 
 cout <<"max("<< a <<","<< b <<")="<< max(a, b); 
 cout << endl; 
 cout <<"max("<< x <<","<< y <<")"<< max(x, y); 
 system("pause"); 
 return; 
 } 
 Ин мисол низ чун ҳамон мисоли гузашта буда, фарқияташ аз он иборат 
 аст, ки дар ин ҷо ҳарду функсия бо як навъ муаррифӣ шудаанд. Ҳангоми 
 иҷроиши ин барнома пайғоми “body has already been defined for function- 
 функсия такроран муаррифӣ шудааст” пайдо мегардад. 
 Хатогӣ дар пайваст кардани китобхонаи математикӣ 
 Дар забони С++ барои истифода бурдани функсияҳои математикӣ бояд 
 ки китобхона <cmath> пайваст карда шавад. Дар сурати пайваст накардани он,
 агар аз функсияҳои математикӣ истифода бурда шавад, барнома ба хатогӣ рӯ 
 ба рӯ мешавад. 
 Мисол. 
 #include<iostream> 
 usingnamespace std; 
 int main() { 
 float x, y; 
 cin >> x; 
 y = sqrt(x); 
 cout << y; 
 system("pause"); 
 return; 
 } 
 Ҳангоми иҷроиши барнома пайғоми зерин пайдо мешавад: 
 “Call to undefined function ‘sqrt’-даъват дар функсияи муаррифинашуда карда
 шудааст.” 
 Хатогиҳои ҳангоми иҷроиш ва мантиқӣ 
 Хатогиҳое, ки то ҳоло мавриди баррасӣ қарор додем, хатогиҳои наҳвӣ 
 буданд. Ин навъ хатогиҳо ба чашми барномасоз айён буда, ислоҳ намудани 
 онҳо хеле осон аст. Илова бар ин, хатогиҳои дигаре низ вуҷуд доранд, ки 
 хатогиҳои вақти иҷроиш “runtime error” ном доранд. Мутаассифона, ин навъ 
 хатогиҳо то иҷро гардидани барнома аён намегарданд ва пас аз иҷро намудан
 барномаро маҳкам мекунанд. Агар барнома дар диск сабт нашуда бошад, аз 
 байн меравад. Хатогиҳои дигар ин хатогиҳои мантиқӣ “logic errors” 
 мебошанд. Хатогиҳои мазкур ба маҳкам кардани барнома намеоранд. Биёед, 
 дар якҷоягӣ хатогиҳои навъи мазкурро дида мебароем. 
 Сарфи назар кардани қимати аввала бахшидан ба тағйирёбандаҳо 
 Тағйирёбандаҳои шуморанда (счётчик) бояд, ки дорои қимати аввала 
 бошанд. Дар сурати надоштани қимати аввала метавонанд барномаро ба 
 хатогӣ рӯ ба рӯ созанд. Тағйирёбандаҳои мазкур аслан дар дастурҳои даврӣ 
 ба кор бурда мешаванд. 
 Мисол: 
 #include<iostream> 
 usingnamespace std; 
 int main() { 
 int s =, i, n; 
 cin >> n; 
 while (i <= n) { 
 s += i; 
 i++; 
 } 
 cout << s; 
 system("pause"); 
 return; 
 } 
 Пас аз иҷрои барнома қимати s= чоп мешаваду халос. Ин маънои онро 
 дорад, ки ҳар тағйирёбанда дар забони С/С++ ҳангоми муаррификунӣ 
 қиматеро вобаста аз навъ ба намуди пешфарз ба худ қабул мекунад. 
 Сарфи назар кардани оператори break дар сохтори switch 
 Оператори break оператори охирин дар сохтори switch ба кор рафта, 
 барои сарфи назар кардани дастурҳои боқимонда, дар сурати қимати true қабул
 кардани оператори case ба кор меравад. Баъзе навомӯзон оператори мазкурро
 сарфи назар мекунанд. Аз ин рӯ, ба барнома лозим мешавад, ки ҳамаи 
 шартҳоро санҷад. Ин амал бошад, кори барномаро хеле суст мекунад ва баъзан
 қимати дилхоҳ намедиҳад. 
 Мисол. Барномаи зерин барои муайян намудани баҳои хонандагон ба 
 кор рафта, аз пайғомҳои зерин танҳо он сатреро пешниҳод мекунад, ки агар ба
 қимати n мувофиқат кунад, масалан, ҳангоми n= будан пайғоми Chor ро 
 мебарорад. 
 #include<iostream> 
 usingnamespace std; 
 int main() { 
 int n=; 
 switch (n) { 
 case: cout <<"Du"<< endl; 
 break; 
 case: cout <<"Se"<< endl; 
 break; 
 case: cout <<"Chor"<< endl; 
 break; 
 case: cout <<"Panj"<< endl; 
 break; 
 default: 
 cout <<"Error!"<< endl; 
 break; 
 } 
 system("pause"); 
 return; 
 } 
 Агар дар ин барнома оператори break сарфи назар карда шавад, тамоман
 натиҷаи дигар пайдо мешавад. 
 #include<iostream> 
 usingnamespace std; 
 int main() { 
 int n=; 
 switch (n) { 
 case: cout <<"Du"<< endl; 
 case: cout <<"Se"<< endl; 
 case: cout <<"Chor"<< endl; 
 case: cout <<"Panj"<< endl; 
 default: 
 cout <<"Error!"<< endl; 
 } 
 system("pause"); 
 return; 
 } 
 Пас аз иҷроиши барнома пайғомҳои зерин пайдо мешаванд. 
 Chor 
 Panj 
 Error! 
 Тақсим ба нол 
 Хатогии дигар дар C++ тақсим ба нол мебошад. Яъне бигзор ду адад 
 дода шуда бошад ва талаб карда шавад, ки адади якумро бо дувум тақсим 
 кунед. Ин амал дар сурате иҷро мешавад, ки агар адади дувум набошад. 
 Баъзан дар барноманависӣ ба ин хатогӣ рӯ ба рӯ шудан мумкин аст. 
 Мисол: 
 #include<iostream> 
 usingnamespace std; 
 int main() { 
 float a =, b =, x; 
 x = -b / a; 
 cout <<"x="<< x << endl; 
 system("pause"); 
 return; 
 } 
 Пас аз иҷро намудани барнома пайғоми зерин пайдо мегардад: 
 Аз реша баровардани адади манфӣ 
 Решаи квадратӣ аз адади додашуда ба ададе баробар аст, ки агар онро ба
 худаш зарб кунем, адади дар таҳти решабуда ҳосил шавад. 
 Масалан, решаи адади ба баробар аст, чунки *= мешавад. 
 Фаразан агар гуфта шавад, ки решаи ба чӣ баробар мешавад? Решаи ҳақиқӣ 
 аз ин адад вуҷуд надорад, чунки дар майдони ададҳои ҳақиқӣ ададе ёфт 
 намешавад, ки агар онро ба худаш зарб кунем, адади ҳосил шавад. Дар 
 барноманависӣ баъзан вақт ба ин хатоги рӯ ба рӯ шудан мумкин аст. 
 Мисол: 
 #include<iostream> 
 #include<cmath> 
 usingnamespace std; 
 int main() { 
 float a = -, x; 
 x = sqrt(a); 
 cout <<"x="<< x << endl; 
 system("pause"); 
 return; 
 } 
 Пас аз иҷроиши ин барнома пайғоми зерин пайдо мешавад: sqrt: 
 «DOMAIN error nan» 
 Ислоҳи хатогиҳо 
 Барои устувории барнома бояд ки дар барнома ислоҳи хатогиҳо низ 
 пешбинӣ шавад. Хатогиҳои компилятор хеле сода буда, ислоҳи онҳо низ осон 
 мебошад. Хатогиҳои вақти иҷроиш вобаста аз система мебошанд. Барои 
 ислоҳи хатогиҳои мантиқӣ бошад, бояд пеш аз амалиёти иҷромешуда шарт 
 гузошта шавад. 
 Мисол. 
 #include<iostream> 
 usingnamespace std; 
 int main() { 
 float a =, b =, x; 
 if (a == ) { 
 cout <<"Taqsim bo sifr mumkin nest!"<<endl; 
 } 
 else { 
 x = -b / a; 
 cout <<"x="<< x << endl; 
 } 
 system("pause"); 
 return; 
 } 
 Ин роҳ метавонад аз воқеъ шудани хатогӣ пешгирӣ кунад, вале агар дар
 чанд ҷойи як барнома лозим бошад, ки аз вуқуъи хатогиҳо пешгирӣ карда 
 шаванд, ин амал камтар душвортар мегардад, зеро барои ин лозим аст, ки дар
 чанд ҷойи барнома як нусха аз коди ислоҳи хатогӣ навишта шавад. Барои 
 камтару хубтар ва саҳеҳтар пешгирӣ кардани хатогиҳо аз блоки try-catch 
 истифода мекунанд. 
 Моҳияти ин блок чунин аст: дар дохили блоки try шарт санҷида 
 мешавад, агар дар он ҷо зарурати ислоҳи хатогӣ пеш ояд, қисми барномаи 
 дохили блоки catch иҷро карда мешавад. 
 Наҳви умумии коркарди хатогиҳо дар забони C++ ба сурати зерин аст: 
 try { 
 … 
 throw ибора 
 } 
 сatch(навъи тағйирёбанда) 
 { 
 // тани коркард 
 } 
 [сatch …] мумкин аст, ки дигар навъ бошад 
 Биёед, ба таври мухтасар ҳар яке аз ин блокҳоро алоҳида- алоҳида дида
 бароем: 
 Блоки try 
 Тавре ки гуфта будем, дар дохили блоки мазкур мавҷудияти хатогӣ 
 санҷида мешавад. Дар дохили ин блок функсияҳо метавонанд низ даъват 
 шаванд. Тарзи умумии итстифодаи блоки мазкур намуди зеринро дорад: 
 try { 
 … 
 } 
 Блоки catch 
 Блоки catch метавонад якчандто хатогиҳои навъҳои гуногунро нигоҳ 
 дорад. Тарзи истифодаи умумии он ба сурати зерин аст: 
 try { 
 … 
 } 
 catch (int n) 
 { // ба даст овардани ё хориҷ кардани хатогиҳои навъи 
 бутун 
 …. 
 } 
 catch (char *str) { // ба даст овардани хатогии навъи 
 рамзӣ 
 … 
 } 
 catch (…) 
 { // ба даст овардан ё хориҷ кардани хатогиҳои дилхоҳ 
 навъ 
 … 
 } 
 Оператори throw 
 Барои ҳосил ё пайдо кардани хатогиҳо аз оператори throw истифода 
 бурда мешавад. Оператори мазкур метавонад, дорои амалванд ё бе амалванд 
 бошад. Амалванди он метавонад, қимати тағйирёбандаи дилхоҳ навъи 
 стандартӣ бошад. 
 Намунаи ҳалли мисолҳо 
 Мисоли. Тартиби иҷроиши блокҳои try / catch. 
 #include<iostream> 
 usingnamespace std; 
 int main() 
 { 
 int x = -; 
 cout <<"Pesh az try \n"; 
 try { 
 cout <<"Dohili try \n"; 
 if (x < ) 
 { 
 throw x; 
 cout <<"Pesh az throw (Hej vakt ijro naes- 
 havad) \n"; 
 } 
 } 
 catch (int x) { 
 cout <<"Holati istisnoi korkard karda shud \n"; 
 } 
 cout <<"Pas az catch (Ijro meshavad) \n"; 
 return; 
 } 
 Натиҷаи барнома: 
 Pesh az try 
 Dohili try 
 Pesh az throw (Hej vakt ijro naeshavad) 
 Holati istisnoi korkard karda shud 
 Pas az catch (Ijro meshavad) 
 Мисоли. Блокӣ махсуси catch бо номи «catch all» catch (…), мавҷуд аст, ки
 барои ба даст овардани ҳама намуд хатогиҳо истифода бурда мешавад. Дар 
 мисоли зерин ба сифати намуна int ҳамчун ҳолати истисноӣ даъват карда 
 шудааст, аммо барои int нет блоки catch мавҷуд намебошад, бинобар ин, блоки
 catch (…) иҷро мегардад. 
 #include<iostream> 
 usingnamespace std; 
 int main() 
 { 
 try { 
 throw; 
 } 
 catch (char *excp) { 
 cout <<"Ba dast ovardan "<< excp; 
 } 
 catch (...) { 
 cout <<"Holati istisnoi ba namudi peshfarz\n"; 
 } 
 return; 
 } 
 Натиҷаи барнома: Holati istisnoi ba namudi peshfarz. 
 Мисоли. Ба таври ноошкор табдидиҳии типҳо барои типҳои стандартӣ 
 ба вуҷуд намеояд. Дар мисоли зерин ба таври ноошкор тағйирёбандаи «а» ба 
 типи int табдил дода шудааст. 
 #include<iostream> 
 usingnamespace std; 
 int main() 
 { 
 try { 
 throw'a'; 
 } 
 catch (int x) { 
 cout <<"Ba dast ovardan "<< x; 
 } 
 catch (...) { 
 cout <<" Holati istisnoi ba namudi peshfarz!\n"; 
 } 
 return; 
 } 
 Натиҷа: Holati istisnoi ba namudi peshfarz. 
 Мисоли. Агар ҳолати истисноӣ ба амал омада, бартараф карда 
 нашавад, барнома номуваффақона корашро ба анҷом мерасонад. Масалан, дар 
 барномаи зерин символ ба даст оварда шуда, блоки catch барои ба даст 
 овардани символ мавҷуд нест. 
 #include<iostream> 
 usingnamespace std; 
 int main() 
 { 
 try { 
 throw'a'; 
 } 
 catch (int x) { 
 cout <<"Ba dast ovardan "; 
 } 
 return; 
 } 
 Натиҷа: 
 Мисоли. Дар муқоиса бо Java, дар C ++ ҳамаи ҳолатҳои истисноӣ 
 тафтиш карда намешаванд. Компилятор коркард шудан ё нашудани ҳолати 
 истисноиро тафтиш намекунад. Масалан, дар С++ наметавон ҳангоми 
 муаррифии функсия ҳамаи ҳолатҳои истисноии имконпазирро нишон дод. 
 Барномаи зерин нағз кор мекунад, аммо дар сигнаураи функсияи fun () бояд 
 ҳамаи ҳолатҳои истисноии коркарднашаванда ҷой дошта бошанд. 
 #include<iostream> 
 usingnamespace std; 
 void fun(int *ptr, intx) 
 { 
 if (ptr == NULL) 
 throwptr; 
 if (x == ) 
 throwx; 
 } 
 int main() 
 { 
 try { 
 fun(NULL, ); 
 } 
 catch (...) { 
 cout <<"Ba dast ovardani holathoi istisnoi az 
 fun()"; 
 } 
 return; 
 } 
 Мисоли. Дар C ++ блокҳои try-catch метавонанд дохили ҳам бошанд. 
 Илова бар ин, тавассути «throw» аз нав коркард карда шаванд. 
 #include<iostream> 
 usingnamespace std; 
 int main() 
 { 
 try { 
 try { 
 throw; 
 } 
 catch (int n) { 
 cout <<"Handle Partially "; 
 throw; //Re-throwing an exception 
 } 
 } 
 catch (int n) { 
 cout <<" Handle remaining "; 
 } 
 return; 
 } 
 Натиҷа: Handleremaining 
 Илова бар ин, бо истифода аз «throw» функсия метавонад, функсияро 
 даъват кунад. 
 Мисоли. Ҳангоми қайд намудани ҳолати истисноӣ ҳамаи объектҳои 
 дар дохили блоки try сохташуда то ба блоки catch равон кардан, нест карда
 мешаванд. 
 #include<iostream> 
 usingnamespace std; 
 classTest { 
 public: 
 Test() { cout <<"Constructor of Test "<< endl; } 
 ~Test() { cout <<"Destructor of Test "<< endl; } 
 }; 
 int main() { 
 try { 
 Test t; 
 throw; 
 } 
 catch (int i) { 
 cout <<"Caught "<< i << endl; 
 } 
 } 
 Натиҷа: 
 Constructor of Test 
 Destructor of Test 
 Caught 
 Саволҳо барои мустаҳкамкунӣ 
 дан мумкин аст? 
 ҳодиса рӯй медиҳад? 
 Мисолҳо барои мустаҳкамкунӣ: 
 Классҳо, объектҳо. Конструктор ва деструктор 
 ) Пас аз иҷроиш барномаи зерин чӣ хел натиҷа ба даст меояд? 
 #include<iostream> 
 usingnamespace std; 
 classA { 
 public: 
 A() { 
 this->_num =; 
 } 
 A(intnum) { 
 this->_num = num; 
 } 
 ~A() { 
 cout <<this->_num<<endl; 
 } 
 private: int _num; 
 }; 
 int main() 
 { 
 A val(); 
 val.~A(); 
 system("pause"); 
 return; 
 } 
 ) Пас аз иҷроиш барномаи зерин чӣ хел натиҷа ба даст меояд? 
 #include<iostream> 
 usingnamespace std; 
 classCounter { 
 public: 
 void Count() { 
 cout<<<<endl; 
 } 
 }; 
 voidCounter::Count() { 
 cout << << endl; 
 } 
 int main() { 
 Counter obj; 
 obj.Count(); 
 system("pause"); 
 return; 
 } 
 ) Пас аз иҷроиш барномаи зерин чӣ хел натиҷа ба даст меояд? 
 #include<iostream> 
 usingnamespace std; 
 classI { 
 int i; 
 public: 
 I(): i() { 
 cout <<"sun"<< endl; 
 } 
 I(inta): i(a) { 
 cout <<"venus "<< i << endl; 
 } 
 I(constI&other): i(other.i) { 
 cout <<"earth "<< i << endl; 
 } 
 ~I() { 
 cout <<"moon"<< endl; 
 } 
 int Get() { 
 return i; 
 } 
 voidoperator+= (constI&op) { 
 i += op.i; 
 } 
 }; 
 void f(I&x, Iy) { 
 y+=; x+=y; 
 } 
 int main() { 
 I i; 
 I i(); i +=; 
 f(i, i); 
 cout << i.Get() << i.Get() << endl; 
 system("pause"); 
 return; 
 } 
 ) Пас аз иҷроиш барномаи зерин чӣ хел натиҷа ба даст меояд? 
 #include<iostream> 
 usingnamespace std; 
 classI { 
 int i; 
 public: 
 I(): i() { 
 cout <<"owl"<< endl; 
 } 
 I(inta): i(a) { 
 cout <<"sheep "<< i << endl; 
 } 
 I(constI&other): i(other.i) { 
 cout <<"horse "<< i << endl; 
 } 
 ~I() { 
 cout <<"wolf"<< endl; 
 } 
 int Get() { 
 return i; 
 } 
 voidoperator*=(constI&op) { 
 i *= op.i; 
 } 
 }; 
 void f(Ix, I&y) { 
 x*=; y*=x; 
 } 
 int main() { 
 I i; 
 I i(); 
 i *=; 
 f(i, i); 
 cout << i.Get() <<' '<< i.Get() << endl; 
 system("pause"); 
 return; 
 } 
 ) Пас аз иҷроиш барномаи зерин чӣ хел натиҷа ба даст меояд? 
 #include"stdafx.h" 
 #include<iostream> 
 usingnamespace std; 
 classI { 
 int i; 
 public: 
 I(): i() { 
 cout <<"fist"<< endl; 
 } 
 I(inta): i(a) { 
 cout <<"lance "<< i << endl; 
 } 
 I(constI&other): i(other.i) { 
 cout <<"dagger "<< i << endl; 
 } 
 ~I() { 
 cout <<"pistole"<< endl; 
 } 
 int Get() { 
 return i; 
 } 
 voidoperator+=(constI&op) { 
 i += op.i; 
 } 
 }; 
 void f(I&x, Iy) { 
 y+=; x+=y; 
 } 
 int main() { 
 I i; 
 I i(); 
 i +=; 
 f(i, i); 
 cout << i.Get() <<' '<< i.Get() << endl; 
 system("pause"); 
 return; 
 } 
 ) Пас аз иҷроиш барномаи зерин чӣ хел натиҷа ба даст меояд? 
 #include"stdafx.h" 
 #include<iostream> 
 usingnamespace std; 
 classS { 
 public: 
 int x; 
 S(intn) { 
 x = n; 
 cout <<" Cons \n"; 
 } 
 S(constS&a) { 
 x = a.x; 
 cout <<" Copy \n"; 
 } 
 ~S() { 
 cout <<"Des \n"; 
 } 
 S f(Sy) { 
 y=S(); 
 returny; 
 } 
 }; 
 int main() { 
 S s(); 
 S f(s); 
 cout << s.x << endl; 
 system("pause"); 
 return; 
 } 
 ) Пас аз иҷроиш барномаи зерин чӣ хел натиҷа ба даст меояд? 
 #include<iostream> 
 usingnamespace std; 
 classS { 
 public: 
 int x; 
 S(intn) { 
 x = n; 
 cout <<" Cons \n"; 
 } 
 S(constS&a) { 
 x = a.x; 
 cout <<" Copy \n"; 
 } 
 ~S() { 
 cout <<"Des \n"; 
 } 
 }; 
 S f(S&y) { 
 y=S(); 
 returny; 
 } 
 int main() { 
 S s(); f(s); 
 cout << s.x << endl; 
 system("pause"); 
 return; 
 } 
 ) Пас аз иҷроиш барномаи зерин чӣ хел натиҷа ба даст меояд? 
 #include<iostream> 
 usingnamespace std; 
 classS { 
 public: 
 int x; 
 S(intn) { 
 x = n; 
 cout <<" Cons \n"; 
 } 
 S(constS&a) { 
 x = a.x; 
 cout <<" Copy \n"; 
 } 
 ~S() { 
 cout <<"Des \n"; 
 } 
 }; 
 S& f(Sy, S&z) { 
 y=S(); 
 returnz; 
 } 
 int main() { 
 S s(); 
 f(s, s); 
 cout<<s.x<<endl; 
 system("pause"); 
 return; 
 } 
 ) Оё дар барномаи зерин хатогӣ вуҷуд дорад? Дар ҳолати вуҷуд доштан 
 онҳоро ислоҳ кунед. 
 ) 
 #include<iostream> 
 usingnamespace std; 
 int n=; 
 float f(floata, intt =, intd = n) { 
 returna * (float)(t % d); 
 } 
 int main() { 
 cout<<f()<<endl; 
 system("pause"); 
 return; 
 } 
 ) 
 #include<iostream> 
 usingnamespace std; 
 float f(floata, intt, intd = ) { 
 returna * (float)(t % d); 
 } 
 int main() { 
 cout<<f(.,)<<endl; 
 system("pause"); 
 return; 
 } 
 ) 
 #include<iostream> 
 usingnamespace std; 
 enum { myparam = }; 
 float f(floata, intt = myparam +, intd = ) { 
 returna * (float)(t % d); 
 } 
 int main() { 
 cout<<f(.)<<endl; 
 system("pause"); 
 return; 
 } 
 ) Оё дар навишти коди зерин хатогӣ ҷой дорад? Дар ҳолати мавҷуд будан 
 онро нишон диҳед. Чӣ тавр метавон бе иловакунии методи нав ё ивазкунии 
 f() класси А-ро тавре тағйир дод, ки дар функсияи f() хатогӣ мавҷуд 
 набошад? Натиҷаи функсияи f() чӣ гуна аст? 
 #include<iostream> 
 usingnamespace std; 
 classA { 
 int a, b; 
 public: 
 A(A&x) { 
 a = x.a; 
 b = x.b; 
 cout <<; 
 } 
 A(inta) { 
 this->a = a; 
 b = a; 
 cout <<; 
 } 
 }; 
 void f() { 
 A x(); 
 A y; 
 A z = A(., ); 
 A s =; 
 A w = z; 
 x = z = w; 
 } 
 ) Класси А-ро тавре таҳия кунед, ки ҳамаи дастурҳои функсияи main () 
 дуруст буда, дар экран ададҳои ва хориҷ карда шаванд. 
 int main() { 
 A a(), a =; 
 a *=; 
 a *= a *=; 
 cout << a.get() << a.get() << endl; 
 system("pause"); 
 return; 
 } 
 ) Класси B-ро тавре таҳия кунед, ки ҳамаи дастурҳои функсияи main () 
 дуруст буда, дар экран ададҳои, ва хориҷ карда шаванд. 
 int main() { 
 B b, b = b, b(b); 
 cout << b.get() << b.get() << b.get() << endl; 
 system("pause"); 
 return; 
 } 
 ) Класси C-ро тавре таҳия кунед, ки ҳамаи дастурҳои функсияи main () 
 дуруст буда, дар экран ададҳои, ва хориҷ карда шаванд. 
 int main() { 
 C c(), c =, c(c + c); 
 cout << c.get() << c.get() << c.get() << endl; 
 system("pause"); 
 return; 
 } 
 ) Класси A-ро тавре таҳия кунед, ки ҳамаи дастурҳои функсияи main () 
 дуруст буда, дар экран ададҳои, ва хориҷ карда шаванд. 
 int main() { 
 A a(), a =, а; a *= a *=; 
 cout << a.get() <<' '<< a.get() <<' '<< a.get() << 
 endl; 
 system("pause"); 
 return; 
 } 
 ) Класси B-ро тавре таҳия кунед, ки ҳамаи дастурҳои функсияи main () 
 дуруст буда, дар экран ададҳои ва хориҷ карда шаванд. 
 int main() { 
 B b(), b(, ), b(b); 
 b += b += b; 
 cout << b.get() <<' '<< b.get() <<' '<< b.get() << 
 endl; 
 system("pause"); 
 return; 
 } 
 ) Класси C-ро тавре таҳия кунед, ки ҳамаи дастурҳои функсияи main 
 ()ба ғайр аз эълони с дуруст буда, дар экран ададҳои ва хориҷ 
 карда шаванд. 
 int main() { 
 C c(), c =, c(c + c); 
 cout << cl.get() <<' '<< c.get() << endl; 
 system("pause"); 
 return; 
 } 
 ) Дар барномаи зерин кадом конструктор ва деструктор бо кадом тартиб 
 иҷро мешавад? 
 ) 
 #include<iostream> 
 usingnamespace std; 
 classA {}; 
 classB: 
 publicA {}; 
 classC: 
 publicB {}; 
 int main() { 
 C c; 
 A a = c; 
 structD { 
 B b; 
 D(): b() {} 
 } d; 
 system("pause"); 
 return; 
 } 
 ) 
 #include<iostream> 
 usingnamespace std; 
 classA {}; 
 classB {}; 
 classC: publicA, publicB {}; 
 int main() { 
 C c; 
 classD { 
 C c; 
 B b; 
 public: D(): b(c) {} 
 } d; 
 system("pause"); 
 return; 
 } 
 ) Навишти методҳои зеринро тавре тағйир диҳед, ки бе ивазкунии амалҳои
 хориҷкунӣ ва сохторҳои B ва D ҳамаи дастурҳои методи main () дуруст 
 буда, дар экран натиҷаи чоп карда шавад. 
 #include<iostream> 
 usingnamespace std; 
 structB { 
 float x; 
 B() {} 
 B(floata) { 
 x = a; 
 cout <<; 
 } 
 ~B() { 
 cout <<; 
 } 
 }; 
 structD: B { 
 D(){ 
 cout <<; 
 } 
 ~D() { 
 cout <<; 
 } 
 }; 
 int main() { 
 B * p = newB(), *p = newD[]; 
 delete p; 
 delete[] p; 
 system("pause"); 
 return; 
 } 
 ) Навишти методҳои зеринро тавре тағйир диҳед, ки бе ивазкунии амалҳои
 хориҷкунӣ ва сохторҳои B ва D ҳамаи дастурҳои методи main () дуруст 
 буда, дар экран натиҷаи чоп карда шавад. 
 #include<iostream> 
 usingnamespace std; 
 structB { 
 int x; 
 B() {} 
 B(inta) { 
 x = a; cout <<; 
 } 
 ~B() { 
 cout <<; 
 } 
 }; 
 structD: B { 
 D(intd): B(d) { 
 cout <<; 
 } 
 ~D() { 
 cout <<; 
 } 
 }; 
 int main() { 
 B * p = newB[], *p = newD(); 
 delete[] p; 
 delete p; 
 system("pause"); 
 return; 
 } 
 ) Навишти методҳои зеринро тавре тағйир диҳед, ки бе ивазкунии амалҳои
 хориҷкунӣ ва сохторҳои B ва D ҳамаи дастурҳои методи main () дуруст 
 буда, дар экран натиҷаи карда шавад. 
 #include<iostream> 
 usingnamespace std; 
 classB { 
 public: 
 int x; 
 B() { 
 x =; 
 cout <<; 
 } 
 ~B() { 
 cout <<; 
 } 
 }; 
 classD: B { 
 public: 
 D(intd) { 
 x = d; 
 cout <<; 
 } 
 ~D() { 
 cout <<; 
 } 
 }; 
 int main() { 
 B * p = newB[], *p = newD[]; 
 delete[] p; 
 delete[] p; 
 system("pause"); 
 return; 
 } 
 ) Оё дар навишти коди зерин хатогӣ ҷой дорад? Дар ҳолати мавҷуд будан 
 дастурҳои дорои хатогиро тоза кунед. 
 Пас аз даъвати методи main() чӣ гуна натиҷа ба даст меояд? 
 ) 
 #include<iostream> 
 usingnamespace std; 
 classX { 
 int i; 
 double t; 
 X(intk) { 
 i = k; 
 t =; 
 cout <<; 
 } 
 public: 
 X() {} 
 X(intk, doubler = ) { 
 i = k; 
 t = r; 
 cout <<; 
 } 
 X&operator= (X&a) { 
 i = a.i; 
 t = a.t; 
 cout <<; 
 return *this; 
 } 
 X(constX&a) { 
 i = a.i; 
 t = a.t; 
 cout <<; 
 } 
 }; 
 int main() { 
 X a; 
 X b(,); 
 X c(,.); 
 X d = c; 
 X e(., ); 
 c = d = e; 
 system("pause"); 
 return; 
 } 
 ) 
 #include<iostream> 
 usingnamespace std; 
 classX { 
 int i; 
 double t; 
 public: 
 X() { 
 i =; 
 t =.; 
 cout <<; 
 } 
 X(intk, doubler =.) { 
 i = k =; 
 t = r; 
 cout <<; 
 } 
 X(constX&a) { 
 i = a.i; 
 t = a.t; 
 cout <<; 
 } 
 }; 
 int main() { 
 X a; 
 X b(); 
 X c(., ); 
 X d = b; 
 X e =; 
 b = c = e; 
 system("pause"); 
 return; 
 } 
 ) Бо номи employee класс созед, ки дорои як майдони типи бутун - 
 барои нигоҳ доштани рақами коргар ва як майдони типи ҳақиқӣ – барои 
 нигоҳ ддоштани маоши коргар мавҷуд бошад. Методҳои класс бояд 
 дорои имкониятҳои дохилкунӣ ва хориҷкунии иттилооти коргарро 
 дошта бошанд. Дар функсияи асосии барнома барои се коргар нусхаи 
 классро сохта, методҳои классро даъват кунед. 
 ) Бо номи Date класс созед, ки дар он имконияти ҷамъ ва тарҳ намудани 
 таърихи рӯз, ки иборат аз рӯз, моҳ ва сол меиошад, мавҷуд бошад. 
 ) Бо номи rectangle класс созед, ки дорои майдонҳои бар ва дарозӣ буда,
 барои муайян намудани масоҳат ва периметри он метод нависед. 
 ) Бо номи Tringle класс созед, ки дорои майдони радиус буда, барои муайян
 намудани диаметр, дарозӣ ва масоҳати доираи бо ин давра маҳдуд метод 
 нависед. 
 Хосияти меросӣ 
 ) Пас аз иҷроиш барномаи зерин чӣ натиҷа ба даст меояд? 
 #include<iostream> 
 usingnamespace std; 
 classABase { 
 public: 
 void f(inti) const { 
 cout <<; 
 } 
 void f(charch) const { 
 cout <<; 
 } 
 }; 
 classBBase { 
 public: 
 void f(doubled) const { 
 cout <<; 
 } 
 }; 
 classABBase: publicABase, publicBBase { 
 public: 
 usingABase::f; 
 usingBBase::f; 
 void f(charch) const { 
 cout <<; 
 } 
 }; 
 void g(ABBase&ab) { 
 ab.f('c'); 
 ab.f(.); 
 ab.f(); 
 } 
 int main() { 
 ABBase ab; 
 g(ab); 
 system("pause"); 
 return; 
 } 
 ) Пас аз иҷроиш барномаи зерин чӣ натиҷа ба даст меояд? 
 #include<iostream> 
 usingnamespace std; 
 classA { 
 int j; 
 public: 
 A(inti): j(i) { } 
 A() {} 
 void print() { 
 cout <<sizeof(j) << endl; 
 } 
 }; 
 classB: virtualpublicA { 
 public: 
 B(inti): A(i) { } 
 }; 
 classC: publicB { 
 public: 
 C(inti):B(i){ } 
 }; 
 int main(){ 
 C c(); 
 c.print(); 
 system("pause"); 
 return; 
 } 
 ) Пас аз иҷроиш барномаи зерин чӣ хел натиҷа ба даст меояд? 
 #include<iostream> 
 usingnamespace std; 
 classA { 
 public: 
 A() { f(); } 
 virtualvoid f() { 
 std::cout <<"A::f"; 
 } 
 }; 
 classB: publicA { 
 public: void f() { 
 std::cout <<"B::f"; 
 } 
 }; 
 int main(){ 
 A * a = newB(); 
 delete a; 
 system("pause"); 
 return; 
 } 
 ) Дар кадом сатри барномаи зерин хатогӣ ҷой дорад? 
 #include<iostream> 
 usingnamespace std; 
 classBase { 
 public: 
 void method(); 
 protected: 
 void method(); 
 private: 
 void method(); 
 }; 
 classChild:publicBase { 
 protected: 
 void method() { } 
 void method() { } 
 void method() { } 
 }; 
 int main() { 
 Base* base = newChild(); 
 base->method(); // 
 base->method(); // 
 base->method(); // 
 system("pause"); 
 return; 
 } 
 ) Сатри // –ро бо чӣ иваз кардан лозим, то барнома кор кунад? 
 #include<iostream> 
 usingnamespace std; 
 classA { 
 public: 
 void someMethod() { 
 /*... */ 
 } 
 }; 
 classB: publicA { 
 public: 
 void someMethod(intsomeArg) { 
 /*... */ 
 }// 
 }; 
 int main() { 
 B b; 
 b.someMethod(); 
 system("pause"); 
 return; 
 } 
 ) Пас аз сохтани нусхаи класси Х барномаи зерин чӣ натиҷа медиҳад? 
 #include"stdafx.h" 
 #include<iostream> 
 usingnamespace std; 
 classY { 
 public: 
 Y() { 
 cout <<"Y"; 
 } 
 }; 
 classZ { 
 public: 
 Z() { 
 cout <<"Z"; 
 } 
 }; 
 classX: publicZ { 
 private: 
 Y m_objY; 
 public: 
 X() { 
 cout <<"X"; 
 } 
 }; 
 int main(){ 
 X a; 
 system("pause"); 
 return; 
 } 
 ) Пас аз иҷроиш барномаи зерин чӣ хел натиҷа ба даст меояд? 
 #include<iostream> 
 usingnamespace std; 
 structA { 
 A() { 
 cout <<"A"; 
 } 
 }; 
 structB: A { 
 B() { 
 cout <<"B"; 
 } 
 }; 
 structC: A { 
 C() { 
 cout <<"C"; 
 } 
 }; 
 structD: B, C { 
 D() { 
 cout <<"D"; 
 } 
 }; 
 int main() { 
 D d; 
 system("pause"); 
 return; 
 } 
 ) Бо кадом тартиб деструкторҳо даъват карда мешаванд? 
 #include<iostream> 
 usingnamespace std; 
 classA { 
 public: 
 A() {} 
 ~A() { cout <<"~A"; } 
 }; 
 classB: publicA { 
 public: 
 B() {} 
 ~B() { 
 cout <<"~B"; 
 } 
 }; 
 int main() { 
 B *b = newB(); 
 delete b; 
 system("pause"); 
 return; 
 } 
 ) Дар пиёдасозии методҳои B::g () и main () оё хатогӣ ҷой дорад? Барои 
 ҳамаи операторҳои дурусти функсияҳои мазкур тавассути оператори:: 
 (иҷозати ҳудуди фаъолият) нишон диҳед, ки номҳои дар онҳо навишташуда 
 аз кадом минтақаи фаъолият интихоб карда шудаанд. Кадом конструкторҳо 
 ва деструкторҳо бо кадом тартиб даъват карда мешаванд? 
 ) 
 #include<iostream> 
 usingnamespace std; 
 int x =; 
 void f(inta, intb) { 
 x = a + b; 
 } 
 classA { 
 int x; 
 public: 
 void f() { 
 x =; 
 } 
 }; 
 classB: publicA { 
 public: 
 void f(inta) {::x = a; 
 } 
 void g(); 
 }; 
 voidB::g() { 
 f(); 
 f(); 
 f(, ); 
 x =; 
 } 
 B ret(B&x, B&y) { 
 returnx; 
 } 
 int main() { 
 B b; 
 f(); 
 f('+', ); 
 b = ret(b, b); 
 system("pause"); 
 return; 
 } 
 ) 
 #include<iostream> 
 usingnamespace std; 
 double a =; 
 void f(doublex) { 
 a = x; 
 } 
 structA { 
 double a; 
 void f() { 
 a =; 
 } 
 }; 
 classB: A { 
 public: 
 void f(inta) {::a = a; 
 } 
 void g(); 
 }; 
 voidB::g() { 
 f(.); 
 f(); 
 a =; 
 } 
 void empty(B&a, Bb) { } 
 int main() { 
 B d; 
 f(); 
 f(); 
 empty(d, d); 
 system("pause"); 
 return; 
 } 
 ) 
 #include<iostream> 
 usingnamespace std; 
 int x =; 
 void f(inta, intb) { 
 x = a + b; 
 } 
 classA { 
 int x; 
 public: 
 void f() { 
 x =; 
 } 
 void f(chara, charb) { 
 x = a - b; 
 } 
 }; 
 classB: publicA { 
 public: 
 void f(inta) {::x = a; 
 } 
 void g() { 
 f(); 
 f(); 
 f(., ); x =; 
 } 
 }; 
 int main() { 
 B b; 
 f(); 
 f(, 'a'); 
 system("pause"); 
 return; 
 } 
 ) 
 #include<iostream> 
 usingnamespace std; 
 double a =; 
 void f(doublex = ) { 
 a = x; 
 } 
 void f() { 
 a =; 
 } 
 structBBase { 
 double a; 
 void f() { 
 a =; 
 } 
 }; 
 classB: BBase { 
 public: 
 void f(inta) {::a = a; 
 } 
 void g() { 
 f('r'); 
 f(); 
 a =; 
 } 
 }; 
 int main() { 
 B d; 
 f(); 
 f(); 
 system("pause"); 
 return; 
 } 
 ) 
 #include<iostream> 
 usingnamespace std; 
 float y =; 
 void f(floata) { 
 y = a; 
 } 
 classT { 
 int y; 
 public: 
 void f() { 
 y =; 
 } 
 }; 
 classB: publicT { 
 public: 
 void f(floatn, floatm) {::y = n * m; 
 } 
 void f(charc, charc) {::y = c + c; 
 } 
 void g() { 
 f(); 
 f(); 
 f(-, ); 
 y =; 
 } 
 }; 
 int main() { 
 B b; f(); 
 f('+', ); 
 system("pause"); 
 return; 
 } 
 ) Дар пиёдасозии методҳои классҳои овардашуда ва main () оё хатогӣ ҷой
 дорад? Барои ислоҳкунии онҳо аз оператори:: (иҷозати ҳудуди фаъолият) 
 истифода намоед. Кадом конструкторҳо ва деструкторҳо бо кадом тартиб 
 даъват карда мешаванд? 
 ) 
 #include<iostream> 
 usingnamespace std; 
 int x =; 
 int f(inta, intb) { 
 return x = a + b; 
 } 
 classA { 
 int x; 
 public: 
 A(intn = ) { 
 x = n; 
 } 
 int f() { 
 return::x = x; 
 } 
 }; 
 classB { 
 int x; 
 public: 
 B(intn = ) { 
 x = n; 
 } 
 }; 
 classC: publicA, publicB { 
 int x; 
 public: 
 int f(inta) { 
 return::x = x; 
 } 
 void g(); 
 }; 
 voidC::g() { 
 x = f(); 
 f(); 
 x = f(, ); 
 x =; 
 } 
 int main() { 
 C c; 
 B b = c; 
 A a = с; 
 c.f(); 
 c.f(); 
 x = f(‘’, ); 
 system("pause"); 
 return; 
 } 
 ) 
 #include<iostream> 
 usingnamespace std; 
 int x =; 
 int f(inta, intb) { 
 return x = a + b; 
 } 
 classA { 
 int x; 
 public: 
 A(intn = ) { 
 x = n; 
 } 
 int f() { 
 return::x = x; 
 } 
 }; 
 classB { 
 int x; 
 public: 
 B(intn = ) { 
 x = n; 
 } 
 }; 
 classC: publicA, publicB { 
 int x; 
 public: 
 int f(inta) { 
 return::x = x; 
 } 
 void g(); 
 }; 
 voidC::g() { 
 x = f(); 
 f(); 
 x = f(,); 
 x =; 
 } 
 int main() { 
 C c; 
 B b = c; 
 A a = c; 
 c.f(); 
 c.f(); 
 x = f('', ); 
 system("pause"); 
 return; 
 } 
 ) 
 #include<iostream> 
 usingnamespace std; 
 int x =; 
 int f(inta, intb) { 
 return x = a + b; 
 } 
 classA { 
 int x; 
 public: 
 A(intn = ) { 
 x = n; 
 } 
 int f() { 
 return::x = x; 
 } 
 }; 
 classB { 
 int x; 
 public: 
 B(intn = ) { 
 x = n; 
 } 
 }; 
 classC: publicA, publicB { 
 int x; 
 public: 
 int f(inta) { 
 return::x = x; 
 } 
 void g(); 
 voidC::g() { 
 x = f(); 
 f(); 
 x = f(, ); 
 x =; 
 } 
 }; 
 int main() { 
 C c; 
 B b; 
 A a; 
 c.f(); 
 c.f(); 
 x = f(‘’, ); 
 system("pause"); 
 return; 
 } 
 ) 
 #include<iostream> 
 usingnamespace std; 
 int x =; 
 int f() { 
 return x =; 
 } 
 classA { 
 int x; 
 public: 
 A(intn = ) { 
 x = n; 
 } 
 int f() { 
 return x =; 
 } 
 int f(inta, intb) { 
 return x = a % b; 
 } 
 }; 
 classB: publicA { 
 int x; 
 public: 
 int f(inta) { 
 return x = a; 
 } 
 int f(inta, intb) { 
 return x = a + b; 
 } 
 int g(A * a, B * b); 
 intB::g(A * pa, B * pb) { 
 x = f(); 
 x = f(); 
 x = f(, ); 
 x = A::f(); 
 return -; 
 } 
 }; 
 int main() { 
 B a; 
 x = a.f(); 
 x = a.f(); 
 classC { 
 A a; 
 public: 
 C(): a(b) {} 
 }; 
 C c; 
 cout<<a.g(&a, &a); 
 system("pause"); 
 return; 
 } 
 ) 
 #include<iostream> 
 usingnamespace std; 
 int x =; 
 classA { 
 int x; 
 public: 
 A(intn = ); 
 int f(inta =, intb = ); 
 }; 
 classB:publicA { 
 public: 
 int x; 
 B(intn = ); 
 int f(inta); 
 }; 
 classC: publicB { 
 int x; 
 public: 
 C(intn = ); 
 int f(inta, intb); 
 int g(A * p); 
 }; 
 int main() { 
 A * p; 
 B b; 
 C c; 
 A a = c; structD { 
 B b; 
 D(): b() {} 
 } d; p = &b; 
 x = c.g(&c); 
 x = c.f(); 
 x = c.f(x); 
 x = c.f(x, ); 
 x = p->f(); 
 x = p->f(x); x = p->f(x, ); 
 system("pause"); 
 return; 
 } 
 ) 
 #include<iostream> 
 usingnamespace std; 
 int x =; 
 classA { 
 int x; 
 public: 
 A(intn = ); 
 int f(inta =, intb = ); 
 }; 
 classB: publicA { 
 int x; 
 public: 
 B(intn = ); 
 int f(inta = ); 
 }; 
 classC: publicB { 
 int x; 
 public: 
 C(intn = ); 
 int f(inta, intb); 
 int g(A * p); 
 }; 
 int main() { 
 A * p; 
 B b; 
 C c; 
 classD { 
 B b; 
 A a; 
 public: 
 D(): a(b) {} 
 }d; 
 p = &b; 
 x = c.g(&b); 
 x = c.f(); 
 x = c.f(x); 
 x = c.f(x, ); 
 x = p->f(); 
 x = p->f(x); 
 x = p->f(x, ); 
 system("pause"); 
 return; 
 } 
 ) Оё дар барномаи зерин хатогӣ мавҷуд аст? Агар мавҷуд бошад, бе тоза 
 намудани ягон фармон, бо навиштани символ онро ислоҳ кунед: 
 #include<iostream> 
 usingnamespace std; 
 classA { 
 public: 
 int * n; 
 int m; 
 }; 
 classB: publicA { 
 public: 
 int * p; 
 }; 
 classC: publicA { 
 public: 
 int * c; 
 }; 
 classD: publicB, publicC { 
 public: 
 int * e; 
 }; 
 int main() { 
 D fA, *f = newD; 
 fA.m =; 
 cout << *((*f).e = &fA.m); 
 system("pause"); 
 return; 
 } 
 ) Оё дар барномаи зерин хатогӣ мавҷуд аст? Агар мавҷуд бошад, бе тоза 
 намудани ягон фармон, бо навиштани то символ онро ислоҳ кунед: 
 #include<iostream> 
 usingnamespace std; 
 classS { 
 public: 
 int s; 
 void sp(intsi) { 
 s = si; 
 } 
 }; 
 classT: S { 
 public: 
 int t; 
 void tp(intti) { 
 t = ti; 
 s = ti; 
 } 
 }; 
 classU: T { 
 public: 
 int u; 
 void up(intui) { 
 u = ui; 
 t = ui; 
 s = ui; 
 } 
 }; 
 void g() { 
 U * pu = newU; 
 T * pt = pu; 
 S * ps = pu; 
 } 
 int main(){ 
 g(); 
 return; 
 } 
 ) Оё дар барномаи зерин хатогӣ мавҷуд аст? Агар мавҷуд бошад, бе тоза 
 намудани ягон фармон, бо навиштани то символ онро ислоҳ кунед: 
 #include<iostream> 
 usingnamespace std; 
 classW { 
 public: 
 int * w; 
 void wf(int * wp) { 
 w = wp; 
 } 
 }; 
 classX: W { 
 public: 
 int * x; 
 void xf(int * xp) { 
 x = xp; 
 w = xp; 
 } 
 }; 
 classY: W { 
 public: 
 int * y; 
 void yf(int * yp) { 
 y = yp; 
 w = yp; 
 } 
 }; 
 classZ: X, Y { 
 public: 
 int * z; 
 void zf(int * zp) { 
 z = zp; 
 x = zp; 
 y = zp; 
 } 
 }; 
 void h() { 
 int hi; 
 W * pw; 
 X * px; 
 Y * py; 
 Z * pz; 
 pz = newW; 
 (*pz).w = &hi; 
 pz->xf((*pz).X::w); 
 } 
 int main(){ 
 h(); 
 system("pause"); 
 return; 
 } 
 ) Иерархияи классҳоро тавсиф намуда, (дар мувофиқа бо вариантҳо – 
 класси базавӣ ва меросгирро муайян намоед) онҳоро пиёдасозӣ кунед. 
 Вариант Задание 
 Классҳои - одам (ном, соли таваллуд), довталаб (миқдори 
 балҳо), донишҷӯ (курс, гурӯҳ, факултет), устодон 
 (дараҷаи илмӣ, кафедра). 
 Классҳои - растанӣ (ном, намуд), дарахт (синну сол), гул 
 (дарозии қад), лола (ранг). 
 Классҳои - ширхӯрон (сол), хояндаҳо (муҳити зист), 
 паранда (шикорчӣ), ҳайвонот (намуд, оила, вазн). 
 Классҳои - ҷой (масоҳат, ном), вилоят (миқдори нуқтаҳои 
 аҳолӣ, роҳбар), ҳашр (вилоят, миқдори аҳолӣ, раиси 
 шаҳр), деҳа (миқдори аҳолӣ). 
 Классҳои - мошин (тамға, рақам), қатора (рақам, миқдори 
 вагонҳо, миқдори мусофирон дар вагон), воситаҳои 
 нақлиётӣ (суръати миёна, шакли сузишворӣ, соли 
 барориш). 
 Классҳои - ҷумҳурӣ (шакл, роҳбарият), монархия (намуд, 
 монархия), шоҳигарӣ (шоҳ), давлат (ном, воҳиди пулӣ, 
 рамзҳо). 
 Функсияҳои виртуалӣ. Классҳои абстрактӣ 
 ) Ҳангоми иҷроиш дар кадом сатр хатогӣ ба амал меояд? 
 #include<iostream> 
 usingnamespace std; 
 classTest { 
 public: 
 bool flag; 
 Test() { 
 flag = false; 
 } 
 staticint ObjectCount; // staticvoidPOut () // 
 { 
 cout << flag; // 
 cout << ObjectCount; // } 
 } 
 }; 
 intTest::ObjectCount =; // 
 int main() 
 { 
 Test T; 
 system("pause"); 
 return; 
 } 
 ) Ҳангоми сохтани нусхаи класси D чӣ натиҷа ба даст меояд? 
 #include"stdafx.h" 
 #include<iostream> 
 usingnamespace std; 
 structA { 
 A() { 
 cout <<"A"; 
 } 
 }; 
 structB: virtualA { 
 B() { 
 cout <<"B"; 
 } 
 }; 
 structC: virtualA { 
 C() { 
 cout <<"C"; 
 } 
 }; 
 structD: B, C { 
 D() { 
 cout <<"D"; 
 } 
 }; 
 int main() 
 { 
 D d; 
 system("pause"); 
 return; 
 } 
 ) Пас аз иҷроиш барномаи зерин чӣ хел натиҷа ба даст меояд? 
 #include<iostream> 
 usingnamespace std; 
 classA { 
 public: 
 A() { 
 f("A()"); 
 } 
 ~A() { 
 f("~A()"); 
 } 
 protected: 
 virtualvoid f(constchar* str) =; 
 }; 
 classB: publicA { 
 public: 
 B() { 
 f("B()"); 
 } 
 ~B() { 
 f("~B()"); 
 } 
 protected: 
 void f(constchar* str) { 
 cout <<str<< endl; 
 } 
 }; 
 int main(){ 
 B b; 
 system("pause"); 
 return; 
 } 
 ) Оё ба шакли зерин муаррифӣ намудани функсияи виртуалии тоза мумкин 
 аст? 
 classAbstract 
 { 
 public: 
 virtualvoid pureVirtual() = { 
 // реализация } 
 } 
 }; 
 ) Пас аз иҷроиш барномаи зерин чӣ хел натиҷа ба даст меояд? 
 #include<iostream> 
 usingnamespace std; 
 classA { 
 int i; 
 public: 
 A(intx) { 
 i = x; 
 cout <<"first"<< endl; 
 } 
 virtual ~A() { 
 cout <<"second"<< endl; 
 } 
 int f() const { 
 return i + g() + h(); 
 } 
 virtualint g() const { 
 return i; 
 } 
 int h() const { 
 return; 
 } 
 }; 
 classB: publicA { 
 public: 
 B(): A() { 
 cout <<"third"<< endl; 
 } 
 ~B() { 
 cout <<"fourth"<< endl; 
 } 
 int f() const { 
 return g() -; 
 } 
 virtualint g() const { 
 return; 
 } 
 int h() const { 
 return; 
 } 
 }; 
 int main() { 
 B b; 
 A* p = &b; 
 cout <<"result = ("<< p->f() <<';'<< b.f() <<')'<< endl; 
 system("pause"); 
 return; 
 } 
 ) Пас аз иҷроиш барномаи зерин чӣ хел натиҷа ба даст меояд? 
 #include<iostream> 
 usingnamespace std; 
 classA { 
 int i; 
 public: 
 A(intx) { 
 i = x; 
 cout <<"mercury"<< endl; 
 } 
 virtual ~A() { 
 cout <<"venus"<< endl; 
 } 
 int f() const { 
 return; 
 } 
 virtualint g() const { 
 return i; 
 } 
 int h() const { 
 return i - f() - g(); 
 } 
 }; 
 classB: publicA { 
 public: 
 B(intx): A(x + ) { 
 cout <<"earth"<< endl; 
 } 
 ~B() { 
 cout <<"mars"<< endl; 
 } 
 int f() const { 
 return; 
 } 
 virtualint g() const { 
 return; 
 } 
 int h() const { 
 return f() + g(); 
 } 
 }; 
 int main() { 
 B b(); 
 A* p = &b; 
 cout <<"result = ("<< p->h() <<';'<< b.h() <<')'<< endl; 
 system("pause"); 
 return; 
 } 
 ) Пас аз иҷроиш барномаи зерин чӣ хел натиҷа ба даст меояд? 
 #include<iostream> 
 usingnamespace std; 
 classA { 
 int i; 
 public: 
 A(intx) { 
 i = x; 
 cout <<"dog"<< endl; 
 } 
 virtual ~A() { 
 cout <<"cat"<< endl; 
 } 
 int f() const { 
 return i + g() + h(); 
 } 
 virtualint g() const { 
 return i; 
 } 
 int h() const { 
 return; 
 } 
 }; 
 classB: publicA { 
 public: 
 B(): A() { 
 cout <<"sheep"<< endl; 
 } 
 ~B() { 
 cout <<"horse"<< endl; 
 } 
 int f() const { 
 return g() -; 
 } 
 virtualint g() const { 
 return; 
 } 
 int h() const { 
 return; 
 } 
 }; 
 int main() { 
 B b; 
 A* p = &b; 
 cout <<"result = ("<< p->f() <<';'<< b.f() <<')'<< endl; 
 system("pause"); 
 return; 
 } 
 ) Пас аз иҷроиш барномаи зерин чӣ хел натиҷа ба даст меояд? 
 #include<iostream> 
 usingnamespace std; 
 structB { 
 virtualvoid f(intn) { 
 cout <<"f(int) from B"<< endl; 
 } 
 staticint i; 
 }; 
 structD: B { 
 virtualvoid f(charn) { 
 cout <<"f(char) from D"<< endl; 
 } 
 }; 
 intB::i =; 
 int main() { 
 D d; 
 B b, b, *pb = &d; 
 pb->f('a'); 
 b.i +=; 
 b.i +=; 
 d.i +=; 
 cout << b.i <<' '<< b.i <<' '<< d.i <<' '<<B::i << 
 endl; 
 system("pause"); 
 return; 
 } 
 ) Пас аз иҷроиш барномаи зерин чӣ хел натиҷа ба даст меояд? 
 #include<iostream> 
 usingnamespace std; 
 structK { 
 virtualvoid add_st(K * n) { 
 st++; 
 cout <<"add_st(K*) from K"<< endl; 
 } 
 staticint st; 
 }; 
 structL: K { 
 virtualvoid add_st(L * a) { 
 st++; 
 cout <<"add_st(L*) from L"<< endl; 
 } 
 }; 
 intK::st =; 
 int main() { 
 L ob, ob; 
 K k, *pl = &ob; 
 pl->add_st(&ob); 
 k.st++; 
 ++ob.st; 
 cout << k.st <<' '<< ob.st <<' '<<K::st << endl; 
 system("pause"); 
 return; 
 } 
 ) Пас аз иҷроиш барномаи зерин чӣ хел натиҷа ба даст меояд? 
 #include<iostream> 
 usingnamespace std; 
 structS { 
 staticdouble d; 
 virtualS& g() { 
 cout <<"g() from S"<< endl; 
 } 
 }; 
 structT: S { 
 virtualT& g() { 
 cout <<"g() from T"<< endl; 
 } 
 }; 
 doubleS::d =.; 
 int main() { 
 T t; S s, *ps = &t; 
 ps->g(); 
 s.d =; t.d =; 
 cout << s.d <<' '<< t.d <<' '<<S::d << endl; 
 system("pause"); 
 return; 
 } 
 ) Оё дар қитъаи барномаи зерин хатогӣ ҷой дорад? 
 classB { 
 public: 
 virtualint f() =; 
 int g() { 
 return f() *; 
 } 
 virtual ~B() {} 
 }; 
 int h(Bb) { 
 returnb.g() +; 
 } 
 ) Оё дар қитъаи барномаи зерин хатогӣ мавҷуд аст? 
 structS { 
 virtualvoid f() const =; 
 virtual ~S() {} 
 }; 
 structA { 
 S s; int i; 
 }; 
 ) Оё дар қитъаи барномаи зерин хатогӣ мавҷуд аст? Дар сурати мавҷуд 
 будан хатогиҳоро ислоҳ кунед ва дастури хатодоштаро тоза кунед: 
 #include<iostream> 
 usingnamespace std; 
 classX { 
 public: 
 virtualint g(doublex) { 
 h(); 
 cout <<"X::g"<< endl; 
 return; 
 } 
 void h() { 
 t(); 
 cout <<"X::h"<< endl; 
 } 
 virtualvoid t() { 
 cout <<"X::t"<< endl; 
 } 
 }; 
 classZ: publicX { 
 public: 
 int g(doubley) { 
 h(); 
 cout <<"Z::g"<< endl; 
 return; 
 } 
 virtualvoid h() { 
 t(); 
 cout <<"Z::h"<< endl; 
 } 
 virtualvoid t(intk) { 
 cout <<"Z::t"<< endl; 
 } 
 }; 
 int main() { 
 X a; Z b; 
 X * p = &b; 
 p->g(.); 
 p->h(); 
 p->t(); 
 system("pause"); 
 return; 
 } 
 ) Оё дар қитъаи барномаи зерин хатогӣ мавҷуд аст? Дар сурати мавҷуд 
 будан хатогиҳоро ислоҳ кунед ва дастури хатодоштаро тоза кунед: 
 #include<iostream> 
 usingnamespace std; 
 classT { 
 public: 
 virtualint f(intx) { 
 cout <<"T::f"<< endl; 
 return; 
 } 
 void g() { 
 f(); 
 cout <<"T::g"<< endl; 
 } 
 virtualvoid h() { 
 g(); 
 cout <<"T::h"<< endl; 
 } 
 }; 
 classS: publicT { 
 public: 
 int f(doubley) { 
 cout <<"S::f"<< endl; return; 
 } 
 virtualvoid g() { 
 f(); 
 cout <<"S::g"<< endl; 
 } 
 virtualvoid h() { 
 g(); 
 cout <<"S::h"<< endl; 
 } 
 }; 
 int main() { 
 T t; S s; T *p = &s; p->f(.); 
 p->g(); p->h(); 
 system("pause"); 
 return; 
 } 
 ) Оё дар қитъаи барномаи зерин хатогӣ мавҷуд аст? Дар сурати мавҷуд 
 будан хатогиҳоро ислоҳ кунед ва дастури хатодоштаро тоза кунед: 
 #include<iostream> 
 usingnamespace std; 
 classK { 
 public: 
 virtualint f(intx) { 
 cout <<"K::f"<< endl; 
 return; 
 } 
 void g() { 
 f(); 
 cout <<"K::g"<< endl; 
 } 
 virtualvoid h() { 
 g(); 
 cout <<"K::h"<< endl; 
 } 
 }; 
 classP: publicK { 
 public: 
 int f(doubley) { 
 cout <<"P::f"<< endl; 
 return; 
 } 
 virtualvoid g() { 
 f(); 
 cout <<"P::g"<< endl; 
 } 
 virtualvoid h() { 
 g(); 
 cout <<"P::h"<< endl; 
 } 
 }; 
 int main() { 
 K k; 
 P p; 
 K *t = &p; 
 t->f(.); 
 t->g(); 
 t->h(); 
 system("pause"); 
 return; 
 } 
 ) Оё дар қитъаи барномаи зерин хатогӣ мавҷуд аст? Дар сурати мавҷуд 
 будан хатогиҳоро ислоҳ кунед ва дастури хатодоштаро тоза кунед: 
 #include<iostream> 
 usingnamespace std; 
 classA { 
 public: 
 virtualvoid f(intx) { 
 h(x); 
 cout <<"A::f,"<<x<< endl; 
 } 
 void g() { 
 h(); cout <<"A::g"<< endl; 
 } 
 virtualvoid h(intk) { 
 cout <<"A::h,"<<k<< endl; 
 } 
 }; 
 classB: virtualpublicA { 
 public: 
 void f(inty) { 
 h(y); cout <<"B::f,"<<y<< endl; 
 } 
 void g() { 
 h(); cout <<"B::g"<< endl; 
 } 
 void h(intk) { 
 cout <<"B::h,"<<k<< endl; 
 } 
 }; 
 int main() { 
 A a; 
 B b; 
 A * p = &b; 
 p->f(); 
 p->g(); 
 p->h(); 
 p->h(); 
 system("pause"); 
 return; 
 } 
 ) Оё дар қитъаи барномаи зерин хатогӣ мавҷуд аст? Дар сурати мавҷуд 
 будан хатогиҳоро ислоҳ кунед ва дастури хатодоштаро тоза кунед: 
 #include<iostream> 
 usingnamespace std; 
 classC { 
 public: 
 virtualvoid f(intx) { 
 h(x); cout <<"C::f,"<<x<< endl; 
 } 
 virtualvoid g() { 
 h(); cout <<"C::g"<< endl; 
 } 
 virtualvoid h() { 
 cout <<"C::h"<< endl; 
 } 
 virtualvoid h(intk) { 
 h(); cout <<"C::h,"<<k<< endl; 
 } 
 }; 
 classD: publicC { 
 public: 
 virtualvoid f(inty) { 
 h(y); cout <<"D::f,"<<y<< endl; 
 } 
 virtualvoid g() { 
 h(); cout <<"D::g"<< endl; 
 } 
 virtualvoid h() { 
 cout <<"D::h"<< endl; 
 } 
 virtualvoid h(intk) { 
 h(); 
 cout <<"D::h,"<<k<< endl; 
 } 
 }; 
 int main() { 
 C c; 
 D d; 
 C * p = &d; 
 p->f(); 
 p->g(); 
 p->h(); 
 p->h(); 
 system("pause"); 
 return; 
 } 
 ) Оё дар қитъаи барномаи зерин хатогӣ мавҷуд аст? Дар сурати мавҷуд 
 будан хатогиҳоро ислоҳ кунед ва дастури хатодоштаро тоза кунед: 
 #include<iostream> 
 usingnamespace std; 
 classT { 
 public: 
 virtualvoid f(intx) { 
 h(); 
 cout <<"T::f,"<<x<< endl; 
 } 
 void g() { 
 h(); 
 cout <<"T::g"<< endl; 
 } 
 virtualvoid h() { 
 cout <<"T::h"<< endl; 
 } 
 }; 
 classU: virtualpublicT { 
 public: 
 void f(inty) { 
 h(y); 
 cout <<"U::f,"<<y<< endl; 
 } 
 virtualvoid g() { 
 h(); 
 cout <<"U::g"<< endl; 
 } 
 void h(intk) { 
 cout <<"U::h,"<<k<< endl; 
 } 
 }; 
 int main() { 
 T t; 
 U u; 
 T * p = &u; 
 p->f(); 
 p->g(); 
 p->h(); 
 p->h(); 
 system("pause"); 
 return; 
 } 
 ) Оё дар қитъаи барномаи зерин хатогӣ вуҷуд дорад? 
 structA { 
 int i; 
 virtualvoid f() =; 
 virtual ~A() {} 
 }; 
 int g(Aa) { 
 returna.i *; 
 } 
 Сарборигузории амалҳо 
 Шарти умумӣ. Вобаста ба варианти додашуда класс созед, ки дорои 
 конструкторҳо, деструкторҳо, функсияҳои зарурӣ ва сарборигузории амалҳои 
 зарурӣ бошад. 
 Вариант Шарти масъала 
 Класси массиви якченака. Амалҳои зарб, ҷамъ, дастрасӣ ба 
 индекси массив ([]), андозаи массив (int()), муқоисаи массивҳо 
 (==, <= ) –ро сарборӣ кунед. 
 Класси массиви якченака. Амалҳои дастрасӣ ба индекси 
 массив ([]), муқоисаи массивҳо (==,!=, <= ) ва якҷоякунии 
 массивҳо (+) –ро сарборӣ кунед. 
 Класси маҷмӯъҳоӣ cset. Амалҳои иловакунӣ элемент (set + 
 item), якҷоякунӣ (+), фарқ(-), муқоисакунӣ (==) ва тавоноии 
 маҷмӯъ (int ())-ро сарборӣ кунед. 
 Класси навбатҳои cqueue. Амалҳои иловакунӣ (+) ва 
 несткунии элемент, тафтиши холӣ будан (bool()) ва 
 нусхабардории як навбат ба навбати дигар бо мурраттабкунии 
 аз рӯйи камшавӣ(<) ва тавоноии навбат (int ()) – ро сарборӣ 
 кунед. 
 Класси маҷмӯҳои cset. Амалҳои конструктори маҷмӯъ (), 
 якҷоякунии маҷмӯъҳо (+), муқоисаи маҷмӯъҳо (<=), тавоноии 
 маҷмӯъ (into), дастрасӣ бо элементи аз рӯйи мавқеъ ([]) –ро 
 сарборӣ кунед. 
 Класси баргаҳои якпайвандӣ list. Амалҳои + - якҷоякунии ду 
 рӯйхат, несткунии элемент аз аввали list (--list), муқоисакунӣ 
 (==) ва тафтиши холӣ будан (bool()) –ро сарборӣ кунед. 
 Класси матритса. Амалҳои ҷамъ (+), дастрасӣ бо элемент – 
 (m(c, i)) ва муқоисакунии матритсаҳо (>, ==) – ро сарборӣ 
 кунед. 
 Класси вақт - CVector. Амалҳои иловакунии элемент (+), 
 зиёдкунии ҳамаи элементҳо (cVector++), муқоисакунӣ (! =) ва 
 дастрасӣ бо элемент тавассути зернавис ([]) –ро сарборӣ 
 кунед. 
 Класси вақт - CVector. Амалҳои тарҳ, ҷамъ ва зарби вектор, 
 муқоисакунӣ (!=) ва дастрасӣ бо элемент тавассути зернавис 
 ([]) –ро сарборӣ кунед. 
 Класси stack. Амалҳои иловакунӣ ва несткунии элемент аз 
 стек, тафтиши холӣ будан (bool()) ва нусхабардории як стек ба 
 стеки дигар (>) –ро сарборӣ кунед. 
 Коркарди ҳолатҳои истисноӣ 
 ) Пас аз иҷроиш барномаи зерин чӣ хел натиҷа ба даст меояд? 
 #include<iostream> 
 usingnamespace std; 
 classX; 
 void F(X&x, intn); 
 classX { 
 public: 
 X() { 
 try { 
 F(*this, -); 
 cout << << endl; 
 } 
 catch (X) { 
 cout << << endl; 
 } 
 catch (int) { 
 cout << << endl; 
 } 
 } 
 X(X&) { 
 cout << << endl; 
 } 
 }; 
 classY: publicX { 
 public: 
 Y() { 
 cout << << endl; 
 } 
 Y(Y&a) { 
 cout << << endl; 
 } 
 ~Y() { 
 cout << << endl; 
 } 
 }; 
 void F(X&x, intn) { 
 try { 
 if (n< ) throwx; 
 if (n> ) throw; 
 cout << << endl; 
 } 
 catch (int) { 
 cout << << endl; 
 } 
 catch (X&) { 
 cout << << endl; 
 throw; 
 } 
 } 
 int main() { 
 try { 
 Y a; 
 } 
 catch (...) { 
 cout << << endl; 
 } 
 cout << << endl; 
 system("pause"); 
 return; 
 } 
 ) Пас аз иҷроиш барномаи зерин чӣ хел натиҷа ба даст меояд? 
 #include<iostream> 
 usingnamespace std; 
 classA { 
 public: 
 A() { 
 cout << << endl; 
 } 
 }; 
 classB: publicA { 
 public: 
 B(intn) { 
 try { 
 if (n == ) throw *this; 
 if (n> ) throw; 
 } 
 catch (int) { 
 cout << << endl; 
 } 
 catch (B&) { 
 cout << << endl; 
 throw; 
 } 
 cout << << endl; 
 } 
 B(B&) { 
 cout << << endl; 
 } 
 ~B() { 
 cout << << endl; 
 } 
 }; 
 int main() { 
 try { 
 B b(); 
 B c(); 
 } 
 catch (...) { 
 cout << << endl; 
 } 
 cout << << endl; 
 system("pause"); 
 return; 
 } 
 ) Пас аз иҷроиш барномаи зерин чӣ хел натиҷа ба даст меояд? 
 #include<iostream> 
 usingnamespace std; 
 classX; 
 void F(X&x, intn); 
 classX { 
 public: 
 X() { 
 try { 
 F(*this, -); 
 cout << << endl; 
 } 
 catch (X) { 
 cout << << endl; 
 } 
 catch (int) { 
 cout << << endl; 
 } 
 } 
 X(X&) { 
 cout << << endl; 
 } 
 }; 
 classY: publicX { 
 public: 
 Y() { 
 cout << << endl; 
 } 
 Y(Y&a) { 
 cout << << endl; 
 } 
 ~Y() { 
 cout << << endl; 
 } 
 }; 
 void F(X&x, intn) { 
 try { 
 if (n< ) throwx; 
 if (n> ) throw; 
 cout << << endl; 
 } 
 catch (int) { 
 cout << << endl; 
 } 
 catch (X&) { 
 cout << << endl; 
 throw; 
 } 
 } 
 int main() { 
 try { 
 Y a; 
 }catch (...) { 
 cout << << endl; 
 } 
 cout << << endl; 
 system("pause"); 
 return; 
 } 
 ) Пас аз иҷроиш барномаи зерин чӣ хел натиҷа ба даст меояд? 
 #include<iostream> 
 usingnamespace std; 
 structX; 
 void f(X&x, intn); 
 intconst P =; 
 intconst Q =; 
 intconst R =; 
 structX { 
 X() { 
 try { 
 f(*this, -); 
 cout << << endl; 
 } 
 catch (X) { 
 cout << << endl; 
 } 
 catch (int) { 
 cout << << endl; 
 } 
 } 
 X(X&) { 
 cout << << endl; 
 } 
 ~X() { 
 cout << << endl; 
 } 
 }; 
 structY: X { 
 Y() { 
 f(*this, -); 
 cout << << endl; 
 } 
 Y(Y&) { 
 cout << << endl; 
 } 
 ~Y() { 
 cout << << endl; 
 } 
 }; 
 void f(X&x, intn) { 
 try { 
 if (n< ) throwx; 
 if (n> ) throw; 
 cout << << endl; 
 } 
 catch (int) { 
 cout << << endl; 
 } 
 catch (X& a) { 
 cout << << endl; 
 f(a, ); 
 cout << << endl; 
 throw; 
 } 
 } 
 int main() { 
 try { Y a; } 
 catch (...) { 
 cout << << endl; 
 } 
 cout << << endl; 
 system("pause"); 
 return; 
 } 
 ) Пас аз иҷроиш барномаи зерин чӣ хел натиҷа ба даст меояд? 
 #include<iostream> 
 usingnamespace std; 
 structX; 
 void f(X&x, intn); 
 intconst P =; 
 intconst Q =; 
 intconst R =; 
 structX { 
 X() { 
 try { 
 f(*this, ); 
 cout << << endl; 
 } 
 catch (X) { 
 cout << << endl; 
 } 
 catch (int) { 
 cout << << endl; 
 } 
 } 
 X(X&) { 
 cout << << endl; 
 } 
 ~X() { 
 cout << << endl; 
 } 
 }; 
 structY: X { 
 Y() { 
 f(*this, -); 
 cout << << endl; 
 } 
 Y(Y&) { 
 cout << << endl; 
 } 
 ~Y() { 
 cout << << endl; 
 } 
 }; 
 void f(X&x, intn) { 
 try { 
 if (n< ) throwx; 
 if (n> ) throw; 
 cout << << endl; 
 } 
 catch (int) { 
 cout << << endl; 
 } 
 catch (X& a) { 
 cout << << endl; 
 f(a, ); 
 cout << << endl; 
 throw; 
 } 
 } 
 int main() { 
 try { 
 Y a; 
 }catch (...) { 
 cout << << endl; 
 } 
 cout << << endl; 
 system("pause"); 
 return; 
 } 
 ) Пас аз иҷроиш барномаи зерин чӣ хел натиҷа ба даст меояд? 
 #include<iostream> 
 usingnamespace std; 
 structX; 
 void f(X&x, intn); 
 intconst P =; 
 intconst Q =; 
 intconst R =; 
 structX { 
 X() { 
 try { 
 f(*this, -); 
 cout << << endl; 
 } 
 catch (X) { 
 cout << << endl; 
 } 
 catch (int) { 
 cout << << endl; 
 } 
 } 
 X(X&) { 
 cout << << endl; 
 } 
 ~X() { 
 cout << << endl; 
 } 
 }; 
 structY: X { 
 Y() { 
 f(*this, ); 
 cout << << endl; 
 } 
 Y(Y&) { 
 cout << << endl; 
 } 
 ~Y() { 
 cout << << endl; 
 } 
 }; 
 void f(X&x, intn) { 
 try { 
 if (n< ) throwx; 
 if (n> ) throw; 
 cout << << endl; 
 } 
 catch (int) { 
 cout << << endl; 
 } 
 catch (X& a) { 
 cout << << endl; 
 f(a, ); 
 cout << << endl; 
 throw; 
 } 
 } 
 int main() { 
 try { Y a; } 
 catch (...) { 
 cout << << endl; 
 } 
 cout << << endl; 
 system("pause"); 
 return; 
 } 
 ) Пас аз иҷроиш барномаи зерин чӣ хел натиҷа ба даст меояд? 
 #include<iostream> 
 usingnamespace std; 
 classEx { 
 int code; public: 
 Ex(inti): code(i) {} 
 Ex(constEx&ex): code(ex.code) {} 
 int Get() const { 
 return code; 
 } 
 }; 
 structEx: Ex { 
 Ex(): Ex() {} 
 }; 
 void f() { 
 throwEx(); 
 cout <<"dog"<< endl; 
 } 
 void t() { 
 try { f(); } 
 catch (Ex&x) { 
 cout <<"cat"<< endl; 
 throwEx(x.Get() + ); 
 cout <<"sheep"<< endl; 
 } 
 catch (Ex&) { 
 cout <<"horse"<< endl; 
 } 
 cout <<"cow"<< endl; 
 }; 
 int main() { 
 try { 
 t(); 
 }catch (Ex&x) { 
 cout <<"elephant "<< x.Get() << endl; 
 } 
 catch (...) { 
 cout <<"wolf"<< endl; 
 } 
 system("pause"); 
 return; 
 } 
 ) Пас аз иҷроиш барномаи зерин чӣ хел натиҷа ба даст меояд? 
 #include<iostream> 
 usingnamespace std; 
 classEx { 
 int code; public: 
 Ex(inti): code(i) {} 
 Ex(constEx&ex): code(ex.code) {} 
 int Get() const { 
 return code; 
 } 
 }; 
 structEx: Ex { 
 Ex(): Ex() {} 
 }; 
 void f() { 
 throwEx(); 
 cout <<"sword"<< endl; 
 } 
 void t() { 
 try { f(); } 
 catch (Ex&x) { 
 cout <<"lance"<< endl; 
 throwEx(x.Get() + ); 
 cout <<"dagger"<< endl; 
 }catch (Ex&) { 
 cout <<"knife"<< endl; 
 } 
 cout <<"hammer"<< endl; 
 } 
 int main() { 
 try { t(); } 
 catch (Ex&x) { 
 cout <<"arche "<< x.Get() << endl; 
 } 
 catch (...) { 
 cout <<"pistole"<< endl; 
 } 
 system("pause"); 
 return; 
 } 
 ) Пас аз иҷроиш барномаи зерин чӣ хел натиҷа ба даст меояд? 
 #include<iostream> 
 usingnamespace std; 
 classEx { 
 int code; 
 public: 
 Ex(inti): code(i) {} 
 Ex(constEx&ex): code(ex.code) {} 
 int Get() const { 
 return code; 
 } 
 }; 
 structEx: Ex { 
 Ex(): Ex() {} 
 }; 
 void f() { 
 throwEx(); 
 cout <<"train"<< endl; 
 } 
 void t() { 
 try { 
 f(); 
 } 
 catch (Ex&x) { 
 cout <<"plane"<< endl; 
 throwEx(x.Get() + ); 
 cout <<"helicopter"<< endl; 
 } 
 catch (Ex&) { 
 cout <<"car"<< endl; 
 } 
 cout <<"truck"<< endl; 
 }; 
 int main() { 
 try { 
 t(); 
 } 
 catch (Ex&x) { 
 cout <<"boat "<< x.Get() << endl; 
 } 
 catch (...) { 
 cout <<"rocket"<< endl; 
 } 
 system("pause"); 
 return; 
 } 
 ) Оё барномаи зерин кор мекунад? Ҳангоми иҷроиши он чӣ натиҷа ба даст 
 меояд? 
 #include<iostream> 
 usingnamespace std; 
 void f(X&x,intn); 
 structX { 
 X() { 
 try { 
 f(*this, -); 
 cout <<"a"; 
 } 
 catch (X) { 
 cout <<"b"; } 
 catch (int) { cout <<"c"; } 
 } 
 X(X&) { 
 cout <<"d"; 
 } 
 virtual ~X() { 
 cout <<"e"; 
 } 
 }; 
 structY: X { 
 Y() { 
 try { 
 f(*this, ); 
 cout <<"f"; 
 } 
 catch (Y) { 
 cout <<"g"; 
 } 
 catch (int) { 
 cout <<"h"; 
 } 
 cout <<"i"; 
 } 
 Y(Y&) { cout <<"j"; } 
 ~Y() { cout <<"k"; } 
 }; 
 void f(X&x, intn) { 
 try { 
 if (n< ) 
 throw - n; 
 elseif (n == ) 
 throwx; 
 else 
 thrown; 
 } 
 catch (int) { 
 cout <<"l"; 
 } 
 } 
 int main() { 
 try { 
 Y a; 
 } 
 catch (...) { 
 cout <<"m"; 
 return; 
 } 
 cout <<"n"; 
 system("pause"); 
 return; 
 } 
 ) Пас аз иҷроиш барномаи зерин чӣ хел натиҷа ба даст меояд? 
 #include<iostream> 
 usingnamespace std; 
 void f(X&x, intn); 
 structX { 
 X() { 
 try { 
 f(*this, ); 
 cout <<"a"; 
 } 
 catch (X) { 
 cout <<"b"; 
 } 
 catch (int) { 
 cout <<"c"; 
 } 
 } 
 X(X&) { 
 cout <<"d"; 
 } 
 virtual ~X() { 
 cout <<"e"; 
 } 
 }; 
 structY: X { 
 Y() { 
 try { 
 f(*this, ); 
 cout <<"f"; 
 } 
 catch (Y) { 
 cout <<"g"; 
 } 
 catch (int) { 
 cout <<"h"; 
 } 
 cout <<"i"; 
 } 
 Y(Y&) { 
 cout <<"j"; 
 } 
 ~Y() { 
 cout <<"k"; 
 } 
 void f(X&x, intn) { 
 try { 
 if (n< ) 
 throw - n; 
 elseif (n == ) 
 throwx; 
 elsethrown; 
 } 
 catch (int) { 
 cout <<"l"; 
 } 
 } 
 }; 
 int main() { 
 try { 
 Y a; 
 } 
 catch (...) { 
 cout <<"m"; 
 return; 
 } 
 cout <<"n"; 
 system("pause"); 
 return; 
 } 
 ) Пас аз иҷроиш барномаи зерин чӣ хел натиҷа ба даст меояд? 
 #include<iostream> 
 usingnamespace std; 
 void f(X&x, intn); 
 structX { 
 X() { 
 try { 
 f(*this, ); 
 cout <<"a"; 
 } 
 catch (X) { 
 cout <<"b"; 
 } 
 catch (int) { 
 cout <<"c"; 
 } 
 } 
 X(X&) { 
 cout <<"d"; 
 } 
 virtual ~X() { 
 cout <<"e"; 
 } 
 }; 
 structY: X { 
 Y() { 
 try { 
 f(*this, ); 
 cout <<"f"; 
 } 
 catch (Y) { 
 cout <<"g"; 
 } 
 catch (int) { 
 cout <<"h"; 
 } 
 cout <<"i"; 
 } 
 Y(Y&) { 
 cout <<"j"; 
 } 
 ~Y() { 
 cout <<"k"; 
 } 
 }; 
 void f(X&x, intn) { 
 try { 
 if (n< ) 
 throw - n; 
 elseif (n == ) 
 throwx; 
 else 
 thrown; 
 } 
 catch (int) { 
 cout <<"l"; 
 } 
 } 
 int main() { 
 try { 
 Y a; 
 } 
 catch (...) { 
 cout <<"m"; 
 return; 
 } 
 cout <<"n"; 
 system("pause"); 
 return; 
 } 
 ) Пас аз иҷроиш барномаи зерин чӣ хел натиҷа ба даст меояд? 
 #include<iostream> 
 usingnamespace std; 
 structS { 
 S(inta) { 
 try { 
 if (a> ) 
 throw *this; 
 elseif (a< ) 
 throw; 
 } 
 catch (S&) { 
 cout <<"SCatch_S&"<< endl; 
 } 
 catch (int) { 
 throw; 
 } 
 cout <<"SConstr"<< endl; 
 } 
 S(constS&a) { 
 cout <<"Copy"<< endl; 
 } 
 ~S() { 
 cout <<"Destr"<< endl; 
 } 
 }; 
 int main() { 
 try { 
 S s(), s(-); 
 cout <<"Main"<< endl; 
 } 
 catch (S&) { 
 cout <<"MainCatch_S&"<< endl; 
 } 
 catch (...) { 
 cout <<"MainCatch_..."<< endl; 
 } 
 system("pause"); 
 return; 
 } 
 ) Пас аз иҷроиш барномаи зерин чӣ хел натиҷа ба даст меояд? 
 #include<iostream> 
 usingnamespace std; 
 structS { 
 S(inta) { 
 try { 
 if (a> ) 
 throw *this; 
 else 
 if (a< ) 
 throw; 
 } 
 catch (S&) { 
 cout <<"SCatch_S&"<< endl; 
 } 
 catch (int) { 
 throw; 
 } 
 cout <<"SConstr"<< endl; 
 } 
 S(constS&a) { 
 cout <<"Copy"<< endl; 
 } 
 ~S() { 
 cout <<"Destr"<< endl; 
 } 
 }; 
 int main() { 
 try { 
 S s(), s(); cout <<"Main"<< endl; 
 } 
 catch (S&) { 
 cout <<"MainCatch_S"<< endl; 
 } 
 catch (...) { 
 cout <<"MainCatch_..."<< endl; 
 } 
 system("pause"); 
 return; 
 } 
 ) Пас аз иҷроиш барномаи зерин чӣ хел натиҷа ба даст меояд? 
 #include<iostream> 
 usingnamespace std; 
 structS { 
 S(inta) { 
 try { 
 if (a> ) 
 throw *this; 
 elseif (a< ) 
 throw; 
 } 
 catch (S&) { 
 cout <<"SCatch_S&"<< endl; 
 throw; 
 } 
 catch (int) { 
 cout <<"SCatch_int"<< endl; 
 } 
 cout <<"SConstr"<< endl; 
 } 
 S(constS&a) { 
 cout <<"Copy"<< endl; 
 } 
 ~S() { 
 cout <<"Destr"<< endl; 
 } 
 }; 
 int main() { 
 try { 
 S s(-), s(); 
 cout <<"Main"<< endl; 
 }catch (S&) { 
 cout <<"MainCatch_S&"<< endl; 
 } 
 catch (...) { 
 cout <<"MainCatch_..."<< endl; 
 } 
 system("pause"); 
 return; 
 } 
 Аъзоҳои доимӣ ва статикии классҳо 
 ) Оё дар барномаи зерин хатогӣ вуҷуд дорад? Бе иловакунии аъзоҳои 
 иловагӣ метавон онро ислоҳ кард? 
 #include<iostream> 
 usingnamespace std; 
 classA { 
 public: 
 int y; 
 void f() { 
 cout <<"f"<< endl; 
 } 
 }; 
 intA::y; 
 int main() { 
 A::y =; 
 constA a; 
 a.f(); 
 system("pause"); 
 return; 
 } 
 ) Оё дар барномаи зерин хатогӣ вуҷуд дорад? Бе иловакунии аъзоҳои 
 иловагӣ метавон онро ислоҳ кард? 
 #include<iostream> 
 usingnamespace std; 
 classX { 
 public: 
 void g() { 
 cout <<"g"<< endl; 
 } 
 int h(intn) { 
 cout <<"f"<< endl; 
 returnn; 
 } 
 }; 
 int main() { 
 int k; 
 constX x; 
 X::g(); 
 k = x.h(); 
 system("pause"); 
 return; 
 } 
 ) Оё дар барномаи зерин хатогӣ вуҷуд дорад? Бе иловакунии аъзоҳои 
 иловагӣ метавон онро ислоҳ кард? 
 ) 
 #include<iostream> 
 usingnamespace std; 
 classA { 
 staticint i; 
 staticvoid f() { 
 g(); 
 cout <<"fO"<< endl; 
 } 
 void g() { 
 if (i >= ) i = -, 
 f(); 
 cout <<"g()"<< endl; 
 } 
 }; 
 intA::i =; 
 int main() { 
 A::i =; 
 A a; 
 a.f(); 
 a.i =; 
 system("pause"); 
 return; 
 } 
 ) 
 #include<iostream> 
 usingnamespace std; 
 classA { 
 staticint i; 
 void f() { 
 if (i >= ) i = -, g(); 
 cout <<"f()"<< endl; 
 } 
 void g() { 
 f(); 
 cout <<"g()"<< endl; 
 } 
 }; 
 intA::i =; 
 int main() { 
 A::i =; 
 constA a; 
 a.f(); 
 a.i =; 
 system("pause"); 
 return; 
 } 
 ) 
 #include<iostream> 
 usingnamespace std; 
 classA { 
 staticint i; 
 void f() const { 
 if (i < ) 
 g(i); 
 cout <<"f ()"<< endl; 
 } 
 void g(int&n) { 
 i = n; 
 f(); 
 cout <<"g ()"<< endl; 
 } 
 }; 
 intA::i =; 
 int main() { 
 constA a; 
 a.g(); 
 system("pause"); 
 return; 
 } 
 ) Оё дар барномаи зерин хатогӣ вуҷуд дорад? Бо истифодаи калимаҳои 
 калидӣ онҳоро ислоҳ кунед: 
 ) 
 #include<iostream> 
 usingnamespace std; 
 classA { 
 int i; 
 int f(int&x) { 
 return g(x); 
 } 
 int g(int&x) { 
 if (x>= ) 
 f(-i); 
 return i; 
 } 
 }; 
 intA::i =; 
 int main() { 
 constA a; 
 A::i =; 
 a.f(); 
 cout << a.i =; 
 system("pause"); 
 return; 
 } 
 ) 
 #include<iostream> 
 usingnamespace std; 
 classA { 
 int x; int y; int p() { 
 return y >=? y = -: q(); 
 } 
 int q() const { 
 return p(); 
 } 
 int r() { 
 return x = y; 
 } 
 A(intz) { 
 x = y >? z % y: -y; 
 } 
 }; 
 intA::y =; 
 int main() { 
 A::y =; 
 A::p(); 
 constA b(), b(b); b.q(); 
 cout<<(b.x == ); 
 system("pause"); 
 return; 
 } 
 ) 
 #include<iostream> 
 usingnamespace std; 
 classA { 
 int m; 
 void m() { 
 if (m < ) 
 m(m); 
 } 
 int m(int&n) const { 
 return m(), n; 
 } 
 void m(int&n) { 
 m = m(n); 
 } 
 }; 
 intA::m =; 
 int main() { 
 A::m(); 
 A mm; 
 cout<<mm.m(); 
 system("pause"); 
 return; 
 } 
 ) Оё дар барномаи зерин хатогӣ вуҷуд дорад? На зиёда аз ду дастурро 
 тавре ислоҳ кунед, ки класси овардашуда дуруст кор кунад: 
 #include<iostream> 
 usingnamespace std; 
 classA { 
 public: 
 staticvoid f(intx) { 
 h(x); 
 cout <<"A::f,"<<x<< endl; 
 } 
 void g() { 
 cout <<"A::g"<< endl; 
 } 
 void h(intx) { 
 g(); 
 cout <<"A::h,"<<x<< endl; 
 } 
 }; 
 classB: virtualpublicA { 
 public: 
 staticvoid f(intx) { 
 h(x); 
 cout <<"B::f,"<<x<< endl; 
 } 
 void g() { 
 cout <<"B::g"<< endl; 
 } 
 void h(intx) { 
 g(); 
 cout <<"B::h,"<<x<< endl; 
 } 
 }; 
 int main() { 
 B::f(); 
 B b; 
 A * p = &b; 
 p->f(); 
 p->g(); 
 p->h(); 
 A::f(); 
 system("pause"); 
 return; 
 } 
 ) Класси А-ро тавре муаррифӣ кунед, ки дастурҳои зерин дуруст кор 
 кунанд: 
 ) 
 #include<iostream> 
 usingnamespace std; 
 int A::x; 
 int main() { 
 const A a; 
 a.x =; 
 a.get_(); 
 system("pause"); 
 return; 
 } 
 ) 
 #include<iostream> 
 usingnamespace std; 
 constchar A::a = '+'; 
 int main() { 
 A ob; 
 A::f(); 
 system("pause"); 
 return; 
 } 
 ) 
 #include<iostream> 
 usingnamespace std; 
 int main() { 
 const A x; 
 A::g(); x.h(); 
 system("pause"); 
 return; 
 } 
 Китобхонаи стандартии қолабҳо - STL 
 ) Пас аз иҷроиш барномаи зерин чӣ хел натиҷа ба даст меояд? 
 #include<iostream> 
 #include<vector> 
 usingnamespace std; 
 int main() { 
 vector<bool> v = { true, false, true, false }; 
 vector<int>v(v.begin(), v.end()); // v.flip(); // 
 for (size_t i =; i!= v.size(); ++i) 
 cout << (v[i]& v[i]); 
 system("pause"); 
 return; 
 } 
 ) Пас аз иҷроиш барномаи зерин чӣ хел натиҷа ба даст меояд? 
 #include<iostream> 
 #include<vector> 
 #include<sstream> 
 #include<algorithm> 
 #include<iterator> 
 usingnamespace std; 
 int main() { 
 string str = "To be or not to be...", str; 
 istringstream ist(str); 
 for (int i =; i <; i++) 
 { 
 copy(istream_iterator<char>(ist), istream_itera- 
 tor<char>(), back_inserter(str)); ist.str(str); 
 } 
 cout << str; 
 system("pause"); 
 return; 
 } 
 ) Пас аз иҷроиш барномаи зерин чӣ хел натиҷа ба даст меояд? 
 #include<iostream> 
 #include<vector> 
 #include<sstream> 
 #include<algorithm> 
 #include<iterator> 
 usingnamespace std; 
 int main() { 
 int Arr[] = {,,,,, }; 
 vector<int>Vec(Arr, Arr + (sizeof(Arr) / 
 sizeof(Arr[]))); sort(Vec.begin(), Vec.end()); 
 unique_copy(Vec.begin(), Vec.end(), ostream_itera- 
 tor<int>(cout, " ")); 
 system("pause"); 
 return; 
 } 
 ) Пас аз иҷроиш барномаи зерин чӣ хел натиҷа ба даст меояд? 
 #include<iostream> 
 #include<utility> 
 #include<vector> 
 #include<algorithm> 
 usingnamespace std; 
 typedefpair<int, int>p_int; 
 int main(){ 
 vector<p_int> v; 
 v.push_back(make_pair(, )); 
 v.push_back(make_pair(, )); 
 v.push_back(make_pair(, )); 
 v.push_back(make_pair(, )); 
 sort(v.begin(), v.end()); 
 for (auto&x: v) 
 cout << x.first << x.second; 
 system("pause"); 
 return; 
 } 
 ) Пас аз иҷроиш барномаи зерин чӣ хел натиҷа ба даст меояд? 
 #include<iostream> 
 #include<map> 
 usingnamespace std; 
 int main(){ 
 multimap<char, int> mm{ { 'a', },{ 'b', },{ 'c', },{ 
 'a', },{ 'a', },{ 'c', } }; 
 map<char, int> m(++mm.begin(), mm.lower_bound('c')); 
 for (auto i: m) 
 ++i.second; 
 for (auto i: m) 
 cout << i.second <<' '; 
 system("pause"); 
 return; 
 } 
 ) Пас аз иҷроиш барномаи зерин чӣ хел натиҷа ба даст меояд? 
 #include"stdafx.h" 
 #include<vector> 
 #include<iostream> 
 usingnamespace std; 
 structA { 
 A(inti) { 
 cout <<"A("<<i<<")"; 
 } 
 ~A() { 
 cout <<"~A()"; 
 } 
 }; 
 int main() { 
 vector<A*> a; 
 for (int i =; i <; i++) { 
 a.push_back(newA(i)); 
 } 
 system("pause"); 
 return; 
 } 
 ) Пас аз иҷроиш барномаи зерин чӣ хел натиҷа ба даст меояд? 
 #include<iostream> 
 #include<list> 
 #include<iterator> 
 #include<algorithm> 
 usingnamespace std; 
 int main() { 
 list<int>coll; 
 for (int i =; i <=; ++i) 
 { 
 coll.push_back(i); 
 } 
 list<int>::iterator pos; pos = find(coll.begin(), 
 coll.end(), ); 
 cout <<*pos <<' '; 
 list<int>::reverse_iterator rpos(pos); 
 cout <<*rpos <<' '; list<int>::iterator rrpos; 
 rrpos = rpos.base(); 
 cout <<*rrpos <<' '; 
 system("pause"); 
 return; 
 } 
 ) Хатогии барномаи зеринро ислоҳ кунед. 
 #include<vector> 
 #include<algorithm> 
 #include<cmath> 
 usingnamespace std; 
 int main() { 
 constint Xmin = -; 
 constint Xmax =; 
 vector<double>xArray; 
 vector<double>yArray; 
 for (int i = Xmin; i < Xmax; i +=.) 
 { 
 xArray.push_back(i); 
 yArray.push_back(sin(i)); 
 i +=.; 
 } 
 system("pause"); 
 return; 
 } 
 БОБИ. ИМКОНИЯТҲОИ ГРАФИКИИ С++ 
 Муқаддима 
 Нақши графикҳо дар барноманависӣ, корҳои илмиву тадқиқотӣ ва ғайра 
 хеле калон мебошад. Яке анвои татбиқи графикҳо ин графики функсияҳо, 
 графики зиёдшавӣ ё камшавии аҳолӣ, графики боду ҳаво, графики нархҳои 
 бозор ва ғайра мебошад. Ба намуди графикӣ тасвир намудани ҳалли масъала 
 аёнияти онро ифода намуда, мақсади масъаларо ба хонанда возеҳ мегардонад.
 Дар ин боб барои тасвир намудани графикҳо аз Bloodshed Dev C++ 
 истифода мебарем. Саҳифаи тасвири ин забонҳо дар ду реҷа: реҷаи матнӣ ва 
 графикӣ амал мекунад. Ҳамаи он амалиётеро, ки то ҳол анҷом додем, дар 
 муҳити матнӣ буд, акнун дар ин боб олати графикиро дида мебароем. Яъне 
 дар ин боб муайян мекунем, ки забони С++ чӣ қадар имконият ё қудрати бо 
 график кор карданро дорад. Дар ҳолати графикӣ саҳифаи тасвир маҷмӯе аз 
 нуқтаҳо аст, ки ҳар нуқта як пиксел номида мешавад. Миқдори нуқтаҳо чӣ 
 қадар зиёд бошанд, сифати расм ҳамон қадар хубтар мешавад. Дар аксар 
 мавридҳо ҳолати графикӣ ба намуди х, х, х ва х 
 истифода бурда мешавад. Дар ин ҳолатҳо адади якум миқдори нуқтаҳоро ба 
 намуди уфуқӣ ва адади дуюм бошад, миқдори нуқтаҳоро ба намуди амудӣ 
 ифода мекунад, яъне х маънои онро дорад, ки васеъгии саҳифаи 
 графики нуқта ё пиксел ва дарозии он бошад, ба ба нуқта ё пиксел 
 баробар аст. Ба таври умумӣ саҳифаи графикии андозаи х намуди 
 зеринро дорад. Расми. 
 Расми. Шакли умумии саҳифаи график 
 Дар ин ҷо гӯшаи тарафи чап, яъне нуқтаҳои (; ) ҳамчун мабдаъ ё 
 ибтидо фаҳмида мешаванд. 
 Функсияҳои графикӣ дар муҳити Dev C++ 
 Забони Dev c++ баръакси дигар забонҳо функсияҳои зиёди графикиро 
 истифода мебарад, ки бо пайваст кардани библиотекаи <graphics.h> ба кор 
 медароянд. Ин библиотека аслан ҳангоми насб намудани барномаи Devc++ 
 мавҷуд нест. Онро метавон аз интернет 
 (http://kpolyakov.spb.ru/school/c/faq.htm), ба таври ройгон дастрас кард. Пас аз
 дастрас кардани китобхонаи мазкур онро дар компютер насб мекунем. 
 Библиотекаи мазкур аз ду қисмат иборат аст. Папкаи include ва lib дар дохили
 папкаи include файли <graphics.h> мавҷуд аст, ки онро нусхабардорӣ намуда,
 ба суроғае, ки дар он ҷо китобхонаҳои Dev c++ ҷойгиранд, мегузорем. 
 Масалан, “C:\\ Dev-Cpp\\include”. Дар дохили папкаи lib бошад, файли libbgi.a
 мавҷуд аст, ки онро нусхабардорӣ карда, ба суроғаи “C:\ Dev-Cpp\\lib” 
 мегузорем. Баъд барномаи Dev C++-ро ба кор омода месозем, яъне фармони 
 “Пуск-Все программи -> Bloodshed Dev-C++->Dev c++”-ро иҷро мекунем. Аз 
 менюи tools фармони Compiler options-ро иҷро карда, дар сатри “add these 
 commands to the linker command line “ –фармони “ -lbgi -lgdi -lcomdlg -luuid
 -loleaut -lole”-ро навишта, тугмачаи ok-ро пахш мекунем (Расми ). 
 Расми. 
 Ба ҳамин китобхонаи графикӣ насб карда шуда, забони Dev C++ омода 
 барои тасвири графикҳо мегардад. 
 Маълумотҳои умумӣ дар бораи ҳолати графикӣ 
 Пас аз насби библиотекаи <graphics.h> барои ба ҳолати графикӣ дастрас
 шудан аз функсияи initgraph() истифода мебарем. Наҳви истифодаи функсияи 
 мазкур намуди зеринро дорад: 
 void initgraph(int *driver, int *mode, char *directory) 
 Функсияи мазкур ҳолати графикиро баррасӣ мекунад, то ин ки ба 
 тағйирёбандаи driver ва mode қимат диҳад. Дар ин ҷо driver роҳандози графикӣ
 буда, бе истифодаи он ягон функсияи графикӣ кор намекунад. Дар 
 библиотекаи <graphics.h> якчанд роҳандозҳои графикӣ муаррифӣ шуда, 
 намунаашон дар ҷадвали поён оварда шудаанд. Барои барномасоз ё 
 истифодабаранда лозим нест, ки номи ҳар яке аз ин макросҳоро бидонад, 
 балки қимати онҳоро донистан кифоягӣ мекунад. 
 № Доимӣ ё номи макрос Қимат 
 DETECT 
 CGA 
 MCGA 
 EGA 
 EGA- 
 EGAMONO 
 HERCMONO 
 VGA 
 Ҷадвали. Расми. 
 Параметри mode як адади бутун аст, ки ҳолати гракфикӣ (video mode)- 
 ро мушаххас мекунад. Параметри охирон, яъне directory бошад, сатрест, ки 
 дар куҷо будани роҳандозии графикиро нишон медиҳад. Агар библиотекаи 
 графикӣ, яъне <graphics.h> дар дохили папкаи include-и минтақае, ки дар он
 ҷо Dev C++ насб шудааст, бошад, нишон додани суроға ё роҳи он лозим нест,
 танҳо ба ҷойи он дар параметри охирон сатри холӣ нишон дода мешавад. 
 Мисол. Дар қитъаи барномаи дар поён овардашуда тарзи истифода 
 бурдани саҳифаи графикӣ ва роҳандозҳои графикӣ нишон дода шудаанд: 
 #include<iostream> 
 usingnamespace std 
 #include<graphics.h> 
 #definedirectory"C:\ Dev-Cpp\\bgi"; 
 int main() 
 { 
 int driver = DETECT; 
 int mode =; 
 initgraph(&driver, &mode, directory); 
 system("pause"); 
 closegraph(); 
 return; 
 } 
 Тавре ки дида мешавад, дар ин ҷо параметри directory ба суроғаи 
 роҳандозҳои графикӣ ишорат мекунад. Чи хеле ки гуфтем, метавонад он сатри
 холие бошад, қимати параметри driver бошад, як роҳандози графикӣ, яъне 
 driver=DETECT мебошад. Ба ҷойи номи DETECT метавонем қимати он, яъне 
 нависем. Параметри mode тавре ки зикр шуд, як адади бутун мебошад. Барои
 ҳолати графикиро интизор нигоҳ доштан функсияи getch() истифода бурда 
 мешавад, ки он аъзои китобхонаи <conio.h> мебошад. 
 Баромадан аз ҳолати графикӣ 
 Баъд аз он ки кори муҳити графикӣ ба анҷом расид, бояд ки ба ҳолати 
 матнӣ баргардем. Барои иҷрои ин амал функсияи closegraph() истифода бурда
 мешавад. Ин функсия кори ҳолати графикиро ба анҷом расонида, 
 идоракуниро ба ҳолати матнӣ бармегардонад. Барои якбора ҳам аз ҳолати 
 матнӣ ва ҳам графикӣ баромадан функсияи rectorectmode() истифода бурда 
 мешавад. Аз ин ҷо мисоли болоро метавонем ба сурати зерин низ навишт: 
 #include<iostream> 
 usingnamespace std 
 #include<graphics.h> 
 int main() 
 { 
 int driver =; 
 int mode =; 
 initgraph(&driver, &mode, " "); 
 system("pause"); 
 restorecrtmode(); 
 return; 
 } 
 Истифодаи рангҳо дар график 
 Дар ҳолати графикӣ ранг истифода бурда мешавад. Барои дастрас 
 шудан ба рангҳо ё истифода намудани рангҳо функсияҳои setcolor() ва 
 setbkcolor() истифода бурда мешаванд. Функсияи setcolor() ранги расми 
 тасвиркардашуда (яъне хатҳои расм)-ро тағйир медиҳад ва функсияи 
 setbkcolor() бошад, ранги заминаро тағйир медиҳад. Наҳви умумии ин 
 функсияҳо шакли зеринро дорад: 
 void setcolor(int color); 
 void setbkcolor(int color); 
 Дар ин ҷо ба сифати аргументи color метавонем аз қимати рангҳо ё аз 
 доимие, ки номи рангро ифода мекунад, истифода барем. Дар ҷадвали зерин 
 ҳамаи ин намуди рангҳо ва қимати онҳо оварда шудааст: 
 № Номи ранг бо тоҷикӣ Доимие, ки номи Қимати ранг 
 рангро ифода мекунад. 
 Сиёҳ Black 
 Обӣ Blue 
 Сабз Green 
 Кабуд Cyan 
 Қирмизӣ Red 
 Бунафш Magenta 
 Қаҳваранг Brown 
 Хокистарранги равшан Light gray 
 Хокистарранги тира Dark gray 
 Обии равшан Light blue 
 Сабзи равшан Light green 
 Кабуди равшан Light cyan 
 Қирмизии равшан Light red 
 Бунафши равшан Light magenta 
 Зард Yellow 
 Сафед White 
 Ҷадвали. Расми. 
 Функсияи initwindow(int width, int height, const char *title=”Windows
 BGI”) 
 Функсияи мазкур яке аз функсияҳои асоситарин ба ҳисоб рафта, 
 имконияти дастрас шудан ба саҳифаи тасвирро медиҳад. Дар ин ҷо 
 параметрҳои int width, int height мувофиқан васеъгӣ ва дарозии саҳифаи 
 намоишро бо пиксел ифода мекунанд. Параметри title сатрест, ки дар 
 сарлавҳаи саҳифаи графикӣ навишта мешавад. Ҳангоми истифода намудани 
 ин функсия зарур нест, ки функсияи initgraph) истифода карда шавад. 
 Мисол. Барномаи мисоли -ро бо истифодаи функсияи initwindow() 
 дида мебароем: 
 #include<iostream> 
 usingnamespace std 
 #include<graphics.h> 
 int main() 
 { 
 initwindow(,, "Мухитиграфики"); 
 system("pause"); 
 closegraph(); 
 return; 
 } 
 Функсияи мазкурро метавон ба сурати initwindow(,) низ истифода
 кард. Дар ин сурат танҳо андозаи саҳифаи графикӣ нишон дода мешавад. Чӣ 
 қадаре ки қимати параметрҳои width ва height зиёд бошанд, ҳамон қадар 
 саҳифаи графикӣ калон нишон дода мешавад ва баръакс. 
 Функсияи arc(int x, int y, int start, int end, int radius) 
 Ин функсия камонеро аз start то end ба намуди нимдоира, ки маркази он
 x, y буда, радиусаш ба radius баробар аст, тасвир мекунад. Ранги хатҳои 
 нимдоираро метавонем, тавассути функсияи setcolor() тағйир дод. 
 Мисол. Барномаи зерин камонеро тасвир мекунад, ки маркази он 
 нуқтаҳои, буда, ибтидои он нуқтаи, интиҳои он нуқтаи ва 
 радиусаш ба баробар аст. 
 #include<iostream> 
 usingnamespace std 
 #include<graphics.h> 
 int main() 
 { 
 initwindow(,, "Нимдоира"); 
 arc(,,,, ); 
 system("pause"); 
 closegraph(); 
 return; 
 } 
 Қайд. Рақамҳое, ки ба сифати аргументи функсияи мазкур омада бо 
 пиксел ҳастанд. 
 Функсияи bar(int left, int top, int right, int bottom) 
 Функсияи мазкур як росткунҷаеро тасвир намуда, бо ранги ҷорӣ пур 
 мекунад. Барои бо ранги дилхоҳ пур намудани он функсияи setfillstyle() 
 истифода бурда мешавад. Параметрҳои int left, int top координатаҳои болоӣ ва
 чапи росткунҷаро ифода мекунанд. Параметрҳои right ва bottom бошанд, 
 координатаҳои поёнӣ ва рости росткунҷаро ифода мекунанд. 
 Мисоли. Барномаи зерин дар саҳифаи тасвир росткунҷаеро тасвир 
 мекунад, ки координатаҳои чап ва болои он ба, баробар буда, 
 координатаҳои рост ва поёнии он ба, баробар мебошанд. 
 #include<iostream> 
 usingnamespace std 
 #include<graphics.h> 
 int main() 
 { 
 initwindow(,, "Росткунча"); 
 setfillstyle(, ); 
 bar(,,, ); 
 system("pause"); 
 closegraph(); 
 return; 
 } 
 Дар ин ҷо барои бо ранги бунафши равшан пур намудани росткунҷа 
 функсияи setfillstyle(,) истифода бурда шудааст. 
 Функсияи bard(int left, int top, int right, int bottom, int depth, int
 topflag) 
 Ин функсия бошад, параллелопипедеро тасвир мекунад, ки умқи он ба 
 depth пиксел баробар мебошад. Агар қимати depth ба баробар бошад, ин 
 функсия монанди функсияи bar() амал мекунад, яъне ин аргумент масофаи 
 байни сатҳи пас ва пешро ифода мекунад. Ин аргумент ва аргументҳои дигар 
 дар расми нишон дода шудаанд. 
 Расми. Шакли умумии параллелопипеди тасвиршаванда 
 Монанди функсияи bar() расми тасвирнамударо ин функсия низ бо ранги 
 ҷорӣ пур мекунад, барои расмро бо ранги дилхоҳ пур кардан аз функсияи 
 setfillstyle() истифода бурда мешавад. Агар параметри topflag баробари 
 бошад, хати сарҳадии болоӣ тасвир карда намешавад. 
 Мисол. Барномаи зерин параллелопипедеро тасвир намуда, онро бо 
 ранги қирмизӣ пур мекунад. 
 #include<iostream> 
 usingnamespace std 
 #include<graphics.h> 
 int main() 
 { 
 initwindow(,, " Параллелопипед "); 
 setfillstyle(, ); 
 bard(,,,,, ); 
 system("pause"); 
 closegraph(); 
 return; 
 } 
 Функсияи circle (int x, int y, int radius) 
 Функсияи мазкур доираеро тасвир мекунад, ки маркази он нуқтаҳои x, 
 y буда, радиусаш ба radius баробар мебошад. Ранги хатҳои давраро метавон 
 тавассути функсияи setcolor() тағйир дод. 
 Мисол. Барномаи зерин давраеро тасвир мекунад, ки маркази он 
 нуқтаҳои, буда, радиуси он ба пиксел баробар мебошад. 
 #include<iostream> 
 usingnamespace std 
 #include<graphics.h> 
 int main() 
 { 
 initwindow(,, "Давра"); 
 circle(,, ); 
 system("pause"); 
 closegraph(); 
 return; 
 } 
 Функсияи ellipse(int x, int y, int start, int end, int xradius, int yradius)
 Ин функсия расми эллипсеро тасвир мекунад, ки маркази он нуқтаҳои 
 (x, y) буда, дарозии радиусҳои он ба (xradius, yradius) баробар мебошанд.
 Параметрҳои start ва end бошанд, мувофиқан ибтидо ва интиҳои эллипсро 
 ифода мекунанд. Агар start= ва end = бошад, эллипс ба пуррагӣ нишон 
 дода мешавад. Ба таври дигар гӯем, параметрҳои start ва end координатаҳои
 даврагии ибтидо ва интиҳои эллипсро мушаххас мекунанд, ки муқобили 
 ҳаракати ақрабаки соат ҳаракат мекунанд. Агар параметри xradius ба yradius
 баробар бошад, давра тасвир карда мешавад. Ҳамаи параметрҳои функсияи 
 мазкур дар расми зерин нишон дода шудаанд. 
 Расми. Эллипс 
 Мисол. Барномаи зерин расми эллипсеро тасвир мекунад, ки маркази он 
 (; ) буда, нуқтаи ибтидоияш, нуқтаи интиҳоияш ба пиксел ва 
 дарозии радиусҳояш ба (; ) баробар мебошанд. 
 #include<iostream> 
 usingnamespace std 
 #include<graphics.h> 
 int main() 
 { 
 initwindow(,, "Эллипс"); 
 ellipse(,,,,, ); 
 system("pause"); 
 closegraph(); 
 return; 
 } 
 Функсияҳои line(int startx, int starty, int endx, int endy), lineto(int x,
 int y) ва linerel(int dx, int dy) 
 Функсияи line() як хатеро сар карда аз нуқтае, ки координатаҳои он 
 (startx, starty) мебошанд, ба нуқтае, ки координатаҳои он (endx, endy) 
 мебошанд, тасвир мекунад. 
 Функсияи lineto () як хатеро ба ранги расми ҷорӣ аз маҳалли ҷорӣ (СP)
 то нуқтаи (x, y) тасвир мекунад ва маҳали ҷорӣ (текущегоположения ) –ро дар
 (x,y) қарор медиҳад. 
 Функсияи linerel() бошад, як хатеро аз маҳали ҷорӣ ба (dx, dy) тасвир
 мекунад, яъне дар зери меҳвари x бо андозаи dx ва дар зери меҳвари y ба 
 андозаи dy расм мекунад. 
 Мисоли. Тасвири хатҳо. 
 #include<iostream> 
 usingnamespace std 
 #include<graphics.h> 
 int main() 
 { 
 initwindow(,, "Тасвирихатҳо"); 
 line(,,, ); 
 lineto(, ); 
 linerel(, ); 
 system("pause"); 
 closegraph(); 
 return; 
 } 
 Мисоли. Барномаи зерин дар саҳифаи ҳарфи А. М-ро тасвир мекунад. 
 #include<iostream> 
 usingnamespace std 
 #include<graphics.h> 
 int main() 
 { 
 initwindow(,, "Ҳарфи авали ном ва насаб"); 
 line(,,, ); 
 line(,,, ); 
 line(,,, ); 
 line(,,, ); 
 circle(,, ); 
 line(,,, ); 
 line(,,, ); 
 line(,,, ); 
 line(,,, ); 
 moveto(, ); 
 outtext("АлиевМуртазо"); 
 system("pause"); 
 closegraph(); 
 return; 
 } 
 Функсияи rectangle (int left, int top, int right, int bottom) 
 Ин функсия росткунҷаеро тасвир мекунад, ки координатаҳои чап ва 
 болои он ба (left, top) баробар буда, координатаҳои рост ва поёнии он ба (right,
 bottom) баробар мебошанд. Ранги замина ва хатҳои росткунҷаро метавон бо 
 ёрии функсияҳои setlinestyle() ва setcolor() тағйир дод. 
 Мисол. Мисоли зерин ҳарфҳои А.М-ро, ки дар мисоли гузашта тасвир 
 шуда буданд, дар дохили як росткунҷа мегирад. 
 #include<iostream> 
 usingnamespace std 
 #include<graphics.h> 
 int main() 
 { 
 initwindow(,, 
 "Ҳарфиаввалинасабваномдардохилиросткунҷа"); 
 line(,,, ); 
 line(,,, ); 
 line(,,, ); 
 line(,,, ); 
 circle(,, ); 
 line(,,, ); 
 line(,,, ); 
 line(,,, ); 
 line(,,, ); 
 rectangle(,,, ); 
 moveto(, ); 
 outtext("Hello World"); 
 system("pause"); 
 closegraph(); 
 return; 
 } 
 Функсияи void fillellipse( int x, int y, int xradius, int yradius)
 Функсияи мазкур барои тасвир намудани эллипсе, ки дохилаш бо рангӣ 
 ҷори пур карда шудааст, хизмат мекунад. Ранги дохил ва хатҳои онро метавон
 бо ёрии функсияи setfillstyle() тағйир дод. 
 Мисол. Барномаи зерин эллипсеро тасвир намуда, бо ёрии функсияи 
 setfillstyle() дохилӣ онро бо ранги зард пур мекунад. 
 #include<iostream> 
 usingnamespace std 
 #include<graphics.h> 
 int main() 
 { 
 initwindow(,, "Расми эллипсӣ дохилаш аз ранг 
 пур"); 
 setfillstyle(, ); 
 fillellipse(,,, ); 
 system("pause"); 
 closegraph(); 
 return; 
 } 
 Функсияи pieslice(int x, int y, int start, int end, int radius)
 Ин функсия барои тасвир намудани сектори доира, ки маркази он 
 нуқтаҳои (x, y) буда, радиуси он ба radius баробар аст, хизмат мекунад. 
 Параметрҳои start ва end бошанд, мувофиқан координатаҳои аввала ва охири 
 доираро, ки муқобили ҳаракати ақрабаки соат тасвир шудаанд, ифода 
 мекунад. Агар қимати start= ва қимати end = бошад, функсияи мазкур 
 давраи пурраро тасвир мекунад. Ин функсия низ дохили доираро бо ранги 
 ҷорӣ пур мекунад ва ранги дохили он ва хатҳои онро метавон тавассути 
 функсияҳои setcolor() ва setfillstyle() тағйир дод. 
 Мисол. Барномаи зерин нимдоираеро тасвир намуда, бо ёрии функсияи 
 setfillstyle() бо ранг пур мекунад. 
 #include<iostream> 
 usingnamespace std 
 #include<graphics.h> 
 int main() 
 { 
 initwindow(,, "секторидоира"); 
 setfillstyle(, ); 
 pieslice(,,,, ); 
 system("pause"); 
 closegraph(); 
 return; 
 } 
 Функсияи sector(int x, int y, int start, int end, int xradius, int yradius )
 Ин функсия барои тасвир намудани сектори эллипс (дарҳолати xra- 
 dius≠yradius будан) ё сектори давра (дарҳолати xradius =yradius будан)-е, ки
 маркази он нуқтаҳои (x, y) буда, радиусҳои он ба xradius ва yradius баробаранд,
 хизмат мекунад. Параметрҳои xradius ва yradius радиуси эллипсро нисбат ба
 тирҳои координатӣ ифода мекунанд. Параметрҳои start ва end ҳудудҳо ё 
 нуқтаҳои сарҳадии эллипсро ифода мекунанд. Дар ҳолати қимати start= ва 
 қимати end = будан, давра тасвир карда мешавад. 
 Мисол. Барномаи зерин сектори эллипсеро дар саҳифаи тасвир расм 
 мекунад. 
 #include<iostream> 
 usingnamespace std 
 #include<graphics.h> 
 int main() 
 { 
 initwindow(,, "секторидоира"); 
 setfillstyle(, ); 
 sector(,,,,, ); 
 system("pause"); 
 closegraph(); 
 return; 
 } 
 Функсияи drawpoly(int numpoints, int *points) 
 Ин функсия хатҳои шикастаи сарбастаро тасвир мекунад. Миқдори 
 нуқтаҳое, ки ин хатҳои шикаста бо ҳамдигар пайваст мешаванд, дар 
 параметри numpoints нишон дода мешаванд. Ҳар як нуқта дорои ду 
 координата (x,y) мебошад. Ин координатаҳо дар массиве нигоҳ дошта 
 мешаванд, ки параметри *numpoints ишора ба ҳамон массив мекунад. 
 Масалан, барномаи зерин секунҷаеро тасвир мекунад. 
 #include<iostream> 
 usingnamespace std 
 #include<graphics.h> 
 int main() 
 { 
 int a[] = {,,,,,,,,, 
 }; 
 initwindow(,, "Секунча"); 
 drawpoly(, a); 
 system("pause"); 
 closegraph(); 
 return; 
 } 
 Функсияи fillpoly (int num points, int *points) 
 Ин функсия низ монанди функсияи drawpoly() амал намуда, графики 
 тасвир шударо бо ранги ҷорӣ пур мекунад. Ранги фигура ва хатҳои фигураро 
 метавон тавассути функсияи setfillstyle() тағйир дод. 
 Мисол. Барномаи зерин секунҷаи росткунҷаеро тасвир намуда, бо ягон 
 ранг дохили онро пур мекунад: 
 #include<iostream> 
 usingnamespace std 
 #include<graphics.h> 
 int main() 
 { 
 int a[] = {,,,,,,, 
 }; 
 initwindow(,, "Росткунча"); 
 setfillstyle(, ); 
 fillpoly(, a); 
 system("pause"); 
 closegraph(); 
 return; 
 } 
 Функсияи putpixel (int x, int y, int color) 
 Ин функсия рангеро, ки дар параметри color нишон дода шудааст, 
 ҳамчун нуқтае дар координатаҳои (x, y) тасвир мекунад. 
 Мисол. Барномаи зерин графики функсияи тригонометрии y=cos(x)-ро 
 тасвир мекунад. 
 #include<iostream> 
 usingnamespace std 
 #include<graphics.h> 
 int main() 
 { 
 float x, dx, x, x, y; 
 int mx, my, x, y, px, py; 
 x =; y =; mx =; my =; 
 initwindow(,, "Графики функсияи тригонометри"); 
 line(, y,, y); //координатаи у 
 line(x,, x, ); //координатаи х 
 x = -; 
 x =; 
 dx =.; 
 x = x; 
 while (x < x) 
 { 
 y = cos(x); 
 px = x + x*mx; 
 py = y - y*my; 
 putpixel(px, py, WHITE); 
 x += dx; 
 } 
 system("pause"); 
 closegraph(); 
 return; 
 } 
 Функсияи getpixel(int x, int y) 
 Ин функсия рангеро, ки дар координатаҳои (x,y) нишон дода шудааст, 
 бармегардонад. Масалан, оператори зерин нуқтаеро, ки дар координатаҳои 
 (, ) нишон дода шудааст, ба тағйирёбандаи color қарор медиҳад: 
 color=getpixel(,); 
 Функсияи getimage(int left, int top, int right, int bottom, void *buf)
 Ин функсия қисмате аз саҳифаи тасвири графикиро, ки гӯшаи чап ва 
 болои он ба left ва top ва гӯшаи рост ва поёнии он ба right ва bottom баробарро
 ба ноҳияе аз ҳофиза, ки ба buf ишора карда шудааст, нусхабардорӣ мекунад.
 Барои муайян кардани ҳаҷми тасвир функсияи imagesize() истифода бурда 
 мешавад. 
 Функсияи putimage(int x, int y, void *buf, int op) 
 Ин функсия тасвире, ки функсияи getimage() дар ҳофиза гирифтааст, дар
 маҳалли x, y мегузорад. Параметри op дар рӯи саҳифа чигуна навишта шудани
 тасвирро муайян мекунад. Барои интанҳо донистани қиматҳои (x, y) кофӣаст.
 Қиматҳои op, ки наҳви зо-ҳир шудани графикро дар саҳифаи тасвир ифода 
 мекунанд, дар ҷадвали зерин оварда шудаанд. 
 № Номи макрос Қимат 
 COPY_PUT 
 XOR_PUT 
 OR_PUT 
 AND_PUT 
 NOT_PUT 
 Ҷадвали.Ҷадвали макросҳо 
 Функсияи imagesize(int left, int top, int right, int bottom) 
 Ин функсия барои муайян кардани андозаи расм хизмат мекунад. Мисол. 
 Барномаи зерин шаклеро тасвир мекунад. Аввал тавассути функсияи 
 imagesize() андозаи расм муайян карда мешавад, баъд бо ёрии функсияи 
 getimage() он расм нусхабардорӣ карда шуда, дар ду ҷойи саҳифаи тасвир 
 гузошта мешавад. 
 #include<iostream> 
 usingnamespace std 
 #include<graphics.h> 
 int main() 
 { 
 initwindow(,, "Нусхабардорӣ кардан ва гузоштани 
 расм"); 
 unsigned size; 
 void *buf; 
 setcolor(); 
 line(,,, ); 
 setcolor(); 
 line(,,, ); 
 setcolor(); 
 line(,,, ); 
 setcolor(); 
 line(,,, ); 
 setcolor(RED); 
 line(,,, ); 
 setcolor(GREEN); 
 line(,,, ); 
 getch(); 
 size = imagesize(,,, ); 
 if (size!= -) 
 buf = malloc(size); 
 if (buf) 
 { 
 getimage(,,,, buf); 
 putimage(,, buf, COPY_PUT); 
 putimage(,, buf, COPY_PUT); 
 } 
 outtext("Press a key"); 
 closegraph(); 
 return; 
 } 
 Функсияи floodfill (int x, int y, int border) 
 Функсияи мазкур як расми тасвиршударо бо ранги додашуда пур 
 мекунад. Дар ин ҷо x ва y координатаҳои дохили расм мебошанд. Расми 
 тасвиркарлашуда бояд сарбаст бошад, вагарна беруни он низ ранг карда 
 мешавад. 
 Мисол. Барномаи зерин ранги саҳифаи тасвирро бо хатчаҳои сурх пур 
 намуда, сипас, бо ранги зард расми росткунҷаеро тасвир мекунад. 
 #include<iostream> 
 usingnamespace std 
 #include<graphics.h> 
 int main() 
 { 
 initwindow(,, "Ранг намудани саҳифаи тасвир"); 
 setfillstyle(HATCH_FILL, RED); 
 floodfill(,, GREEN); 
 setcolor(); 
 rectangle(,,, ); 
 system("pause"); 
 closegraph(); 
 return; 
 } 
 Функсияҳои getmaxx(void) ва getmaxy(void) 
 Ин функсияҳо ба тартиб бузургтарин қиматҳои (x,y)-ро барои ҳолати 
 графикӣ бармегардонанд, яъне ин функсия андозаи саҳифаи тасвирро муайян 
 мекунанд. 
 Барномаи зерин андозаи саҳифаи тасвирро муайян намуда, дар саҳифаи 
 матнӣ онро менависад: 
 #include<iostream> 
 usingnamespace std 
 #include<graphics.h> 
 int main() 
 { 
 initwindow(,, "Саҳифаитасвир"); 
 cout <<"x="<< getmaxx() << endl; 
 cout <<"y="<< getmaxy() << endl; 
 system("pause"); 
 closegraph(); 
 return; 
 } 
 Мисоли дигар. Тасвири секунҷа бо хатҳои моил. 
 #include<iostream> 
 usingnamespace std 
 #include<graphics.h> 
 int main() 
 { 
 int i =; 
 initwindow(,, " "); 
 i = -getmaxy(); 
 while (i <= getmaxy()) 
 { 
 line(, i, getmaxy(), i - getmaxx()); 
 i +=; 
 } 
 system("pause"); 
 closegraph(); 
 return; 
 } 
 Функсияҳои getx() ва gety() 
 Ин функсияҳо мавқеи ҷории рӯйи саҳифаи тасвирро бармегардонанд. 
 Мисол.cout <<"x = "<< getx() <<"y = "<< gety() << endl; 
 Функсияҳои gotoxy(int x, int y) ва moveto(int x, int y) 
 Ин функсияҳо бошанд, мавқеи ё макони курсорро рӯйи саҳифаи тасвир 
 дар координатаҳо бо (x,y) мушаххасшуда қарор медиҳад. 
 Функсияҳои outtext(char *str) ва outtextxy(int x, int y, char *str)
 Функсияи аввала дар маҳалли ҷорӣ, рӯи саҳифаи тасвир матнеро, ки дар
 параметри str нишон дода шудаст, менависад. Дар ҳолати графикӣ макони 
 курсор намоиш дода намешавад, аммо хатсайри маҳалли ҷории он ҳифз карда 
 мешавад. Функсияи outtextxy() бошад, матнӣ дар параметри str нишон 
 додашударо дар маҳалли ба (x,y) нишондодашуда менависад. 
 Функсияи settextstyle(int font, int direction, int charsize) 
 Ин функсия барои андоза ва намуди ҳуруфотро дар саҳифаи тасвир 
 мушаххас кардан, истифода бурда мешавад. Параметри direc-tion чӣ тавр 
 навишта шудани матнро муайян мекунад. Матн бо ёрии функсияи outtext() ё 
 outtextxy() навишта мешавад. Ба сифати қимати параметри font яке аз 
 доимиҳои ҷадвали зерин истифода бурда мешаванд. 
 № Доимӣ Маъно Қимат 
 DEFAULT_FONT Матнро ба намуди стандарти 
 дар қолаби х чоп мекунад. 
 TRIPLEX_FONT Ҳуруфи triplex 
 SMALL_FONT Ҳарфи хурд 
 SANSSERIF_FONT Ҳуруфи SansSerif 
 GOTHIC_FONT Ҳуруфи готикӣ 
 Ҷадвали. Ҷадвали ҳуруфот 
 Равиши намоиши матн аз боло ба поён ё аз чап ба рост шуда метавонад.
 Барои равиши матнро муайян кардан аз макросҳои HORIZ_DIR() ва 
 VERT_DIR() истифода бурда мешавад. Параметри size бошад, андозаи 
 матнро муайян мекунад ва қиматҳои он бошанд, аз то шуда метавонанд. 
 Масалан, барномаи зерин матнеро бо ҳарфи калон дар саҳифаи тасвир 
 менависад: 
 #include<iostream> 
 usingnamespace std 
 #include<graphics.h> 
 int main() 
 { 
 initwindow(,, "Саҳифаи тасвир"); 
 settextstyle(DEFAULT_FONT,, ); 
 outtext("Student"); 
 system("pause"); 
 closegraph(); 
 return; 
 } 
 Функсияи setcolor (int color) 
 Функсияи setcolor (int color) барои ранги хатҳои графикро муайян кардан
 истифода бурда мешавад. Параметри color яке аз коди рангҳои ҷадвали 
 мебошад. 
 Мисол. Барномаи зерин доирачаҳои гуногун рангро дар сафҳаи тасвир 
 нишон медиҳад: 
 #include<iostream> 
 usingnamespace std 
 #include<graphics.h> 
 int main() 
 { 
 int i =; 
 initwindow(,, " "); 
 int gd, gm, ec, uf; 
 gd = DETECT; 
 gm =; 
 ec =; 
 for (gm =; gm <=; gm++) { 
 ec++; 
 if (ec == ) 
 ec =; 
 setcolor(ec); 
 int w = rand() % (); 
 circle(rand() % (getmaxx()), rand() % 
 (getmaxy()), rand() % (gd + )); 
 } 
 setcolor(rand() % ()); 
 system("pause"); 
 closegraph(); 
 return; 
 } 
 Функсияи setttextjustifi (int horiz, int vert) 
 Ин функсия навиштани матнро нисбат ба маҳалли ҷорӣ муайян мекунад. 
 Қиматҳои horiz ва vert дар ҷадвали зерин оварда шудаанд. 
 № Номи макрос Маъно Қимат 
 LEFT_TEXT CP-дар тарафи чапи матн қарор мегирад 
 CENTER_TEXT CP-дар миёнаи матн қарор мегирад 
 RIGHT_TEXT CP-дар тарафи ростии матн қарор мегирад 
 BOTTOM_TEXT CP-дар поёни матн қарор мегирад 
 TOP_TEXT CP-дар болои матн қарор мегирад 
 Ҷадвали.Қимати параметрҳои функсияи settextjustify(). 
 Мисол. Истифодаи функсияи settextjustify() 
 #include<iostream> 
 usingnamespace std 
 #include<graphics.h> 
 int main() 
 { 
 initwindow(,, "Сафхаи тасвир"); 
 settextjustify(, ); 
 outtext("Ягон тугмачаро пахш кунед!"); 
 system("pause"); 
 closegraph(); 
 return; 
 } 
 Функсияи setfillstyle(int pattern, int color ) 
 Ин функсия барои муайян намудани ранг ва сабкҳои графикӣ истифода 
 бурда мешавад. Функсияи мазкурро қариб аксар функсияҳои графикӣ 
 истифода мебаранд. Дар ин ҷо параметри color намуди рангро мушаххас 
 мекунад ва қиматҳои он бошанд, дар ҷадвали оварда шудаанд. Параметри 
 pattern бошад, сабк ё услуби графикиро муайян мекунад. Қиматҳои он бошанд,
 дар ҷадвали зерин оварда шудаанд. 
 № Доимӣ Маъно ва мафҳум 
 EMPTY_FILL Бе заливка 
 SOLID_FILL Заливкаи яклухт бо ранги ҷорӣ 
 LINE_FILL Хатчаҳои горизонталӣ 
 LTSLASH_FILL Хатчаҳо дар зери кунҷи 
 SLASH_FILL Хатчаҳо дар зери кунҷи аз рост 
 BKSLASH_FILL Хатчаҳои борик дар зери кунҷи аз чап 
 LTBKSLASH_FILL Хатчаҳо дар зери кунҷи аз рост 
 HATCH-FILL Хоначаҳо бо хатчаҳо 
 XHATCH_FILL Хатчаҳо дар зери кунҷи 
 INTERLEAVE_FILL Хатчаҳо аз рӯйи кунҷи 
 WIDEDOT_FILL Хатчаҳои тасодуфӣ 
 CLOSEDOT_FILL Пур намудани қисмати нуқта 
 USER_FILL Навъи пуркуниро барномасоз пур мекунад. 
 Ҷадвали. Қиматҳои параметри Параметри pattern 
 Функсияи setlinestyle (int style, unsigned pattern, int width) 
 Ин функсия намуди хатҳоеро, ки тавассути функсияҳои графикӣ тасвир 
 мешаванд, муайян мекунад. Параметри style намуд ё сабки хатро мушаххас 
 мекунад. Қиматҳои он дар ҷадвали оварда шудаанд. Параметри pattern 
 доимии -рақама (дар ҳисоби шонздаҳӣ) мебошад, ки ҳангоми ба 
 USERBITLINE баробар будани худи барномасоз қимати онро муайян 
 мекунад. Параметри width бошад, васеъгии хатҳоро мушаххас мекунад. 
 Қиматҳои он бошанд, дар ҷадвали оварда шудаанд. 
 № Миқдор (value) Маъно ва мафҳум 
 NORM_WIDTH Паҳноӣ ё васеъгии ҳар хат баробари як нуқта аст. ( 
 pixel wide) 
 THICK_WIDTH Паҳноӣ ё васеъгии ҳар хат баробари нуқтааст. ( 
 pixel wide) 
 Ҷадвали.Қиматҳои параметри width 
 № Миқдор (value) ё но-ми Маъно ва мафҳум (meaning) 
 макрос 
 SOLID_LINE Хат ( -) unbroken line 
 DOTTED_LINE Хати аз нуқтаҳо ташкил ёфта (…..) dotted line 
 CENTER_LINE Хати тунуктире (-.-.-.) centered line 
 DASHED_LINE Хати тире-тире (----------) doshed line 
 USERBIT_LINE Хате, ки худи барноманависонро муайян 
 мекунад user_defined line 
 Ҷадвали.Қиматҳои параметри style 
 Мисол. Барномае нависед, ки чеҳраи одамро тасвир кунад. 
 #include<iostream> 
 usingnamespace std 
 #include<graphics.h> 
 #definedt 
 #definedx 
 int main() { 
 initwindow(,, "расмируйиодам "); 
 setfillstyle(SOLID_FILL, YELLOW); 
 setcolor(YELLOW); 
 pieslice(,,,, ); 
 setcolor(BLACK); 
 arc(,,,, ); 
 circle(,, ); 
 circle(,, ); 
 system("pause"); 
 closegraph(); 
 return; 
 } 
 Функсияи delay (unsigned del) 
 Ин функсия барой расми тасвиршударо ба таъхир гузоштан дар 
 муддати вақти (бо миллисекунд) дар параметри del нишондодашуда хизмат 
 мекунад. Функсияи мазкур барои сохтани соат, матн ё расми ҳаракаткунанда 
 истифода бурда мешавад. 
 Мисол. Барномаи зерин дар саҳифаи тасвир сатри худрав (бегушшая 
 строка)-ро эҷод мекунад: 
 #include<iostream> 
 usingnamespace std 
 #include<graphics.h> 
 constint dt =; 
 constint dx =; 
 int main() { 
 int x, y, maxx; 
 x =; y =; 
 initwindow(,, " "); 
 maxx = getmaxx(); 
 while (x < maxx) { 
 delay(dt); 
 outtextxy(x, y, " Saidov"); 
 x += dx; 
 } 
 system("pause"); 
 closegraph(); 
 return; 
 } 
 Функсияҳоикорбосаҳифаитасвир 
 Аз ҳамаи мисолҳои дар боло оварда шуда, мушоҳида намудем, ки 
 натиҷаи мо дар саҳифаи тасвир, ки рангаш сиёҳ мебошад, пешниҳод 
 мешаванд. Ин равзанаи сиёҳ шояд истифода барандаро дилгир кунад. Бояд 
 кореро иҷрокунем, ки равзанаи мо намуди дилхоҳамонро гирад, барои ин аз 
 функсияҳои textcolor() ва backcolor() истифода бурда мешавад. 
 Функсияи textcolor() 
 Ин функсия бо функсияҳои хориҷкунии cprintf() ва cputs (), ки аз 
 китобхонаи <conio.h> мебошанд, истифода бурда шуда, намуди ҳарфи дар 
 саҳифаи тасвир чопшавандаро ба шаклҳои гуногун табдил медиҳад. Наҳви 
 умумии ин функсия намуди зеринро дорад. 
 textcolor(ранг) 
 Дар ин ҷо ба сифати ранг метавонем, номи ранг ё коди рангро, ки дар 
 ҷадвали оварда шуда буд, истифода намоем. 
 Функсияи textbackground() 
 Ин функсия низ бо функсияҳои хориҷкунии cprintf() ва cputs () 
 истифода бурда шуда, заминаи саҳифаи тасвир ба рангҳои гуногун табдил 
 медиҳад. Наҳви умумии ин функсия намуди зеринро дорад. 
 textbackground(ранг) 
 Дар ин ҷо ба сифати ранг метавон номи ранг ё коди рангро, ки дар 
 ҷадвали оварда шуда буд, истифода намуд. 
 Ин функсияҳо дар сурате истифода бурда мешаванд, ки агар китобхонаи 
 <conio.h> пайваст карда шуда бошад. Инчунин ҳамроҳи ин функсияҳо 
 функсияи тозакунии равзана clsrcr(), ки он ҳам объекти китобхонаи <conio.h>
 мебошад, истифода карда мешавад. Ин функсия дорои амалванд (операнд) 
 намебошад. Функсияи мазкур аз ду калимаи англисии clear-тозакунӣ ва screen-
 экран (саҳифаи тасвир) гирифта шудааст. Ҳангоми истифода функсияҳои 
 cprintf() ва cputs () барои ба аввали сатр овардани курсор рамзҳои идоракунии
 \n ва \r якҷоя истифода бурда мешаванд. 
 Мисол. Ду мисраъ шеъри Мавлавии Балхиро дар саҳифаи тасвир ба чоп 
 диҳед, ки равзана намуди сабзро дошта, ҳарфҳо ранги сурхро дошта бошанд. 
 #include<iostream> 
 usingnamespace std; 
 int main(){ 
 textbackground(); 
 textcolor(); 
 clrscr(); 
 cprintf(" In jahon kuh ast feli mo sado,\n\r"); 
 cprintf(" Suyi mo orad sadohoro nido. \n\r"); 
 cprintf(" Mavlavii Rumi (-). \n\r"); 
 return; 
 } 
 Дар ин мисол метавонем ба ҷойи коди ҳарфҳо номи ҳарфҳоро истифода 
 барем, яъне ба ҷойи калимаи GREEN ва ба ҷойи калимаи CYAN. 
 Саволҳо барои мустаҳкамкунӣ: 
 ) Барои чӣ аз графикҳо истифода бурда мешавад? 
 ) Чӣ тавр ба муҳити графикӣ ворид шудан мумкин аст? 
 ) Барои реҷаи графикиро омода сохтан чӣ корро бояд иҷро кард? 
 ) Функсияи initgraph(&driver, &mode, directory) барои чӣ лозим аст?
 Ҳар як аргументи онро эзоҳ диҳед. 
 ) Функсияи initwindow() барои чӣ истифода бурда мешавад ва аз 
 функсияи initgraph() чӣ фарқияте дорад? 
 ) Барои чӣ функсияи closegraph() истифода карда мешавад? 
 ) Функсияи setcolor() чӣ вазифаро иҷро мекунад? 
 ) Сабк ё услуби графикро кадом функсия муайян мекунад? 
 ) Чӣ тавр тамоми саҳифаро ранг кардан мумкин аст? 
 ) Дар дилхоҳ ҷойи саҳифаи графикӣ навиштани матн мумкин аст? 
 ) Барои тасвири хати рост кадом функсия истифода бурда мешавад? 
 ) Сектори давра чист? Кадом функсия барои тасвири он пешбинӣ 
 шудааст? 
 ) Бо чанд роҳ метавон дар саҳифаи графикӣ эллипс ва давра тасвир 
 кард? 
 ) Магар функсияи circle() метавонад расми эллипсро тасвир кунад? 
 ) Функсияи bar () кадом расмро дар саҳифаи графики тасвир мекунад?
 ) Функсияи delay() барои чӣ пешбинӣ шудааст? 
 ) Намуди хатҳоро кадом функсия муайян мекунад? 
 ) Функсияи settextstyle() чӣ вазифаро иҷро мекунад? 
 ) Функсияҳои putpixel() ва getpixel() чӣ амалиётро иҷро мекунанд? 
 ) Функсияи fillpoly() барои кадом амалро иҷро намудан хизмат 
 мекунад? 
 ) Тарзи истифодаи ҳамаи функсияҳои графикиро аз худ кунед ва 
 мисолҳои зеринро ҳал кунед. 
 Масъалаҳо барои кори мустақилона 
 ) Барномае нависед, ки расми мизу курсиро тасвир кунад. 
 ) Барномае нависед, ки расми хонаеро тасвир кунад. 
 ) Барномае нависед, ки расми пиёла ва косаро тасвир кунад. 
 ) Барномае нависед, ки расми китоби кушодаро тасвир кунад. 
 ) Барномае нависед, ки расми мошинро тасвир кунад. 
 ) Барномае нависед, ки расми самолётро тавир кунад. 
 ) Барномае нависед, ки расми дучархаро тавир кунад. 
 ) Барномае нависед, ки расми самолётро тасвир кунад ва ба воситаи 
 функсияи delay () онро ба ҳаракат дароред. 
 ) Барномае нависед, ки чархи мошинро тасвир кунад ва ба воситаи 
 функсияи delay () онро ба ҳаракат дароред. 
 ) Графики функсияи y=lnx-ро тасвир кунед. 
 ) Графики функсияи y=|x|-ро тасвир кунед. 
 ) Графики ҳама функсияҳои тригонометриро тасвир кунед. 
 ) Барномае нависед, ки расми бобои барфиро тасвир кунад. 
 ) Барномае нависед, ки расми мизро тасвир кунад. 
 ) Барномае нависед, ки расми курсиро тасвир кунад. 
 ) Барномае нависед, ки расми дарахтро тасвир кунад.