Пешгуфтор 
 Ҳамқадам бо асру бо даврон мебояд будан, 
 Бо хабар аз илму аз ирфон мебояд шудан. 
 Ҳеҷ роҳе нест, ки бепоён бошад дар ҷаҳон, 
 Бо ирода бо ҳавас бо ҷон мебояд шудан. 
 (Муллошараф Арабов) 
 Барномасозӣ низ ҳунар буда, барои бартараф намудани баъзе мушкилоти 
 ҷомеа бо истифода аз ягон забони барноманависӣ барнома навишта мешавад. 
 Ҳангоме, ки шахс барнома менависад, метавонад ба компютер ҳамчун раис 
 (роҳбар) муомила кунад. Барои навиштани барнома забонҳои барноманависии 
 зиёде мавҷуданд, ки аз байни онҳо якчанд забон маъмулу машҳур ва пурқудрат
 буда, мавриди писанди барноманависон ва омӯзандагон мебошад. Забони С++ 
 аз зумраи чунин забонҳост. Забонҳои барноманависӣ бо гузашти замон такмилу
 густариш меёбанд. Забони С++ низ дар айни ҳол дар ҳолати рушд ва густариш
 мебошад. 
 Забони С++ дорои қудрати зиёд буда, метавонад ҳам дар муҳити 
 Windows ва ҳам дар муҳити дигар системаҳои омилӣ кор кунад. 
 Забони С++ ҳамаи имкониятҳои забони С-ро доро буда, илова бар ин, 
 қудрати БОН-ро низ соҳиб аст. Баъзеҳо то кунун ҳарчанд ки аз забони С 
 истифода баранд ҳам, вале забони С++ дар дар айни ҳол густариш меёбад. 
 Пас аз соҳибистиқлол гардидани Тоҷикистон чи дар мактабҳои миёна ва 
 чи дар коллеҷу донишгоҳҳо омӯзиши компютер ва барноманависӣ ба роҳ монда 
 шудааст, вале мутаасифона, то кунун дар Тоҷикистон адабиёти фарогири ин 
 соҳа бо забони давлатӣ (модарӣ) вуҷуд надорад. Муаллиф кӯшиш ба харҷ 
 додааст, ки бо забони модарӣ барои хонандагон ҳамчунин дастуреро пешкаш 
 намояд. 
 Ин китоб тарзе навишта шудааст, ки хонандагони он метавонанд бе ягон
 душворӣ ва доштани маълумоти иловагӣ ба ғайр аз информатикаи мактабӣ, 
 асосҳои барноманависиро ба таври комил омӯзанд. Барои ин зарур аст, ки ҳар
 мавзӯъро бодиққат хонда, барномаҳои овардашударо таҳлил кунанд. Дар охири
 ҳар боб барои мустаҳкамкунӣ саволҳо ва мисолҳои мувофиқ барои намуна ва 
 барои кори мустақилона оварда шудааст. Мақсади овардани ин мисолҳо аз он 
 иборат аст, ки хонанда дониши омӯхтаашро санҷида, маҳорати 
 барноманависиашро сайқал диҳад. 
 Китоби мазкур бобро дарбар гирифта, ҳамчун воситаи муҳиме барои 
 худомӯзии асосҳои барноманависӣдар C++ ба ҳисоб меравад. Аз ин китоб 
 хонандагон метавонанд, дар як муддати кӯтоҳ асосҳои забони C++-ро ба таври
 комил омӯхта, заминае барои омӯзиши забонҳои C# ва Java пайдо кунанд. 
 Бояд қайд кард, ки ин китоб на танҳо ҳамчун воситаи худомӯзӣ, балки 
 воситаи методиву таълимӣ низ мебошад. Ҳамаи барномаҳои ин китоб дар 
 компютер иҷро ва тест карда шудаанд. 
 Аз сабаби он ки дар забони С++ истифодабарии имкониятҳои забони С 
 вуҷуд доранд, бинобар ин, баъзе хусусиятҳои забони С низ оварда шудаанд. 
 Дар охири китоб феҳристи васеи адабиёт ҷой дода шудааст, ки барои 
 пурратар ва ҳаматарафа омӯхтани забони C++ кӯмак мекунанд. 
 Инак, дастур пешкаши хонандагон мегардад, ки он нахустин таълифоти 
 муаллиф буда, аз нуқсону ғалатҳо орӣ нест. Аз ин рӯ, муаллиф аз ҳамаи 
 хонандагон эҳтиромона хоҳиш менамояд, ки ҳар гуна фикру мулоҳизоти хешро 
 оид ба ин дастур ба нишонаи электронии cool.araby@mail.ru ирсол намоянд. 
 Мо умедворем, ки фикру дархости беғаразонаи Шумо барои беҳтар 
 шудани сифати китоб дар оянда кумак хоҳанд кард. 
 Муаллиф ба шахсоне, ки фикру мулоҳизаҳои худро оид ба мазмуни китоб 
 беғаразона ба ӯ мерасонанд, қаблан миннатдории худро баён месозад. 
 Муаллиф ба муқарризон Ашӯров Х.М., Раҷабов Ф.С., муҳарриррон 
 Саидолимов К.С., Халилова М.Ш. ва шахсоне, ки дар рафти навиштани китоб 
 маслиҳатҳои муфид дода, таваҷҷуҳ зоҳир намуданд, миннатдории худро баён 
 месозад. 
 Боби. Маълумоти умумӣ дар бораи забони 
 барномасозии С++ 
 Таърихи пайдоиши забони С++ 
 Забони С++ -ро соли дар фирмаи «Bell Laboratories» (шаҳри Мурей-
 Хилли иёлоти Ню-Ҷерсӣ) Берн Страуструп сохта, онро С бо классҳо (С with 
 classes) номид. Мақсади чунин ном гузоштани забон аз он иборат буд, ки 
 таҳкурсӣ ва заминаи пайдоиши он забони С ба ҳисоб мерафт. Забони С-ро 
 бошад, соли Данис Ричард тарроҳӣ кардааст. Забони мазкур дар асоси 
 забони BSPL, ки онро Томпсон тарроҳӣ карда буд, сохта шудааст. Сабаби 
 асосии С ном гирифтани забон дар он буд, ки он пас аз забони B пайдо шудааст.
 Идеяи сохтани забони нав ба Страуструп дар вақти навиштани 
 диссертатсияаш оғоз ёфт. Вай муайян кард, ки забони моделсозии Si-mula 
 имкониятҳои зиёдеро доро асту, вале суст кор мекунад. Аз ин рӯ, дар забони С
 имкониятҳои онро илова намуда, онро С бо классҳо ( С with classes) номид.
 Забони С БОН-ро пуштибонӣ намекард. Страуструп забони С++ ро тавре 
 сохт, ки қариб пурра БОН мебошад. Имконияти БОН-и за-бони С++ ро 
 Страуструп аз дигар забонҳо ба хусус забони Simula гирифт. 
 Дар забони С бо классҳо имкониятҳои нав ба монанди функсия-ҳои 
 виртуалӣ, сарборӣ ниҳодан ба функсияҳо ва операторҳо, услуби нави эзоҳдиҳи
 («//») ва ғайра илова гардиданд. Баъд аз ин иловакуниҳо соли номи он ба
 С++ иваз карда шуд. 
 Моҳи октябри соли нахустин версияи забони С++ ба фурӯш 
 бароварда шуд. Аввалин китоби С++ бошад, бо номи «Забони бар-номанависии 
 С++» низ дар ҳамин сол аз чоп бароварда шуд. Соли версияи дуюми 
 забони С++ бароварда шуд. 
 Соли Комитети ANSI/ISO забони С++ -ро стандарти 
 байналхалқӣ(ISO/IEC: «Standard for the C++ Programming Language»)
 кунонид. Баъд аз анҷоми кор дар болои лоиҳаи стандарткунонии С++ 
 ҳодисаҳои наве ба амал омада, стандартӣ С++-ро маҷбур ба васеъшавӣ 
 намуданд. Масалан, Александр Степанов китобхонаи стандартии қолибҳо 
 (Standard Tenplate Library-STL)-ро сохт. Пас аз сохтани китобхонаи мазкур,
 Комитети ANSI/ISO барои STL-ро ба С++ илова намудан розӣ шуд. 
 Комитети ANSI/ISO аз болои С++ чанде кор карда, хатогиҳои С++-ро 
 ислоҳ намуд ва дар натиҷа, соли версияи ислоҳшудаи стандарти С++ ( 
 ISO/IEC:) бароварда шуд. Стандарти мазкур аз ду қисми 
 асосӣиборат буд: эзоҳи ядрои (ҳастаи) забон ва эзоҳи китобхонаҳои стандартӣ.
 Соли китобхонаи техникии ҳисобот (Library Technical Report 
 (TR) пайдо шуд. 
 Соли кӯшиши иваз (аз нав) кардани стандарти пешинаи забон ба 
 миён омад. Дар аввал стандарти C++ мавҷуд буд, баъд стандарти C++ 
 пайдо шуд. Имрӯзҳо бошад, аз стандарти - C++ истифода мебаранд, ки он яке
 аз стандартҳои васеъшуда ба ҳисоб рафта, дар дохили он китобхонаҳои 
 стандартӣ аз он ҷумла TR низ мавҷуд аст. 
 Мувофиқи стандарти ISO/ IEC, забони С++ ба ду қисм– 
 «Барноманависии сохторӣ(Структурное программирование)» ва 
 «Барноманависии ба объектҳо нигаронидашуда (Объектно-ориентированное 
 программирование) ҷудо карда шудааст. 
 Дар ин дастур имкониятҳои қисмати «Барноманависии сохторӣ» мавриди 
 баҳс қарор дода мешавад. 
 Ин китоб қариб, ки фарогири ҳамаи стандартҳо буда, барномаҳои дар он
 овардашуда метавонанд дар компиляторҳои зиёди забони С++ ба монанди: 
 Borland C++ Builder, Microsoft C++, Blodshed Dev C++, Code Block C++, Turbo
 C++, CodeGear C++, CodeGear XE C++ ва ғайра кор кунанд. 
 Баъзе хусусиятҳои забони С++ 
 Забони С++ дорои хусусиятҳое зиёде мебошад, ки баъзе аз онҳо зимнан 
 оварда шудаанд: 
 С++ забони маҳбубу писандида буда, ниҳоят қудратманд мебошад. Дар 
 он ҳеҷ маҳдудият барои барноманависӣ вуҷуд надорад. Аз ин рӯ, ҳар он чи ки
 дар зеҳни барномасоз пайдо мешавад, онро метавонад дар С++ амалӣ гардонад.
 С++ бо забони Асамблер робитаи наздик дорад. Аз ин рӯ, дар он метавон
 имкониятҳои забони Асамблерро низ истифода кард. 
 С++ забони ба объектҳо нигаронидашуда мебошад. 
 С++ нисбат ба ҳассос мебошад. Дар забони мазкур навишти 
 ҳарфҳои хурд аз калон фарқ доранд. Масалан: for як кали-маи калидӣ аст, вале
 FOR не. Аз ин рӯ, б а х о нандагон тавсия карда мешавад, ки ҳангоми 
 барноманависӣ аз ҳарфҳои хурд истифода кунанд. 
 С++ забони барноманависии система аст. Барномаҳои система 
 барномаҳое ҳастанд, ки онҳоро дар дискҳо гирифта, ба компютер насб 
 мекунанд. Ба ин мисол шуда метавонанд: 
 С++ дорои хусусияти хоссе мебошад. Ҳар барнома дар он ба сурати 
 функсия ё class навишта мешавад. Барои эҷоди барнома бояд функсия ё класси
 мавриди назар навишта шавад. Дар китобхонаҳои стандартии С++ функсияҳо ва
 class-ҳои зиёде мавҷуданд, ки барнома-соз метавонад аз онҳо низ истифода 
 кунад. 
 Операторҳои С++ дорои хусусиёти ба худ хос мебошанд, ба монанди: 
 a) Ҳар оператор дар забони С++ бо аломати «;» ба охир мерасад. 
 b) Дарозии ҳар оператор дар як сатр то рамз шуда метавонад. 
 c) Як оператор метавонад дар як ё якчанд сатр навишта шавад. 
 d) Дар як сатр метавон якчанд операторро навишт. 
 C++ татбиқи хеле васеъ дорад. Тавассути он бозиҳо, барномаҳои 
 шабакавӣ, D-графикҳо, барномаҳои системавӣ, барномаҳои мобилӣ ва ғайра 
 сохта мешаванд. 
 C++ барои пайдоиши забонҳои Java ва C# заминаи асосӣ ба ҳисоб 
 меравад, зеро аксари операторҳои забонҳои мазкур ба операторҳои C++ монанд
 мебошанд. 
 Бояд қайд кард, ки C++ пурра забони C -ро дарбар намегирад. Баъзе 
 воситаҳое дар забони C вуҷуд доранд, ки барои забони C++ бегона мебошанд.
 Масалан, C++ даъвати функсияи main-ро дар дохили барнома иҷозат 
 намедиҳад, вале ин амал дар забони C қобили қабул аст. 
 Алифбои забони С++ 
 Дилхоҳ забони гуфтугӯӣ барои навиштани маълумои худ дорои алифбои 
 хос мебошад. Алифбо имконияти навиштани фикру ақида ва дархостҳои 
 одамонро фароҳам меорад. Забони С++ (дилхоҳ забонҳои барноманависӣ) низ 
 дорои алифбои хос мебошад, яъне барнома аз рамзҳо (ҳарфҳо)-и забон сохта 
 мешавад. Аломатҳои (элементҳои) асосии алифбои забони С++ аз рамзҳои 
 зерин таркиб ёфтаанд::,(),+,, 
 Ҳассосият ба ҳуруфот ва эзоҳ дар забони С++ 
 Забони C++ нисбат ба ҳуруфот (регистр) ҳассос мебошад. Бинобар ин, дар
 он навишти калимаҳои ABC, Abc, ABc, aBC, AbC, abc аз ҳамдигар тафотути 
 куллӣ доранд. Дар забони мазкур калимаҳои калида (операторҳо, дастурҳо ва
 фармонҳо) бояд бо ҳарфи хурд навишта шаванд. 
 Ҳангоми навиштани барнома қитъае аз рамзи (коди) барнома ва ё 
 дастуреро, ки барои хонанда нофаҳмост, метавон эзоҳ дод. Эзоҳ аслан яксатра
 ва бисёрсатра мешавад. Эзоҳи яксатра бо ду рамзи хати каҷ (слеш) навишта 
 мешавад. Масалан: // Ин эзоҳи барнома аст. 
 Ин сатрро барнома сарфи назар мекунад, яъне сатре, ки пас аз // навишта
 шудааст, хонда намешавад. Эзоҳи бисёрсатра бошад, дар дохили аломати 
 ситорача ва як хати каҷ (слеш) навишта мешавад. Мисол: /* ин эзоҳи 
 бисёрсатра аст */ 
 Калимаҳои калидии забони C++ 
 Барои ба калимаҳои калидии забони С++ шинос шудан аввал калимаҳои 
 калидии С, сипас калимаҳои калидии С++ -ро дида мебароем. Калимаҳои 
 калидии забони С дар ҷадвали зерин оварда шудаанд: 
 Калимаҳои калиди и за б о н и С + + и н ҳамаи ка л и маҳои калидии забони С ва
 калимаҳои калидии дар ҷ а д в а л и зер о в а рдаш у да м еб о шанд. Аз калимаҳои дар
 поён овардашуда, калимаи калидии __rtti калимаи калидии махсуси Borland 
 С++ буда, дар лоиҳаи ANSI С++ муайян нагардидааст. 
 Истифодаи кали м а ҳ о и калидӣ б а с и ф а т и номи тағйирёбандаҳо, функсияҳо
 ва ғайра мумкин нест. 
 Идентификаторҳо (identifiers) 
 Идентификатор гуфта, пайдарпайии ҳарфу рақамҳо ва символҳои 
 махсусро меноманд, ки ҳангоми навиштани барнома барои номгузории 
 объектҳои гуногуни забони барноманависӣ ба монанди: тағйирёбандаҳо, 
 суроғаҳо, функсияҳо, файлҳо ва ғайра истифода бурда мешаванд. Ҳангоми 
 истифодаи идентификатор бояд ба меъёрҳои зерин риоя кард: 
  Идентификатор бо ҳарфи лотинӣ ва ё символи махсуси хати поён (_) 
 сар мешавад. Ба мисли: abc, ABC, AB, ab, _abs, a, a, _a, a_b; 
  Калимаҳои калидӣ ба сифати идентификатор истифода бурда 
 намешаванд; 
  Дарозии идентификатор набояд аз символ (рамз) зиёд бошад. (Дар 
 стандарти ANSI миқдори символҳои идентификатор номаҳдуд аст. Дар Турбо 
 Си идентификатор то символ шуда метавонад.); 
  Идентификатор бояд, калимаи пайваст бошад. Ба монанди: My_num, 
 speed_of_body, my_text_file ва ғайра. 
 Имкониятҳои нави C++ 
 Заминаи асосии пайдоиши С++ ҳарчанд ки забони С ба ҳисоб равад ҳам, 
 вале забони С++ дорои имкониятҳои мебошад, ки дар забон С вуҷуд 
 надоштанд. Ин имкониятҳо иборатанд аз: 
 (парокандашуда) RTT; 
 Бояд қайд кард, ки имкониятҳои нави C++ ин муаррифӣ намудан ба 
 намуди ифодаҳо, табдилдиҳии навъҳо ба намуди функсия, операторҳои new ва 
 delete, навъҳои bool ва wchar_t, нишонагарҳо, аргументҳо бо намуди пешфарз,
 азнавмуаррификунӣ (overriding), фазоҳои номӣ, классҳо (ба монанди варосат,
 функсия-аъзо, функсия-ҳои виртуалӣ, классҳои абстрактӣ ва конструктор), 
 азнавмуар-рификунии операторҳо (override operators), шаблонҳо, оператори::,
 коркарди ҳолатҳои истисноӣ ва ғайра мебошад. 
 Дар C++ эзоҳ ба намуди ду хати каҷ пайдо шуд, ки он аз забони BCPL 
 гирифта шудааст. 
 Якчанд хусусиятҳои C++ баъдан дар забони C кӯчонида шудаанд. Ба 
 монанди: калимаҳои калидии const, inline, муаррификунӣдар ҳалқаи for, эзоҳ
 дар услуби C++ (//) ва ғайра. 
 Компилятор ва интерпритатор 
 Барномасоз бояд донад, ки забони барноманависӣ дар компютер хислати 
 барномаро муайян мекунад, на роҳҳои иҷроиши онро. Барои иҷроиши барнома 
 аз транслятор истифода бурда мешавад. 
 Транслятор (англ. translator), ин барномаи тарҷумон буда, барномаи дар
 ягон забони барноманависӣ навишташударо ба варианти охирон, яъне 
 фармонҳои мошинӣ ва ё коди мошинӣ табдил медиҳад. 
 Транслятор ба сурати компилятор ё интерпритатор истифода бурда 
 мешавад. 
 Компилятор (англ. compiler) барнома ё маҷмӯае аз барномаҳои компютерӣ
 аст, ки матни дар забонҳои барноманависии сатҳи боло навишташударо хонда,
 онро ба забони сатҳи поён (Target Language), монанди Ассамблер ё забони 
 сатҳи мошинӣ табдил медиҳад. (Дар компилятор амали тарҷумаи барнома 
 якбора иҷро карда мешавад). 
 Интерпретатор (англ. interpreter — мутарҷим, мутарҷими шифоҳӣ) ба 
 монанди компилятор кор карда, барномаро сатр ба сатр тарҷума ва иҷро 
 мекунад. 
 Дилхоҳ забони барноманавӣ, вобаста аз мақсади сохтанаш дорои 
 компилятор ё интерпретатор мебошад. Масалан, забони Паскал, ки асосан 
 БОН- барноманависии ба объектҳо нигаронидашуда 
 барои ҳалли масъалаҳо пешбинӣ шудааст. Барои он суръати иҷроиш муҳим 
 мебошад, аз ин рӯ, он аз компилятор истифода мекунад, яъне дар он 
 компилятор муайян шудааст. 
 Забони Бейсик, ки барои навомӯзон сохта шудааст, аз интерпритатор 
 истифода мекунад, яъне дар он барнома сатр ба сатр хонда ва иҷро карда 
 мешавад. 
 Компиляторҳои озод (бепул)-ӣ C++ ва муҳити интегронидашудаи 
 корбар (МИК) 
 Ба касе пӯшида нест, ки компиляторҳои C++ (аксари барномаҳои 
 компютерӣ) ба ду гурӯҳ тақсим мешаванд: 
  Тиҷоратӣ; 
  Озод. 
 Интихоби компилятор дар дасти барномасоз мебошад. Касоне, ки пул 
 доранд, метавонанд компилятори дорои калидро гиранд. Ва ашхосе, ки пул 
 надоранд, метавонанд варианти бепули компиляторро интихоб кунанд. Забони 
 C++ забони васеъ буда, дорои компиляторҳои зиёди пулакӣ ва бепул мебошад.
 Дар поён руйхати баъзе компиляторҳои бепулӣ C++ оварда шудаанд: 
 компиляторҳои зиёдеро пуштибонӣ мекунад. Худи компилятори мазкур дар 
 забони C++ навишта шудааст, ки шакли зоҳирии он қариб ба Microsoft Visual
 Studio монанд мебошад. 
 Code::Blocks метавонад, дар системаҳои омилии монанди: Windows, 
 Linux ва Mac OS X ва ғайра кор кунад. 
 Code::Blocks компиляторҳои зиёдеро пуштибонӣ мекунад, ба монанди: 
  MinGW / GCC C/C++ 
  GNU ARM GCC Compiler 
  GNU AVR GCC Compiler 
  GNU GCC Compiler for PowerPC 
  GNU GCC Compiler for TriCore 
  Digital Mars C/C++ 
  Digital Mars D (бо якчанд маҳдудият) 
  SDCC (Small device C compiler) 
  Microsoft Visual C++ 
  Microsoft Visual C++ Toolkit 
  Microsoft Visual C++ - (бо якчанд маҳдудият) 
  Borland C++. 
  Watcom 
  Intel C++ compiler 
  GNU Fortran 
  GNU ARM 
  GNU GDC 
 Версияҳои гуногуни Code::Blocks вуҷуд доранд, ки дар айни ҳол аз ҳама
 версияи навтарини он Code::Blocks. ба ҳисоб мераванд. 
 Насби Code::Blocks сода буда, ҳангоми насб ягон чизи иловагиро аз 
 истифодабаранда талаб намекунад. 
 метавон аз суроғаи “http://www.bloodshed.net/devcpp.html” ба таври ройгон ба
 даст овард. Компилятори мазкур дар систмеҳои омилии Windows 
 //NT//XP/ метавонад бе мамоният кор кунад. Худи компилятори Dev-
 C++ дар забони барноманависии Delphi навишта шудааст, ки компиляторҳои 
 оилаи GNU GCC (MinGW, Cygwin)-ро пуштибонӣ мекунад. 
 Насби Dev-C++ душвор набуда, ҳангоми насб ягон чизи иловагиро аз 
 истифодабаранда талаб намекунад. 
 Dev-C++ дорои имкониятҳои зиёд мебошад, ба монанди: 
  Муҳити графикӣ; 
  Меню бо забони русӣ; 
  Дебогар (debugger)-и дохилӣ GDB; 
  Имконияти сохтани барномаҳои консолӣ ва графикӣ ва ғайра. 
 суроғаи “http://www.microsoft.com/express/“ ба даст овард. Компилятори мазкур
 метавонад дар системаҳои омилии: Windows XP SP/Vista/Server /Server 
 /–кор кунад. Илова бар ин, компилятори MS Visual C++ -- ро 
 пуштибонӣ мекунад. 
 Дар дохили Visual Studio Express воситаҳои зерин ба таври алоҳида вуҷуд
 доранд: 
  Visual Basic Express 
  Visual Web Developer Express 
  Visual C++ Express 
  Visual C# Express 
  SQL Server Express 
 онро метавон аз суроғаи “http://www.eclipse.org/cdt/” ба даст овард. Ин 
 компиляторро системаҳои омилии: AIX/FreeBSD/HP-UX/Linux/Mac OS 
 X/OpenSolaris/Solaris/QNX/Windows – пуштибонӣ мекунанд. Компилятори 
 мазкур компилятори GNU GCC- ро пуштибонӣ мекунад. 
 “http://www.netbeans.org/“ ба даст овард. Компилятори мазкур метавонад, дар
 системаҳои омилии: FreeBSD/Linux/Mac OS X/ Open-Solaris/Solaris/Windows –
 кор кунад. Илова бар ин, компилятори GNU GCC- ро пуштибонӣ мекунад 
 мувофиқ буда, барои навиштани барномаҳои GNU ваWin API пешниҳод 
 шудааст. Компилятори мазкур стандарти C-ро пуштибонӣ карда, дорои ҳамаи
 пакетҳои лозимӣ мебошад. 
 “openwatcom.org“ ба даст овард. Компилятори мазкур метавонад, дар 
 системаҳои омилии: DOS, OS/, Windows –кор кунад. 
 суроғаи “digitalmars.com/download/dmcpp.html “ ба даст овард. Компилятори
 мазкур метавонад, дар системаи омилии Windows –кор кунад. 
 “borland.com/devsupport/bcppbuilder/ downloads/“ ба даст овард. Компилятори
 мазкур метавонад, дар системаи омилии: Windows, Vista, XP –кор кунад. 
 Илова бар ин, компиляторҳои C, C++ ва C# - ро пуштибонӣ мекунад. 
 “turboexplorer.com“ ба даст овард. Компилятори мазкур метавонад, дар 
 системаи омилии: Windows, Vista, XP –кор кунад. Илова бар ин 
 компиляторҳои C ва C++- ро пуштибонӣ мекунад. 
 Муҳити интегронидашудаи коркард (МИК) 
 МИК ё IDE (Integrated development environment) - системаи воситаҳои
 барномавӣ мебошад, ки барноманависон онро барои коркарди таъминоти 
 барномавӣ истифода мебаранд. 
 МИК дорои воситаҳои зерин мебошад: 
 Бисёр МИК-ҳои ҳозиразамон дорои мурургари (браузери) классҳо, 
 равзанаи дарахтшакли объектҳо ва диаграммаи дарахтшакли классҳо (барои 
 БОН) мебошанд. МИК-и забонҳои Eclipse, Embarcadero RAD Studio, Qt Creator,
 NetBeans, Xcode ва Microsoft Visual Studio, Borland Delphi чунин аст. 
 Равзанаи таҳриргари коди лоиҳа ё сохтори барнома 
 Тавре ки қаблан зикр шуд, ин равзана ба чор қисмат тақсим мешавад ва
 дар ҳар қисмат амали лозимӣ анҷом дода мешавад. 
 Дар қисмати аввал китобхона (hider files) насб карда мешавад. Китобхона
 файлест, ки дар он маълумоти зарурӣ оид ба ягон функсия ва ё фармони забон
 нигоҳ дошта мешавад. Масалан, барои иҷрои амалҳои математикӣ аз 
 библиотекаи <math>, барои дохилкунию хориҷкунӣ аз библиотекаи <iostream> 
 ва ғайра истифода бурда мешаванд. 
 Дар блоки муаррифӣ намудани class-ҳо ва функсияҳо бошад, class-ҳо ва
 функсияҳо таъриф карда мешаванд. Барои ҳалли як масъалаи бузург барномасоз
 метавонад, онро ба қисматҳои бо ҳамдигар вобаста ҷудо кунад, ки ҳар яке аз он
 қисматҳоро як функсия номида мешавад. сlass-ҳо ҳам монанди функсияҳо 
 барои як барномаро ба қисматҳо тақсим кардан истифода бурда мешаванд. Як 
 класс метавонад функсияҳоро дар дохилаш нигоҳ дорад. Баъдтар ин матолибро
 мавриди баҳс қарор медиҳем. 
 Методи асосӣ ё сарфунксия функсияест, ки барнома корашро аз он оғоз 
 мекунад, яъне, дилхоҳ барнома, ки дар забони С++ навишта мешавад, дорои 
 ақалан як функсия (main) аст, ки барнома корашро аз он ҷо оғоз мекунад. Маҳз
 ин қисматро қисми оғози барнома мегӯянд. 
 Қисмати охирон бошад, блоки эзоҳи функсияҳо ва ё коди асосӣ номида 
 шуда, дар дохили қавсҳои фигуравӣнавишта мешавад. Махсус дар ин қисмат 
 фармонҳои асосии барнома навишта мешаванд. Барои пурратар шинос шудан 
 ба ин матлаб дар поён қисматҳои асосии барнома овардашудаанд. 
 //Қисмати аввал, яъне қисми муаррифи 
 намудани китобхонаҳо 
 //Блоки муаррифӣ намудани class-ҳо, функсияҳо 
 ва пешнамунасозии функсияҳо 
 // Методи асосии барнома (main) 
 int main() 
 { 
 // Блоки эзоҳи функсияҳо ва ё коди асосӣ. 
 return; 
 } 
 Тавре ки аз ин нақша дида мешавад, дар қисмати аввал библиотекаҳо 
 пайваст карда мешаванд. Ҳар як объект ва функсияҳои стандартии забони С++
 дар ҳамон ҳолате кор мекунанд, ки агар библиотекаи ба он вобаста пайваст 
 карда шавад. Масалан, барои дохил ва хориҷ кардани маълумот библиотекаи 
 iostream пайваст карда мешавад. 
 Қисмати дуввум қисматест, ки дар он функсияҳо class-ҳо ва сохторҳо 
 муаррифӣ карда мешаванд. Оянда дар мавзӯи функсияҳо ва class-ҳо дар ин бора
 тавзеҳот хоҳем дод. 
 Қисмати саввум ин функсияи асосии барнома мебошад, ки аз он ҷо коди 
 барнома оғоз мегардад. Ҳар барнома дар забони С++ ҳатман дорои як функсия
 мебошад, ки онро функсияи асосӣ мегӯянд. Қисмати охирон қисматест, ки дар
 он коди барнома навишта мешавад. Намунаи барнома дар C++. 
 #include <iostream> Библиотекаҳои 
 using namespace std; насбкардашуда 
 int main() 
 { 
 cout<<"Barnameai nahustini man dar zaboni C++"; 
 cin.get(); Коди барнома 
 return; 
 } 
 Дар мавзӯи функсияҳои дохилкунӣ ва хориҷккунӣ дар ин бора тавзеҳоти 
 бештаре хоҳем дод. 
 Китобхонаҳои (Библиотекаҳои) С++ 
 Забони С++ забонест, ки аз якчанд қисматҳои бо ҳамдигар вобаста ташкил
 ёфтааст. Далели ин гуфтаҳо китобхонаҳои С++ мебошанд. Ҳангоми бо забони 
 С++ кор кардан бояд библиотекаи лозимӣ дар барнома насб карда шавад. 
 Библиотекаҳо дар диски мантиқие, ки дар он барномаи С++ насб карда 
 шудааст, дар дохили парвандаи include мавҷуданд. Наҳви насб намудани як 
 китобхона шакли зеринро дорад: 
 #include <номи_китобхона> 
 Дар версияҳои куҳнаи С++ пас аз номи ҳар китобхона ҳарфи h навишта 
 мешуд, ки он ҳарфи аввалаи калимаи header (header file-сар файл) мебошад.
 Навиштани ҳарфи “.h” ҳамаи объектҳои библеотекаро фаъол мегардонад (яъне 
 ба кор омода месозад). Дар сурати нанавиштани “.h” бояд дар пеши ҳар як 
 объект ҳангоми истифодабарӣ яке аз операторҳои зерин навишта шавад: 
 std::номи объект ё using std::номи объект 
 Сатри аввала дар пеши ҳар як объект дар сурати итифодашави навишта 
 мешавад. Сатри дуюм бошад, барои ҳар як обек як маротиба пас аз муаррифӣ 
 намудани китобхона навишта мешавад. 
 Илова бар ин, дар стандарти нави С++ метавон барои ҳамаи библиотекаҳо як
 маротиба дастури зеринро навишт. using namespace std: 
 Ин оператор ҳамаи объектҳои библиотекаҳоро фаъол мегардонад. 
 Дар забони С++ Тавре ки қайд кардем, библиотекаҳои зиёде мавҷуданд, ки
 дар ҷадвали зерин якчандтои онҳо оварда шудаанд: 
 № Номи библиотека Маъно ва мафҳум 
 Китобхонаи дохилкунӣ ва хориҷкунии ҷараёнҳо 
 Китобхонаи кор кардан бо класси complex 
 Китобхонаи математикӣ 
 Китобхонаи кор бо сатрҳо 
 Китобхонаи стандартии дохилкуниву хориҷкунӣ 
 Китобхонаи стандартӣ 
 Китобхонаи кор бо монипулятори додаҳо 
 Китобхонаи кор бо муҳити графикӣ 
 Қайд. Барои якуякбора пайваст кардани ҳамаи китобхонаҳои лозими аз 
 дастури зерин истифода бурда мешавад. #include <bits/stdc++.h> 
 Саволҳо барои мустаҳкамкунӣ 
 ) Забони С++ нахустин маротиба кай ва аз тарафи кӣ сохта шудааст? 
 ) Хусусиятҳои забони С++ кадомҳоянд? 
 ) Кадом рамзҳо ба алифбои С++ дохил мешаванд? 
 ) Компилятор аз интерпритатор чӣ фарқ дорад? 
 ) Кадом компиляторҳои С++ ро медонед? 
 ) Чӣ тавр С++ ба кор омода карда мешавад? 
 ) Созандаи С++ чӣ маслиҳат додааст? 
 ) Чӣ тавр дар забони С++ барои барнома эзоҳ навиштан мумкин аст? 
 ) Эзоҳи як сатра аз бисёрсатра чӣ фарқ дорад? 
 )Кадом рамз барои эзоҳи бисёрсатра ва яксатра истифода бурда мешаванд
 )Китобхонаи iostream барои чӣ пешбинӣ шудааст ва шакли кутоҳшудаи 
 кадом калимаҳо мебошад? 
 )Барои кор кардан бо функсияҳои математикӣ аз кадом китобхона 
 истифода бурда мешавад? 
 Боби. Додаҳо, тағйирёбандаҳо ва амалҳо 
 Муқаддима 
 Барои ҳалли ягон масъала дар дилхоҳ барнома бояд муайян бошад, ки 
 додаҳо (data)–и он масъала чӣ гунаанд ва ба он додаҳо чӣамал иҷро карда 
 мешавад. Дар забони барномасозии С++ ду намуди додаҳо мавҷуданд: доимӣ ва
 тағйирёбанда. Додаҳои доимӣ додаҳоеанд, ки дар тамоми тӯли барнома қимати
 худро тағйир намедиҳанд, аммо додаҳои тағйирёбанда бошанд, баракс амал 
 мекунанд, яъне қимати худро метавонанд дар дилхоҳ ҷои барнома тағйир 
 диҳанд, қимати нав қабул кунанд ва ғайра. Додаҳо метавонанд аз навъ (тип ё
 type)-ҳои гуногун иборат бошанд. Ба монанди бутун, ҳақиқӣ (касрӣ), рамзӣ 
 сатрӣ ва ғайра. Ба ғайр аз ин, додаҳо маҳаллӣ, умумӣ ва минтақавӣ мешаванд.
 Пеш аз истифодабариӣ додаҳо бояд муаррифӣ карда шаванд. Дар забони С/C++ 
 додаҳоро метавон дар дилхоҳ ҷойи барнома муаррифӣ кард. Дар вақти 
 муаррификунӣ пеш аз номи дода навъи (типи) он нишон дода мешавад. Навъи 
 муаррифӣ намудани як дода ба сурати зерин аст: 
 Навъи_дода номи_дода; 
 Навъи додаҳо дар С/С++ ба сурати зерин дастабандӣкарда мешаванд: 
 ) Додаҳо аз навъи бутун (integer), ки аз ҳашт навъ иборат мебошанд.
 ) Додаҳо аз навъи касрӣ ё ҳақиқӣ (floating-points), ки он ҳам се навъ аст.
 ) Додаҳои бутун ва доимӣ (integer constants) -ин намуди додаҳоро 
 метавон ба ғайр аз намуди муқаррарӣ ба намудҳои даҳӣ( decimal), ҳаштӣ (octal)
 ва шонздаҳӣ ( hexadecimal) навишт. 
 ) Додаҳо аз навъи ишорагар (pointer type). 
 ) Додаҳо аз навъи шумориши(enumerated type). 
 ) Додаҳо аз навъи арифметикӣ(arithmetic type) -додаҳои бутун ва ҳақиқӣ
 дар якҷоягӣ. 
 ) Додаҳо аз навъи скалярӣ (scalar type) -додаҳои ишорагар, шуморишӣ ва
 арифметикиро дар маҷмӯъ ташкил медиҳанд. Аз сабаби он ки ин навъ додаҳо бо
 додаҳои навъи худ қобили муқоиса ҳастанд, бинобар ин, онҳоро скалярӣ 
 мегӯянд. Яъне барои онҳо операторҳои муқоиса ҷой доранд. 
 ) Додаҳо аз навъи анбӯҳ (aggregate type) ба ин гурӯҳ дохил мешаванд:
 массивҳо, сохторҳо (structures) ва қисмҳо (union). 
 Ин навъ додаҳо барои сохтани тағйирёбандаҳое, ки ба таври мантиқӣ ба
 ҳамдигар алоқаманданд, истифода бурда мешаванд. Дар мавзӯи сохторҳо оид ба
 ин навъ додаҳо пурратар эзоҳ медиҳем. 
 ) Додаҳо аз навъи ҳолӣ (void) – ин навъ додаҳо аслан функсия (func-
 tion)-ҳое, ҳастанд, ки қимат барнамегардонанд. 
 Ба намуди гистограмма метавонем додаҳои забони С/С++- ро ба намуди 
 зерин тасвир кард: 
 Додаҳои навъи (типи) рамзӣ 
 Додаҳои навъи рамзӣ ба таври пешфарз дар хотира як байт ҷойро ишғол 
 мекунанд. Додаҳои ин навъ рамзи ASCII-код буда, метавонанд бо аломат ва
 ё беаломат бошанд. Қимати додаҳои боаломат дар фосилаи - то + ҷойгир
 буда, онҳоро unsigned char мегӯянд. Навъи рамзии бе аломат бошад, signed char
 номида шуда, фосилаи қиматҳояш аз то мебошад. 
 Номи навъ Фосилаи қиматҳо Андоза ё 
 дарозии навъ 
 char -.. байт 
 unsigned char … байт 
 signed char -… байт 
 Дар аксар забонҳои барномасозӣ додаҳои бутун аз рамзи фарқ мекунанд,
 яъне ҳамчун як адади бутун ва “а” ҳамчун як рамз фаҳ-мида мешавад. Вале
 агар мо дақиқтар нигарем, рамзҳо низ адади бутун мебошанд, яъне ҳар як рамз
 аз рӯи кодгузории стандарти ASCII (American Standard Code for Information
 Intercheng) ва ebsd (extended binary-coded decimal interchange code) дорои коди
 муайян аст. Дар забони С++ ҳар як рамз ҳамчун адади бутун фаҳмида мешавад.
 Одатан рамзҳо дар дохили нохунаки якто-якто навишта мешаванд. 
 Додаҳои навъи бутун 
 Додаҳои навъи бутун ба додаҳои аломатдор ва беаломат ҷудо мешаванд. 
 Ҳангоми муаррифӣ намудани додаҳои бо аломат пеш аз навъи дода калимаи 
 «signed» (signed–аломат) ва додаҳои беаломат «unsigned» (unsigned-бе аломат)
 навишта мешавад. Додаҳои навъи мазкур ҳангоми муаррифӣ намудан дар 
 хотира ва ё байтро ишғол мекунанд. 
 Додаҳои беаломат барои ҳалли масъалаҳое, ки дар онҳо натиҷа мусбат 
 нест, ба монанди ҳаҷм ва масоҳати ҷисмҳо, суръат ва ғайра истифода бурда 
 мешавад. 
 Дар ҷадвали зерин ҳамаи навъҳои бутун ва фосилаи қиматҳояшон оварда 
 шудаанд. 
 Навъи додаҳо Фосилаи қиматҳо Андоза 
 int -… байт 
 unsigned int … байт 
 signed int -… байт 
 short int -… байт 
 long int -… байт 
 unsigned short int … байт 
 signed short int -… байт 
 long long int -(-)…( -) байт 
 unsigned long int … байт 
 signed long int -… байт 
 unsigned long long int … - байт 
 Додаҳои навъи ҳақиқӣ 
 Додаҳои навъи бутун наметавонанд ҳамаи талаботи моро қонеъ 
 гардонанд. Аз ин хотир, истифодаи додаҳои навъи ҳақиқӣ зарурат мешавад. 
 Додаҳои навъи ҳақиқиро метавонем ба ду тарз истифода барем. Тарзи якум 
 намуди муқаррарӣ, яъне байни қисми бутун ва касриии адади ҳақиқӣ аломати 
 вергул (дар забони С++ нуқта (dot)) гузошта мешавад. Масалан,.,.,, ва ғайра. 
 Равиши дуюм, ки намоиши илмӣ (scientific notation) низ номида мешавад.
 Як кӯтоҳнависӣ дар қолаби дараҷагӣ (экспонентсиалӣ) буда, дар ин навъи 
 навишт адад ба ду қисм ҷудо карда мешавад: қисми монтис (montica) ва қисми
 дараҷа (exponent). Қисми дараҷагӣ одатан пас аз қисми монтис меояд. Байни ин
 ду қисмат ҳарфи Е навишта мешавад, ки он ҳарфи аввалаи калимаи Exponent -
 дараҷа мебошад. Қисми дараҷагӣ бояд дар нишондиҳанда (ё дараҷа)-и омада,
 ба монтис зарб шавад. Наҳви умумии ин равиш шакли зеринро дорад: 
 Дар ин ҷо m-монтиса(қисми бутуни адад), E-ишораи дараҷа ва p бошад, 
 дараҷа ё қисми дараҷа мебошад. Ба м и со лҳ ои зерин таваҷҷуҳ фармоед. 
 ),Е+=,*=,*= 
 ) Е=*=*= 
 ) 
 Бояд қайд кард, ки қима т и дараҷа (н амо ҳам гуф та мешавад) наметавонад
 адади ғайрибутун бошад. 
 Додаҳои ин навъ float, double ва long double мебошанд. Ба намуди 
 пешфарз додаҳои навъи float чор байтро дар хотира банд мекунанд. Дар намуди
 дараҷагӣ то разряд дар қисми монтис ва разряд дар қисми намо ё дараҷа
 қабул карда метавонанд. Додаҳои навъи double бошанд, тӯлашон (дарозиашон)
 ду баробари додаҳо навъи float мебошад, яъне онҳо дар хотира *= байт 
 ҷойро ишғол мекунанд. Дар баъзе компиляторҳои С++ додаҳои ин навъро 
 метавон ба сурати long float муаррифӣ кард. Аз ин ҷо навиштҳои зерин бо 
 ҳамдигар эквивалент мебошанд. double a,b,c,d;  long float a,b,c,d; 
 Барои додаҳои навъи double дар намуди дараҷагӣ то разряд қисми 
 мантиса ва разряд қисми дараҷа ё намо шуда метавонад. Агар пеш аз навъи
 double калимаи long нависем, фосилаи қиматҳои ин тип байт афзоиш 
 мекунад. Дар ҷадвали зерин ҳамаи навъҳои ҳақиқӣ оварда шудаанд. 
 Навъи додаҳо Фосилаи қиматҳо Андоза 
 float.Е-…..Е+ байт 
 double.Е-…..Е+ байт 
 long double.Е-….Е+ байт 
 Додаҳои навъи мантиқӣ 
 Додаҳои навъи мантиқӣ яъне bool танҳо ду қиматро метавонанд қабул 
 кунанд, true (ҳақ) ва false(ноҳақ). Дар забони С++ ҳар қимате, ки ғайринулӣ аст,
 ҳамчун true (ҳақ) фаҳмида шуда, ҳар гуна қимати нулӣ false (ноҳақ) фаҳмида
 мешавад. Бо ифодаи дигар қимати ҳақ ба як баробар буда, қимати ноҳақ ба нол
 баробар аст. 
 Додаҳои навъи холӣ 
 Ин навъ додаҳо дар дигар стандартҳо мавҷуд набуданд ва танҳо дар 
 стандарти ANSI илова карда шуданд. Ин навъ додаҳо дар функ-сияҳое, ки 
 қимат барнамегардонанд ва танҳо амали муайянеро иҷро мекунанд, истифода 
 бурда мешаванд. Дар мавзӯи функсияҳо ба ин матлаб равшании зиёд 
 меандозем. 
 Тағйирёбандаҳо ва муаррифӣ намудани онҳо 
 (variables declaration) 
 Тағйирёбанда гуфта, бузургие (додае)-ро меноманд, ки дар та-моми тӯли
 барнома метавонад, қиматҳои гуногун қабул кунад. Тағйирёбандаҳо барои 
 коркарди додаҳо истифода шуда, бо ёрии номашон муайян карда мешаванд, 
 яъне номи тағйирёбанда-суроға (адреси) онро дар хотира нишон медиҳад. Номи
 тағйирёбанда бояд бо ҳарф сар шавад ва наметавонад калимаи калидии забон 
 бошад, яъне истифодаи калимаҳои калидии забонро мумкин нест ба сифати 
 номи тағйирёбанда истифода кард. 
 Ҳангоми истифода бурдани тағйирёбандаҳо дар барнома аввал онҳо бояд 
 муаррифӣ карда шаванд, яъне муайян шавад, ки онҳо ба кадом навъ таалуқанд
 ва чӣ қадар хотираро банд мекунанд. 
 Дар аксар забонҳои барноманависӣ тағйирёбандае, ки навъаш муайян 
 нашудааст, ба компилятор фаҳмо намебошад, яъне компилятор ҳангоми 
 тарҷума кардани барномаи навишташуда он тағйирёбандаро намефаҳмад ва дар 
 натиҷа, амали тарҷума иҷро намегардад. Наҳви муаррифӣ намудани 
 тағйирёбанда ба сурати зерин аст: 
 data_type Variable, Variable,…., Variablen 
 Дар ин ҷо data_type-навъи тағйирёбанда (яъне дилхоҳ навъи стан-дартӣ),
 Variable, Variable,…., Variablen-номи тағйирёбандаҳои якум, дуюм ва ҳоказо
 n-ум мебошанд. Тавре ки дида мешавад, номи тағйирёбандаҳо бо рамзи «,» аз
 ҳамдигар ҷудо карда мешаванд. 
 Шояд дар зеҳни хонандаи мо боз саволе пайдо шавад, ки чӣ ниёзест аз 
 муаррифӣ намудани тағйирёбанда ва он дар барнома-нависи чи аҳамияте 
 дорад? Метавон ба ин савол чунин ҷавоб гуфт, ки ҳангоми муаррифӣ намудани
 тағйирёбанда ба компилятор гуфта ме-шавад, ки ин тағйирёбанда аз кадом навъ
 аст, вобаста ба навъи он дар ҳофиза ҷое муайян банд мешавад. Ҳофиза ба 
 воситаи байтҳо пур карда мешавад. Барои дарози навъи додашударо муайян 
 кардан метавон аз функсияи sizeof() истифода кард. Ин функсияро баъдтар 
 мавриди баҳс қарор медиҳем. Дар ҷадвали зерин ном ва дарозии навъҳои 
 стандартӣ гирд оварда шудаанд. 
 Номи навъҳои Дарозии навъи Фосилаи қиматҳои навъи 
 стандарти додашуда бо додашуда 
 байт 
 Қимати ҳақ (true ё ) 
 ва ноҳақ (false ё ) 
 аз - то 
 аз то 
 аз.Е- то.Е+ 
 аз.Е- то.E+ 
 аз - то 
 аз то 
 аз - то 
 аз то 
 аз - то 
 аз - то 
 аз то 
 аз - то 
 аз - то 
 аз то 
 аз - то 
 аз.Е- то.Е+ 
 А с ос а н д а р з абони С/С++ навъи додаҳои зерин истифода бурда мешаванд.. ch a r — р а мзӣ 
 Барои қолиббанди кардан ба дигар навъҳо аз асоси навъҳое, ки 
 спесификатор ном доранд, истифода карда мешавад. Дар забони С++ чор 
 спесификатори навъи додаҳо мавҷуд аст. 
 Дар ҷадвали боло баъзе типҳоро мо дидем, ки пеш аз номи онҳо калимаи
 signed ё unsigned навишта шуда буд. Ин маънои аломатдор ё беаломат будани
 тағйирёбандаҳои вобастаи ин типҳоро нишон ме-диҳад. 
 Пас аз донистани ин маълумотҳо биёед наҳви муаррифӣ намудани 
 тағйирёбандаҳоро аз нав ба таври возеҳтар дида бароем. Тавре ки қаблан 
 гуфтем, пеш аз тағйирёбанда навъи он бо ҳарфи хурд нишон дода мешавад. 
 Масалан, бигзор тағйирёбандаи х аз навъи бутун бошад, пас, барои муаррифӣ
 намудани он дар забони С++ аз равиши зерин истифода мебарем: int x; 
 Тавре ки дидем, пеш аз номи тағйирёбанда навъи он навишта шудааст. 
 Барои муаррифӣ кардани якчанд тағйирёбандае, ки аз ҷиҳати навъ якхела 
 мебошанд, як маротиба навиштани навъ кифогӣ мекунад. Қолаби умумии ин 
 равиш шакли зеринро дорад: 
 data_type var,var,…, varn 
 Дар ин ҷо data_type навъии додашуда, var,var,…, varn-бошанд, 
 тағйирёбандаҳои якум, дуюм ва ҳоказо n-ум мебошанд. Ба ғайр аз ин, метавон
 ҳар як тағйирёбандаро алоҳида-алоҳида муаррифӣ кард. Ба монанди: 
 data_type var; data_type var;….; data_type varn 
 Дар ин ҷо барои ҳар як тағйирёбанда алоҳида муаррифӣ шудааст. 
 Тавре ки айён аст, равиши аввала хело сода ва осон мебошад. Масалан 
 бигзор тағйирёбандаҳои a,b,c,d,e,f аз навъи бутун бошанд. Онҳоро ба намуди
 зерин муаррифӣ намудан мумкин аст: 
 int a,b,c,d,f; ё int a; int b; int c; int d; int e; int f;
 Метавон калимаҳои калидиро ҳангоми яке аз ҳафи онҳоро калон 
 навишта ба сифати номи тағйирёбанда истифода бурд. Мисол: 
 int Int; 
 Дар ин ҷо тағйирёбандаи Int аз навъи int эълон шудааст, вале мас-лиҳат
 он аст, ки аз ин равиш истифода бурда нашавад. 
 Барои муаррифӣ намудани тағйирёбанда бояд ба қоидаҳои зерин риоя 
 кард: 
 кунад. 
 яъне бо як ном дар як барнома ду тағйирёбанда ҳарчанд, ки аз навъҳои 
 гуногунанд муаррифӣ нагардад. Ба таври дигар, ду тағйирёбанда набояд ҳамном
 бошанд. 
 Қимати аввала бахшидан ба тағйирёбандаҳо 
 Ҳангоми муаррифӣ намудани тағйирёбандаҳо метавонем ба онҳо 
 якуякбора қимати аввала бахшид. Бигзор, тағйирёбандаҳои a,b,c,d аз навъи 
 бутун буда, мувофиқан ба,,, баробар бошанд. Ҳангоми муаррифӣ 
 намудани онҳо метавон ин қиматҳоро ба тағйирёбандаҳои мазкур ба сифати 
 қимати аввала бахшед (яъне тағйирёбандаҳоро инитсиализатсия кунем). 
 int a=, b=, c=, d=; 
 Ба ҳамин монанд метавон ба тағйирёбандаҳои дигар типҳо низ қимати 
 аввала бахшид. 
 Аз як навъ ба навъи дигар табдил додани тағйирёбандаҳо 
 Забони С/ С++ иҷозат медиҳад, ки додаҳои як навъро ба навъи дигар 
 табдил дода шаванд. Барои иҷрои ин амал, яъне тағйирёбандаи як навъро ба 
 навъи дигар табдил додан, тағйирёбандаи лозимиро дар дохили қавс ва пас аз
 қавс номи тағйирёбандаи мавриди назарро менависем. Масалан, бигзор 
 тағйирёбандаи a аз навъи int бошад, барои онро ба навъи float-и бо номи b
 табдил додан амали зеринро иҷро мекунем, яъне: 
 int a=; b= (float) a 
 Ин навишт пеш аз он ки қимати бутуни а-ро ба b бахшад, онро ба навъи
 float табдил медиҳад. Тавре ки дидем, оператори cast танҳо як қимат қабул
 мекунаду халос, аз ин рӯ, онро оператори ягона (би-нари)-и дорои як операнда
 меноманд. Ин равиш дар бисёр ҳолатҳо хеле муфид аст. Масалан, бигузор 
 тағйирёбандаҳои х ва у аз навъи бутун буда, дорои қиматҳои мувофиқан ба 
 ва баробар бошанд ва тағйирёбандаи z аз навъи float бошад. Ифодаи зерини
 z=x/y ба. баробар мешавад, яъне ин ифода танҳо қисми бутуни натиҷаро 
 намоиш медиҳад. Барои он ки қисми бутун ва касрии ададро якбора намоиш 
 диҳад, бояд аққалан яке аз тағйирёбандаҳо х ва ё у низ аз навъи float бошанд ва
 ё бо ёрии оператори cast якеашон ба навъи float табдил дода шавад, яъне амали
 зерин иҷро гардад. 
 z=(float)x/y 
 Дар ин равиш натиҷаи z=. хоҳад шуд ва агар ин мисолро ба намудҳои 
 зерин низ табдил диҳем, натиҷаи z=, хоҳад шуд. 
 z=x/(float)y ё z=(float)x/(float)y 
 Аз ин мисолҳо метавонем хулоса баровард, ки дар дилхоҳ ҷойи барнома 
 метавонем додаи навъии дилхоҳи стандартиро ба навъи дигар табдил диҳем, 
 яъне амали casting метавонад дар дилхоҳ ҷои барнома иҷро шавад. Наҳви 
 умумии ин равиш ба сурати зерин аст: 
 (data-type) expression 
 Мисол. Бигзор тағйирёбандаҳои a ва b аз навъи double бошанд, ифодаи 
 зерин суммаи ин тағйирёбандаҳоро ба намуди бутун табдил медиҳад. 
 y= int (a+b) 
 Ин ифода аввал қиматҳои a ва b-ро бо ҳамдигар ҷамъ намуда, баъд 
 натиҷаашро ба навъи бутун гардонида ба тағйирёбандаи y мебах-шад. Ба ҳамин
 монанд метавон амали casting-ро барои дилхоҳ тип-ҳои стандартӣ истифода 
 кард. 
 Доимиҳо (constant) 
 Дар математика баъзе бузургиҳое ҳастанд, ки қимати доимӣ доранд ба 
 монанди, ғайра. Дар барноманависӣ низ ин равиш 
 истифода бурда мешаванд. Пас, доимиҳо бузургиҳое ҳастанд, ки дар тамоми 
 тӯлии ба р но м а қи м ат и ху д р о тағйир намеди-ҳанд, яъне баръакси 
 тағйирёбандаҳо мебошанд. Наҳви муаррифӣ намудани доимиҳо ба сурати зайл 
 аст: 
 const data-type variable=value ё const номи доими =қимати доимӣ 
 Дар ин ҷо const-шакли кӯтоҳи constant-доимӣ буда, value қимати доимӣ
 ва variable бошад, номи доимӣ мебошад. Доимӣ метавонад аз дилхоҳ навъи 
 базавӣ (стандартӣ) бошад, ба монанди бутун, ҳақиқӣ, рамзӣ сатри ва ғайра.
 Масалан, бузургии доимиро бо понздаҳ рақам баъди вергул метавонем ба 
 сурати зерин муаррифӣ кунем: 
 const double Pi=.; 
 Ба ғайр аз ин, метавонем доимиҳоро бо ёрии пешпардозанда 
 (препроссесор)-и #define пеш аз функсияи асосӣ (main) муаррифӣ кунем. Дар
 ин сурат номи доими бояд бо ҳарфҳои калон навишта ша-вад. 
 #define PI. 
 Тавре ки мушоҳида мешавад, ҳангоми бо ёрии пешпардо-занда муаррифӣ 
 намудани доимӣ навъи он нишон дода намешавад. Дар ин ҳолат дар тӯли 
 барнома доимиро метавонем ҳамчун адади ҳақиқии дароз истифода барем. Дар 
 мавзӯи пешпардозанда (препроссесор)-ҳо пурратар баҳс мекунем. 
 Амалҳо 
 Тағйирёбандаҳо, доимиҳо, массивҳо, сохторҳо ва ё class-ҳо бо истифода
 аз амалҳо бо ҳамдигар пайваст карда шуда, ифодаҳоро ташкил медиҳанд. Аз ин
 ҷо амалҳоро бо сурати зерин таъриф медиҳем. 
 Таъриф. Амалҳо аломат ё нишонаҳое ҳастанд, ки барои сохтани (эҷод 
 намудани) ифодаҳо хизмат мекунанд. 
 Баъзан ба ҷои калимаи амал, аз амалгар низ истифода карда мешавад. 
 Амалҳоро метавонем ба сурати зерин дастабандӣ кард: 
 ) Амалҳои арифметикӣ (arithmetic operators) 
 ) Амалҳои мантиқӣ (logical operators) 
 ) Амалҳои муқоисакунӣ (relation operators) 
 ) Амали шартӣ (conditional operator) 
 ) Амали коммо (commo) ё вергул 
 ) Амалҳои ягона (unary operators) 
 ) Амалҳои ҳофиза () 
 Амалҳои арифметикӣ (arithmetic operators) 
 Амалҳои арифметикӣ амалҳое мебошанд, ки барои иҷрокунии амалҳои 
 арифметикӣ ба додаҳо истифода бурда мешаванд. Дар ҷадвали зерин амалҳои 
 мазкур ҷамъ оварда шудаанд. 
 Номи Нишона Истифодабарии Истифодабарии 
 амал Нишона(symbol)-и Намунаи амалҳои Намунаи амалҳои 
 амал арифметикӣ дар арифметикӣ дар 
 математика забони С++ 
 Ҷамъ + 
 Тарҳ - 
 Тақсим / 
 Зарб * 
 Бақия аз % 
 тақсим 
 Ҳамаи ин амалҳо ба ғайр аз ам ал и б а қия аз тақсим (%), да р тамоми
 забонҳои барноманависӣ як хел истифода бурда мешаванд. Оператори % -ро 
 remainder operator ё modulus operators низ мегӯянд, монанди дигар забонҳои
 барноманависӣ истифода бурда мешаванд, яъне бақияи тақсими a-ро бо b 
 муайян мекунад. Ба ғайр аз ин, амалҳои зерин мавҷуданд. 
 Номи амал Нишона Намунаи амал дар Намунаи амал дар 
 (symbol)-и амал математика забони С++ 
 Ҷам ягона + 
 Тарҳи ягона - 
 Як воҳид афзоиш ++ 
 (increment) 
 Як воҳид коҳиш -- ё 
 (decrement) 
 Бахшиш = – 
 Ду амали ++ ва -- дар дигар забонҳои барномасозӣ вуҷуд надорад. Ин 
 амалҳо адади додашударо як воҳид зиёд ва як во ҳи д кам мекунанд. Ҳ ар кадоме
 аз ин амалҳо дар ду намуд ё қолаб истифода бурда мешаванд. Тарзи истифодаи
 онҳо дар ҷадвали зерин оварда шудааст. 
 № Амали афзоиш (++) Мисол Амали коҳиш (--) Мисол 
 Пешафзоиш (preincrement) Пешкоҳиш (predecrement 
 Пасафзоиш (postincrement) Паскоҳиш(postdicrement) 
 Амали бахшиш (default assign m en t operator) бошад, баробари мат ем ат икӣ
 набуда, балки қимати b-ро ба а мебахшад. 
 Қайд. Фарқияти асосии байни амали пешафзоиш (пешкоҳиш) ва 
 пасафзоиш (паскоҳиш) дар он аст, ки амали пешафзоиш (пешкоҳиш) пеш аз 
 иҷрои дигар амалҳо қимати амалвандашро як воҳид афзоиш (коҳиш) медиҳад. 
 Амали пасафзоиш (паскоҳиш) бошад, аввал амалҳи лозимиро иҷро карда, сипас
 қимати амалвандашро як воҳид афзоиш (коҳиш) медиҳад. 
 Мисол. Бигзор a= бошад онгоҳ қимати ифодаи y=++a+ ба баробар 
 буда, қимати ифодаи y=+a++ (y=a+++) ба баробар мешавад/ 
 Амалҳои кор бо битҳо 
 Дар забони С++ якчанд амале мавҷуд аст, ки онҳоро амалҳои кор бо битҳо
 мегӯянд. Сабаби амали бо бит гуфтани онҳо дар он аст, ки онҳо авввал қимат
 (адад)-и додашударо ба намуди дӯӣ фарз намуда, баъд бо он амалиётеро иҷро
 мекунанд. Ин амалҳо иборадатанд аз: 
 ) Амали ва (&) –амали кор бо битҳо (хусусан системаи дӯи) буда, чунин амал
 мекунад, дар сурати ҳам қимати якум ва ҳам дуюмаш ҳақ будан ба қимати ҳақ
 доро буда, дар дигар сурат ба қимати ноҳақ доро аст, яъне: 
 Мисоли. Бигзор х= ва у= бошад ва онҳоро ба намуди системаи дӯи
 гардонем, чунин шаклро мегиранд: 
 X 
 Y 
 x&y 
 Аз ин ҷо натиҷаи мешавад. 
 ) Амали ё (|)-амали кор бо битҳо буда, ба қимати ҳақ дорост, агар 
 ақалан яке аз қиматҳои д о д аш уд а ҳа қ б ош а нд, яъне 
 Мисоли. Мисоли -ро барои ин амал дида мебароем, яъне бигзор х= 
 ва у= бошад ва онҳоро ба намуди системаи дӯи гардонем, чунин шаклро 
 мегиранд: 
 Пас, аз ин ҷо натиҷа x^y=|= мешавад. 
 ) Амали ё (^)-амали кор бо битҳо буда, ба қимати ҳақ доро аст, агар
 танҳо яке аз қиматҳои додашуда ҳақ бошанд, яъне 
 Мисоли. Мисоли -ро барои ин амал дида мебароем, яъне бигзор х= 
 ва у= бошад ва онҳоро ба намуди системаи дӯи гардонем, чунин шакл-ро 
 мегиранд: 
 Пас, аз ин ҷо натиҷаи x^y=^= мешавад. 
 ) Амали тарҳ ~ -амали кор бо битҳо буда, ба қимати ҳақ доро аст, агар
 қимати додашуда ноҳақ бошанд ё баракс, яъне 
 ) Кӯчиш ба чап (А<<В) –ин амал адади А-ро дар намуди дӯӣ фарз 
 намуда, баъд онро В разряд ё мавқеъ ба тарафи чап мекӯчонад. Ми-сол: бигзор
 А= бошад ва В= бошад, дар аввал А-ро ба намуди дӯӣ мегардонад, яъне 
 Аз ин ҷо А<<B=<<= 
 ) Кӯчиш ба рост (А>>В) ин амал адади А-ро дар намуди дӯӣ фарз 
 намуда, баъд онро В разряд ё мавқеъ ба тарафи рост мекӯчонад. Мисол: бигзор
 А= бошад ва В= бошад, дар аввал А-ро ба намуди дӯӣ мегардонад, яъне 
 Аз ин ҷо А>>B=>>= 
 Амалҳои муқоисакунӣ (relation operators) 
 Амалҳои муқоисакунӣ барои дар байни ду тағйирёбанда муносибат ё 
 робита барқарор намудан хизмат мекунанд, яъне муайян мекунанд, ки дар 
 байни ин тағйирёбандаҳо чӣ гуна муносибат мавҷуд аст. Дар ҷадвали зерин 
 амалҳои муқоисакунӣ оварда шудаанд. 
 Номи амал Нишона Нишона Истифодабарии Қимати 
 (symbol)-и (symbol)-и амалҳои амал дар 
 амал дар амал дар муқоисакунӣ дар забони С++ 
 математика С++ забони С++ 
 Калонтар > > a>b а калон аз b 
 Хурдтар < < a<b а хурди b 
 Калон ё >= a>=b а калон ё 
 баробар баробари b 
 Хурд ё <= a<=b а хурд ё 
 баробар баробари b 
 Баробар = == a==b а айнан 
 баробар b 
 Нобаробар!= a!=b a нобароба- 
 ри b 
 Барои ам алҳои муқоисакунӣ ва мантиқӣ калимаҳои калидӣбо номи true ва
 false истифода бурда мешаванд. Дар забони С++ ҳар гуна адади ғайринулӣ 
 ҳамчун true ва адади нулӣбошад, ҳамчун false фаҳмида мешавад. 
 Амалҳои мантиқӣ (logical operators) 
 Амалҳои мантиқӣ амалҳое ҳастанд, ки барои иҷрокунии амале болои 
 ифодаҳои мантиқӣ истифода бурда шуда, дорои қимати ҳақ (true) ва ноҳақ 
 (false) мебошанд. Дар ҷадвали зерин операторҳои мантиқӣ оварда шудаанд. 
 № Номи Аломат (symbol)-и Аломат (symbol)-и Номи амал дар 
 амал амал дар забони С++ амал дар математика математика 
 and-ва && Конъюнксия 
 or-ё || Дизъюнксия 
 not-не! ~ Инкор 
 Тавре ки қайд кардем, дар забони С++ қимати true ба баро-бар буда,
 қимати false ба баробар мешавад. Ин амалҳо дар алгебраи Булл чунин 
 таъриф дода мешаванд: 
 ) Конъюнксияи мулоҳизаҳои A ва B гуфта, ҳамин гуна мулоҳизаи С-ро 
 меноманд, ки ба қимати ҳақ (true) доро аст, агар ҳам мулоҳизаи А ва ҳам 
 мулоҳизаи В баробари true, яъне ҳақ бошанд. Дар акси ҳол, дорои қимати ноҳақ
 (false) мешаванд. 
 Мулоҳизаҳои Мулоҳизаҳои Мулоҳизаи якум && мулоҳизаи 
 якум дуюм дуюм 
 False False False 
 False True False 
 True False False 
 True True True 
 ) Дизъюнксияи мулоҳизаҳои A ва B гуфта, ҳамин гуна мулоҳизаи С-ро 
 меноманд, ки ба қимати ҳақ (true) доро аст, агар аққалан яке аз мулоҳизаҳои А
 ва ё В ба қимати true, яъне ҳақ доро бошанд. Дар акси ҳол, дорои қимати 
 ноҳақ (false) мешаванд. 
 Мулоҳизаи якум Мулоҳизаи дуюм Мулоҳизаи якум || мулоҳизаи дуюм 
 False False False 
 False True True 
 True False True 
 True True True 
 ) Инкори мулоҳизаи А гуфта, мулоҳизаи -ро меноманд, ки он ба 
 қимати ҳақ дорост, агар худи мулоҳизаи А ба қимати ҳақ доро бо-шад, дар акси
 ҳол, ба қимати ноҳақ баробар мешавад. 
 ̃ 
 № Мулоҳиза Инкори мулоҳиза 
 False True 
 True False 
 Мисол. Бигзор тағйирёбандаҳои a,b,c,d аз навъи бутун буда, мувофиқан
 ба,, c, d баробар бошанд. Акнун дар ҷадвали зерин чанд ифодаеро меорем.
 № Мулоҳизаҳо Натиҷаи мантиқӣ Натиҷа дар забони С++ 
 (a<) && (x>) true 
 ((*a+)>=c) && (a>c) false 
 (a==)||(a< (d+)) true 
 (b/a)==a true 
 (a<b)||(a<) false 
 Қайд. Баъзан ба сифати дуто амперсанд (&&) аз якто & низ истифода 
 бурда мешавад. Фарқият дар он аст, ки амали дуто амперсанд дар ҳолати ҷой
 надоштани шарти якум (false будани амалванди якум) шарти (амалванди) 
 дуюмро тамоман тафтиш намекунад. Амали якто амперсанд бошад, новобста 
 аз шарти (амалванди) якум шарти (амалванди) дуюмро низ тафтиш мекунад. 
 Мисол. Бигзор ададҳои бутуни a= ва b= дода шуда бошанд, онгоҳ пас 
 аз иҷроиши дастури bool y=(++a>) && (b++>) қимати a= ва b= ва 
 ҳангоми иҷроиши дастури bool y=(++a>) & (b++>) қимати a= ва b= 
 мешавад. 
 Амали шартӣ (conditional operator) ё сегона (тернерӣ) 
 Амали шартӣ барои санҷидани дурустӣ ва ё нодурустии шарти додашуда 
 истифода бурда мешаванд. Амали мазкур дорои се операнд мебошад, яъне 
 Номи Нишона Наҳви амал Амали иҷромекардаи амал 
 амал (symbol)-и 
 амал 
 Шартӣ?: Exp?exp:exp exp шарти гузошташу-да буда, дар 
 сурати ғай-ринулӣ ё дуруст буда-ни 
 он exp иҷро мегар-дад, дар ҳолати 
 акс exp иҷро мегардад. 
 Ин амал амали амали if else-ро иҷро мекунад. 
 If a> then 
 Z= 
 Else 
 Z=- 
 Масалан, қисми барномаи боло, ки дар забони Visual Basic навишта 
 шудааст. Метавонем онро бо ёрии амали шартӣ дар забони С++ ба сурати зерин
 нависем: 
 Z=((a>)?:-); 
 Ба ҳамин монанд метавонем дигар мисолҳоро низ иҷро кунем. 
 Амали коммо (The commo operator) ё вергул 
 Амали коммо ё вергул имконияти иҷрошавии якчанд амалиётро дар 
 дохили як оператор медиҳад. Ин амал бештар дар операторҳои даврии for 
 истифода бурда мешавад. Наҳв ва истифодаи он дар ҷадвали зерин оварда 
 шудааст. 
 Номи Нишона Наҳви амал Амали ичромекардаи амал 
 амал (symbol)-и 
 амал 
 Коммо, еxp,exp,…,expn Аввал exp баъд exp ва ҳоказо 
 expn аз назар гузаронида 
 мешаванд. 
 Тарзи навишти он ба сурати зерин аст: 
 variable=(var,var,…varn); 
 Мисол: x=(y=,y+) 
 Ин ифода аввал ба тағйирёбандаи у қимати -ро бахшида, баъд натиҷаро
 ба ҷамъ мекунад ва натиҷаи ҳисобшударо ба а мебахшад. Дар натиҷа а ба 
 қимати баробар мешавад. Ин амал асосан дар дохили сикли for истифода 
 бурда мешавад баъдтар дар мавзӯъҳои оянда мисолҳои мушаххасеро бо ёрии ин
 оператор меорем. 
 Амалҳои ягона (Unary operators) 
 Амалҳои ягона амалҳоеанд, ки фақат дар рӯи як операнд амал мекунанд.
 Ин амалҳо дар ҷадвали зерин гирд оварда шудаанд. 
 № Номи амал Рамз (symbol)-и Истифодаи амал дар 
 амал забони С++ 
 Ҷамъи унарӣ (unary plus) + а+= 
 Тарҳи унарӣ (unary minus) - а-= 
 Амали навъ (cast operator) cast (data_type) variable 
 Амали андоза (sizeof) sizeof sizeof(datatype) 
 Амали ҷамъи унарии а+= ба ифодаи а=а+ ва тарҳи унарии а-= ба а=а-
 эквивалент мебошад. Амали cast барои навъи додашударо ба дигар навъи 
 базавӣ табдил додан истифода мешавад. Амали sizeof –амале мебошад, ки 
 барои муайянкунании бузургии операнди худ ба ҳисоби байт истифода бурда 
 мешавад. Амалванди (операнди) ин амал ҳамаи навъҳои стандартӣ мебошанд, 
 яъне ин амал андозаи навъҳои базавиро муайян мекунад. Наҳви умумии ин 
 амал tamenст: 
 variable =sizeof(data-types) 
 Мисол: a=sizeof(int); b=sizeof(double) ва ғайра. 
 Амалҳои ҳофиза 
 Дар забони С/С++ якчанд амалҳое мавҷуданд, ки адрес ё маҳалли физики
 тағйирёбандаи додашуда (нишондодашуда)-ро метавонад ба барномасоз 
 дастрас гардонад. Дар ҷадвали зерин ин амалҳо оварда шудаанд. 
 № Номи амал Аломат Наҳви Амали иҷромекардагӣ 
 амал 
 Суроға & &a Суроғаи тағйирёбандаи а-ро нишон 
 (адрес) медиҳад. 
 Нишона * *a Қимати додае, ки суроғаи он дар 
 (ссылка ё тағйирёбандаи а захира шудааст, 
 deference ) бармегардонад 
 Элементи [] a[n] Элементи (n+)-уми массивро муайян 
 массив мекунад 
 Нуқта (dot). a.b Қимати тағйирёбанда (ё элемент)-и b, 
 ки аз сохтори а мебошад, 
 бармегардонад. 
 Ақрабак ба -> a-> b Қимати тағйирёбанда (ё элемент)-и b, 
 рост (right ки суроғаи он дар тағйирёбандаи 
 arrow) ишорагари а қарор дорад, 
 бармегардонад. 
 Авлавияти амалҳо 
 Дилхоҳ ифода дар забонҳои барноманависӣ аз операндҳо 
 (тағйирёбандаҳо, доимиҳо ва ғайра) ташкил карда мешавад. Аз ин рӯ ҳангоми
 навиштани як ифода, зарурати донистани авлавияти амалҳо пеш меояд, яъне 
 лозим мешавад то бидонем, кадом амал аввал иҷро мешавад. Бигзор ифодаи 
 зерин дода шуда бошад: 
 y=+++/++ 
 барои муайян кардани қимати ин ифода, лозим аст, ки тартиби иҷроиши 
 амалҳоро донем, то ин ки қимати матлабро ба даст ояд. Дар ҷадвали зерин 
 тартиби иҷроиши амалҳо оварда шудаанд. 
 Аввалият Амал Маъно ва мафҳум Равиши амал 
 t 
 Як воҳид афзоиш (намуди f 
 e 
 ++ 
 L 
 пасвандӣ) 
 т 
 с 
 Як воҳид коҳиш (намуди о 
 -- р 
 пасвандӣ) 
 а 
 б 
 () Даъвати функсия п h t 
 аg 
 Дастрасӣба элементи чR i 
 [] 
 массив А 
 з 
 o 
 t 
 Интихоби элемент аз рӯи. 
 ишора 
 Интихоби элемент аз рӯи 
 -> 
 нишона 
 Табдилдиҳии навъ (const 
 const_cast 
 cast) (C++) 
 Табдилдиҳии навъ (dynamic 
 dynamic_cast 
 cast) (C++) 
 Табдилдиҳии навъ 
 reinterpret_cast 
 (reinterpret cast) (C++) 
 stat Табдилдиҳии навъ (static 
 c_cast cast) (C++) 
 Як воҳид афзоиш (намуди 
 ++ 
 пешвандӣ) 
 Як воҳид коҳиш (намуди ) 
 -- t 
 h 
 пешвандӣ) g 
 i 
 + Ҷамъи унарӣ R 
 o 
 - Фарқи унарӣ t 
 t 
 f! Инкори мантиқӣ e 
 L 
 ~ Инкори битӣ ( 
 т 
 с 
 (t Қолаб о 
 р 
 pe) а 
 б 
 * Гирифтани ишорагар п 
 а 
 & Гирифтани суроға ч 
 з 
 Sizeof Size-of (андоза) А 
 Ҷудо намудани ҳофизаи 
 new, new[] 
 динамикӣ (C++) 
 Озод намудани ҳофизаи 
 delete, delete[] 
 динамикӣ (C++).* Ишорагар ба аъзо (C++) 
 Ишорагар ба аъзо (C++) ) 
 t 
 h 
 ->* g 
 i 
 R 
 o 
 * Зарб t 
 t 
 f 
 / Тақсим e 
 L 
 % Бақияи тақсим ( 
 т 
 с 
 + Ҷамъ о 
 р 
 - Тарҳ а 
 б 
 << Лағжиши бити ба чап п 
 а 
 >> Лағжиши бити ба рост ч 
 з 
 < Хурд А 
 <= Хурд ё баробар 
 > Калон 
 >= Калон ё баробар 
 = Баробар!= Нобаробар 
 & Ва –и битӣ 
 ^ Ё-и битии истисно 
 (XOR) 
 | Ё-и битӣ 
 && Ва-и мантиқӣ 
 || Ё-и мантиқӣ?: Амали шартӣ Аз рост ба чап 
 (Right to Left) 
 = Бахшиш 
 += Бахшиш бо ҷамъ 
 ) 
 t 
 -= Бахшиш бо тарҳ e f 
 L 
 *= Бахшиш бо зарб o 
 t 
 /= Бахшиш бо тақсим t 
 h 
 g 
 %= Бахшиш бо бақия аз тақсим i 
 R 
 <<= Бахшиш бо кӯчиш ( п 
 а 
 ба чап ч 
 а 
 >>= Бахшиш бо кӯчиш ба б 
 т 
 Рост с 
 о 
 &= Бахшиш бо ва-и р 
 з 
 Мантиқӣ А 
 ^= Бахшиш бо ё-и 
 Мантиқии битӣ 
 |= Бахшиш бо ё-и битӣ 
 Throw Опрератори коркарди 
 ҳолтҳои истисноӣ (C++), Амали Comma Аз чап ба рост 
 (Left to Right) 
 Қайд: Аксари ин амалҳо дар рафти китоб эзоҳ дода мешаванд. 
 Тавре ки аз ин ҷадвал дида мешавад, дар мисоли овардашуда, аввал амали
 як воҳид афзоиш ба намуди пасвандӣ, баъд амали як воҳид афзоиш ба намуди 
 пешвандӣ, баъд амали тақсим ва дар охир амали ҷамъ иҷро карда мешавад. Аз
 ин ҷо қимати y= мешавад. 
 Таъриф. Тартиби иҷроиши амалҳоро, авлавияти амалҳо меноманд. 
 Қайд. Амалҳо метавонанд, аз чап ба рост ва ё баракс иҷро шаванд. 
 Муродифи амалҳо 
 Дар забони C++ калимаҳои калидие муаррифӣ шудаанд, ки ба якчанд 
 амалҳо муродиф мебошанд. Ба монанди: and (&&), bitand (&), and_eq (&=), or
 (||), bitor (|), or_eq (|=), xor (^), xor_eq (^=), not (!), not_eq (!=), compl (~).
 Амалкарди онҳо бо амалҳо айнан монанд буда, ба сифати амалҳо метавон 
 онҳоро истифода кард, яъне онҳо варианти дигари амалҳо мебошанд. Масалан,
 амали bitand на танҳо барои иваз намудани амали битии ва (&), инчунин 
 метавонад, ба сифати амали суроға низ истифода шавад. Масалан, операторҳои
 зерин бо ҳам баробарқувва мебошанд: 
 int bitand ref = n  int & ref = n 
 Дар стандарти ANSI C (ISO C) ин калимаҳои калидӣ, ҳамчун макросҳои 
 пешпардозанда муайян карда шудаанд, ки дар китобхонаи <iso.h> нигоҳ 
 дошта мешаванд. Барои якпорчагӣ бо C++ бошад, китобхонаи <ciso> мавҷуд
 аст. 
 Ифодаҳо (expression) 
 Ифодаҳо маҷӯи маънидоре мебошанд, ки бо ёрии амалҳои арифметикӣ, 
 мантиқӣ, муқоисанамоӣ ва ғайра ташкил карда мешаванд. 
 Ифодаҳоро ба сурати зерин метавон дастабандӣ кард: 
 ) Ифодаҳои арифметикӣ ифодаҳое ҳастанд, tame ёрии амалҳои арифметикӣ аз 
 рӯи қоидаи хоссе ташкил карда шудаанд. Мисол. 
 № Ифодаҳои риёзӣ Ифодаҳои забони С++ 
 (a+b)c (a+b)*c 
 a/(b+c) 
 Дар мисоли аввал адади a бо адади b ҷамъ намуда, сипас натиҷа бо c зарб
 карда мешавад. Дар м и со ли дуввум бошад, аввал b бо c ҷамъ карда мешавад,
 сипас адади а бо натиҷа тақсим карда мешавад. 
 ) Ифодаҳои муқоисакунӣ ифодаҳое ҳастанд, tame ёрии амалҳои 
 муқоисакунӣ бо риояи қонуни махсусе ташкил карда мешаванд. 
 Қимати ифодаҳои муқоисакунӣ хақ ва ё ноҳақ шуда метавонад, яъне агар
 шартҳои гузошташуда дуруст бошанд, қимати ифодаи муқоисакунӣ ҳақ ва дар 
 сурати акс, ба қимати ноҳақ баробар мегардад. Дар аксари забонҳои 
 барномасозӣ қимати ҳақ-ро true ва қимати ноҳақро false мегӯянд. Дар забони
 С++ бошад, қимати ҳақ ба (ё ба адади ғайринулии калон аз нол) баробар 
 буда, қимати ноҳақ ба баробар аст. 
 № Ифодаҳои риёзӣ Ифодаҳои забони С++ 
 a>b a>b 
 (a+b) (a+b)>=c 
 ) Ифодаҳои мантиқӣ ифодаҳоеанд, ки аз ифодаҳои арифметикӣ ва 
 муқоисакунӣ аққалан бо я к амали мантиқӣ ташкил шудаанд. Нисбат ба ду 
 ифодаҳои пешин ин навъ ифодаҳо мураккабтар ва пе-чидатар мебошанд. 
 Қимати ифодаҳои мантиқӣ ҳам ба ҳақ ё ноҳақ баробар шуда метавонанд. 
 № Ифодаҳои риёзӣ Ифодаҳои забони С++ 
 a>b>c (a>b )&& (b>c) 
 ((x/y)<=(a/b)) &&((a/b)<*x*y) 
 a (a<b)|| (a==b) 
 Операторҳо 
 Операторҳо ҳукмҳое ҳастанд, ки сабаби иҷро кардани амале мегарданд. 
 Дар забони С++ операторҳои зерин истифода бурда мешаванд: 
 ) Операторҳои сода операторҳоеанд, ки бо ёрии онҳо амалҳои 
 ғайришартӣ иҷро карда мешаванд. Масалан, операторҳои зерин сода 
 мебошанд: 
 а) бахшиш; 
 б) хондан ва навиштан ё дохилкунӣ ва хориҷкунӣ; 
 в) даъват (фурӯхони)-и функсия; 
 г) Гузариши бешарт ё равон кардани барнома ба нуқтаи нишондодашуда, 
 яъне goto; 
 ) Операторҳои сохта операторҳоеанд, ки аз навъи сохторҳои алгоритмӣ
 таркиб ёфтаанд, ба монанди: 
 а) Операторҳои мураккаб (compound statement) аз tame ё зиёда 
 операторҳои сода таркиб ёфтаанд; 
 б) Операторҳои даврӣ (repetitive statement) операторҳое ҳастанд, ки аз
 алгоритмҳои даврӣ таркиб ёфтаанд; 
 в) Операторҳои шартӣ (conditional tamen) операторҳое ҳастанд, ки аз 
 алгоритмҳои шартӣ таркиб ёфтаанд. 
 Дар оянда ин операторҳоро ба таври пурра шарҳ медиҳем. 
 Функсияҳои стандартӣ дар забони С++ 
 Забони С++ монанди дигар забонҳо аз функсияҳои стандартии зиёде 
 истифода мебарад. Аксари ин функсияҳоро функсияҳои мате-матикӣ низ 
 мегӯянд ва дар сурате онҳо ба кор медароянд, ки агар ки-тобхонаи <math.h>
 пайваст карда шуда бошад. Дар ҷадвали зерин рӯйхати ин функсияҳо оварда 
 шудааст. 
 № математика Маъно ва мафҳум 
 | | Қимати мутлақи адади х-ро муайян мекунад. 
 - Қимати мутлақи адади ҳақиқии х-ро муайян 
 мекунад. 
 Синуси адади х-ро муайян мекунад. 
 Косинуси адади х-ро муайян мекунад. 
 Тангенси адади х-ро муайян мекунад. 
 Аргтангенси адади х-ро муайян мекунад. 
 Арксинуси адади -ро муайян мекунад. 
 Экспоненти адади х-ро муайян мекунад. 
 Қимати логарифм и натуралии адади х-ро муайян 
 мекунад (x>) 
 Қимати логарифми даҳии адади х-ро муайян 
 мекунад (x>) 
 Қимати решаи квадратии адади х-ро муайян 
 мекунад (x ) 
 √ ax Адади а-ро ба дараҷаи х-мебардорад 
 - Адади ҳақи қи ро то калон шудан аз қисми 
 бутунаш яклухт мекунад 
 - Адади додашударо ба қисми бутун ва касрӣ ҷудо 
 мекунад 
 - Адади ҳақиқиро то аз қисми бутунаш хурд шудан 
 яклухт мекунад 
 - Бақияи тақсими адади x–ро бар y муайян мекунад 
 Ҳамаи ин функсияҳо қимати ҳақиқӣ қабул мекунанд. Баъзан функсияи 
 pow(a,x) қимати н од у р у с т медиҳад ё қимате намедиҳад, яъне дар ҳолате ки
 адади а мусбат буда, х адади касрӣ бошад, дар он ҳолат ин функсия қимат дода
 наметавонад. Пас, барои дар ин ҳолат қимат гирифтан онро ба намуди зерин 
 менависем. 
 Дар забони C++ баъзе аз ин функсияҳо барои дилхоҳ навъ сарборӣ карда
 шудааст, ма с ал а н б ар о и о н ки оператори pow(a,x) болои ададҳои бутуни дароз
 амалеро анҷом диҳад, зарур аст, ки ба сурати powl(, ) навишта шавад. Дар ин
 ҷо l –ҳарфи аввали калимаи long мебошад. 
 Саволҳо барои мустаҳкамкунӣ 
 муаррифӣ кард? 
 Масъалаҳо барои кори мустақила 
 Ифодаҳои зеринро дар забони С++ нависед. 
 y = 
 | | 
 √ 
 √ 
 y = x + x – y = x - x 
 y = x − – y = x − x + 
 y = arcsin x+x y = x + 
 y = x + ln√ | sin x + cos x | y = x·(sin ln x − cos ln x)
 y = arctg (sh x) + (sh x)·ln ch x y = ex ·(cos x + sin x)
 y = ex ·(cos x + sin x) y = x·(sin ln x − cos ln x) 
 y = − ( + x)·arctg y = x·(sin − cos ln x) 
 √ √ 
 Боби. Воситаҳои дохилкуниву хориҷкунӣ дар С++ 
 Муқаддима 
 Барои ягон маълумотро ба компютер дохил кардан ва ё маълумотеро ба 
 чоп додан дар забони С++ функсияҳои (functions) махсусе истифода мешаванд.
 Функсияҳои дохилкунию хориҷкунӣ дар китобхонаи (library)-и «iostream» 
 чойгиранд, ва барои аз ин функ-сияҳо (объектҳо) истифода бурдан дар аввал
 бояд ин китобхона ба барнома пайваст карда шавад. Яъне дар блоки пайвасти
 китобхонаҳо бояд фармонҳои зерин навишта шаванд: 
 #include <iostream> 
 using namespace std; 
 Дар ин ҷо фармони #include пешпардозанда буда, iostream тахфифи се 
 калима input-дохилкунӣ, output-хориҷкунӣ ва stream- ҷа-раён буда, дар якҷоягӣ
 маънои ҷараёни дохилкуниву хориҷкуниро дорад. Ҳарфи h- бошад, аз ҳарфи 
 аввали калимаи header-гирифта шуда, маънои сарлавҳаро дорад. Ҳангоми ин 
 библиотекаро пайваст намудан функсияҳои (объектҳои) cin, cout ва ғайра ба кор
 медароянд. 
 Барои маълумоти хориҷ кардашударо қолиббанди намудан бояд аз 
 функсияҳои библитекаи iomanip истифода бурда шавад, ин библитека низ 
 монанди дигар библиотекаи пеш аз истифодабарии пайваст карда мешавад. 
 Функсияҳои дохилкунию хориҷкунӣ хеле ба регистер (register) ҳассос 
 мебошанд. Аз ин ҷо бояд навъи тағйирёбандаҳое, ки дохил ё хориҷ карда 
 мешаванд, муайян бошад, то ки ба таври автоматӣ коркард гарданд, вагарна 
 барнома ба хатогӣ рубарӯ мешавад. 
 Ба ғайр аз функсияҳое, ки то ҳол номбар шуданд, забони С++ метавонад
 аз функсияҳои дохилкунию хориҷкунии С истифода кунад. Функсияҳои асосии 
 дохилкунию хориҷкунӣ дар забони С scanf() ва printf() мебошанд, ки онҳоро
 функсияҳои қолабдор мегӯянд. Бо ёрии ин функсияҳо ададҳо, рамзҳо ва сатрҳо
 ба компютер (барнома) дохил ва хориҷ карда мешаванд. Ба ғайр аз ин, 
 функсияҳои getchar() ва putchar() барои дохилкунӣ ва хориҷкунии як рамз ва
 функсияҳои gets() ва putch() барои дохилкунию хориҷкунии сатрҳо истифода 
 бурда мешаванд. Барои аз ин функсияҳо истифода намудан бояд библиотекаи 
 stdio пайваст карда шавад. stdio низ тахфифи се калимаи англисии standard-
 стандарт, input-дохилкуни ва output-хориҷкунӣ буда, маънояш дохилкунию 
 хориҷкунии стандартӣ мебошад. 
 Функсияҳои дохилкунию хориҷкуни метавонанд дар дилхоҳ ҷои барнома 
 истифода шаванд. Ҳоло ба навбат функсияҳои дохилкунӣ ва хориҷкунии С ва 
 баъд С++-ро дида мебароем. 
 Функсияҳои дохилкунию хориҷкунии қолабдор ( formatted console 
 input/output) 
 Тавре ки гуфтем, дар забони С функсияҳои scanf() ва printf() функсияҳои
 қолабдор мебошанд, яъне ин функсияхо ба барномасоз имконият медиҳанд, ки 
 додаҳои гуногунро ба барнома дохил ва хориҷ намуда, коркард кунад. 
 Функсияи printf() барои додаҳои гуногунро дар саҳифаи тасвир (console ) чоп
 намудан истифода бурда мешавад, функсияи scanf() бошад, баръакси printf()
 амал мекунад, яъне додаҳоро аз саҳифаи вурудӣ мехонад. Ҳар яке аз ин 
 функсияҳоро ба таври муфассал дида мебароем. 
 Функсияи printf() 
 Функсияи printf() барои чоп намудани дилхоҳ навъи додаҳо истифода 
 бурда мешавад. Ин функсия метавонад якчандто аргумент дошта бошад, ки 
 онҳо аз ҳамдигар бо вергул ҷудо карда мешаванд. Аргументҳои сатрӣ дар 
 дохили нохунак навишта мешаванд ва Тавре ки гуфтем, ин функсия функсияи 
 қолабдор мебошад ва қолаби дода-ҳои он дар дохили қавс навишта мешаванд. 
 Наҳви умумии истифодабарии ин функсия ба намуди зерин аст: 
 printf(“control string ”,arg,arg,…,argn) 
 Дар ин ҷо control string-сатр ё рамзи идоракунанда буда, arg, arg, …,argn
 аргументҳои ин функсия мебошанд. 
 Сатрҳои идоракуни чунин сатрҳое мебошанд, ки дар дохили нохунак 
 (double quotation) навишта шуда, навъи аргументҳои функсияро муайян 
 мекунанд. Дар ҷадвали зерин якчандтои онҳо оварда шудаанд. 
 Код Маънои фармони қолаб( навъи иттилооти чопшаванда) 
 %c (character data Item)- Додаҳои навъи рамзӣ 
 %d (Signed decimal Integer)-Додаҳои навъи бутуни аломатдор 
 %f (floating-point decimal notation)-Додаҳои навъи ҳақиқӣ 
 %e (floating-point exponential notation)-Додаҳои навъи floating_point - и
 аломатдор 
 %g (floating-point (%f or %e) width char shorter)-Додаҳои навъи floating-point
 бо қолаби %f ё %e 
 %u (Unsigned decimal integer)-Додаҳои навъи бутуни беаломат 
 %s (String)-Додаҳои сатрӣ 
 %o (unsigned octal integer )-Додаҳои навъи бутун дар асоси системаи ҳисоби
 ҳаштӣ 
 %x (unsigned hexadecimal integer)- Додаҳои навъи бутун дар системаи ҳисоби
 шонздаҳӣ 
 %L (Prefix used with %d, %u, %x, %o, to specify long integer )-Адади бутуни
 дароз дар қолаби %d, %u, %x, %o 
 %I (Signed decimal integer)-Додаҳои навъи бутуни аломатдор 
 %p (display a pointer)-Додаҳои навъи ишорагар 
 Мисоли. Истифодаи функсияи printf(). 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 double Pi =.; 
 int Int =; 
 printf("%f %d", Pi, Int); 
 cin.get(); 
 return; 
 } 
 Дар ин ҷо қолаби %d –нишондиҳандаи адади бутун (яъне якум 
 аргументи функсияи printf () адади бутун мебошад), фармати %f- 
 нишондихандаи ададҳи ҳақиқӣ (яъне нишон медиҳад, ки аргументи дуюми 
 функсияи printf () адади ҳақиқӣ мебошад). Як фосилаи холӣ байни қолабҳо 
 гузоштем барои натиҷаҳоро аз ҳамдигар бо як ҷои холӣ ҷудо кардан. Агар ҷои
 холӣ гузошта нашавад натиҷаи дуввум аз паси натиҷаи аввала меояд ва дидани
 натиҷаҳои ҷори имконнопазир мегардад. 
 Аргументҳои функсияи мазкур на танҳо ададҳо (тағйирёбандаҳо), балки 
 метавонанд ягон ифода бошанд. 
 Мисоли. Хориҷкунии ифодаҳо ва ададҳо. 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 double Pi =.; 
 int Int =; 
 printf("%f %d", Pi, Int * - ); 
 cin.get(); 
 return; 
 } 
 Ба ғайр аз ин, функсияи мазкур дар дилхоҳ минтақаи саҳифаи тасвир 
 хориҷ намудани натиҷаро фароҳам меорад. Дарозии май-донро бо навиштани 
 як адади бутун дар байни аломати % ва коди қолаб муайян мегардад. Агар 
 хоҳем, ки фазои холӣ бо нол пур карда шавад, пеш аз адади гуфташуда нол 
 менависем. Дар мавриди ададҳои ҳақиқии дароз бошад, барои пас аз вергул 
 чоп намудани микдори разрядҳои лозимӣ (аниқ), пас аз рамзи % як нуқта ва 
 микдори разрядҳои лозимиро менависем. Масалан, қолаби %.f-ададеро бо 
 ҳашт рамз бо дарозии майдон ва се рақам баъди вергул чоп мекунад. 
 Мисоли. Истифодаи қолаб дар функсияи printf(). 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 double Pi =.; 
 int Int =; 
 printf("%.f % d\n", Pi, Int); 
 printf("%.f % d \n", Pi, Int); 
 printf("%.f % d \n", Pi, Int); 
 printf("%.f % d \n", Pi, Int); 
 printf("%.f % d \n", Pi, Int); 
 cin.get(); 
 return; 
 } 
 Натиҷаи барнома намуди зеринро дорад: 
 Тавре дида мешавад, дар ин ҷо якчанд сатр чоп шуд ва дар онҳо дарозии
 майдон, яъне аз кадом мавқеи саҳифаи тасвир навишта шудани маълумот 
 нишон дода шудааст ва дар адади якум пайдарпай нишон дода шудааст, ки 
 баъд аз вергул чанд разряд гирифта шавад. 
 Ба ҳамин монанд дарозии майдонро барои дилхоҳ навъи додаҳои сатрӣ ва
 ададӣ метавон муайян кард. Ин амал барои сатрҳо (риштаҳо) ҳам монанди 
 ададҳо мебошад, яъне агар дарозии сатр аз дарозии майдони пешбинишуда 
 камтар бошад, тарафи чапи он ба микдори лозимии ҷои холӣ (фосила) пур 
 карда мешавад ва дар сурати баръакс, барои пуррра намоиш додани сатр ҷои 
 холӣ ҷудо карда мешавад. Ва агар қолабе, ки барои ададҳои ҳақиқӣ ба кор 
 бурдем (яъне баъди вергул микдори разряд ҳои чопшаванда ҳамчун мисоли 
 пешина мушаххас карда шавад) истифода шавад, микдори рамзҳои 
 намоишдодашуда аз ададе, ки пас аз нуқта навишташуда камтар бошад, 
 рамзҳои аз он адад зиёд аз тарафи рост намоиш дода намешаванд ҳарчанд, ки
 дарозии майдон аз дарозии сатр калонтар бошад. 
 Мисол. Хориҷ кардани сатр тавассути функсияи printf(). 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 char Satr[] = "Man Barnameasozam"; 
 printf(" % s", Satr); 
 printf("\n % s", Satr); 
 printf("\n%.s", Satr); 
 printf("\n%.s", Satr); 
 printf("\n%.s\n", Satr); 
 cin.get(); 
 return; 
 } 
 Натиҷаи барнома намуди зеринро дорад: 
 Man Barnameasozam 
 Man Barnameasozam 
 Man Barname 
 Man Barnamasoz 
 Man 
 Тавре ки мушоҳида кардем, дар сатри якум ҳарчанд ки дарозии майдон аз
 дарозии сатри додашуда хурд буд, сатр пурра чоп гардид. Сатри дуюм бошад,
 бо панҷ фазои холӣ (яъне дарозии майдон аз дарозии сатри додашуда чор рамз
 бештар буд ва як фазои холигии байни қолабҳо ) чоп гардид. Сатри сеюм 
 бошад, ёздаҳ рамзи сатрро ба чоп додаст. Тавре ки каблан гуфта будем, пас аз
 нуқта чи қадар қимате омада бошад, ҳамон кадар рамз чоп мегардад, ҳарчанд,
 ки дарозии майдон аз дарозии сатри додашуда калонтар бошад. Танҳо пеш аз 
 сатр ба микдори зиёдатиаш ҷои холӣ боқӣ мегузорад ва билохира сатри чорум
 бошад, танҳо се рамзӣ сатрро ба чоп медиҳад, зеро дар қолаб ҳамин кадар 
 нишон дода шудааст. 
 Функсияи scanf() 
 Функсияи scanf() барои аз клавиатура ба барнома дохил намудани қимати
 тағйирёбандаҳо истифода бурда мешавад. Аз рӯи наҳви истифодабарӣ монанди 
 функсияи printf() буда, баръакси он амал мекунад. Аргументҳои функсияи 
 мазкур метавонанд аз дилхоҳ навъи додаҳо ба монанди додаҳои ададӣ, рамзӣ ва
 сатрӣ бошанд. Пеш аз ҳар як аргументи он оператори адреси (&) навишта 
 мешавад. Наҳви умумии ин функсия ба сурати зерин аст: 
 scanf(“control string ”,&arg&,arg,…,&argn) 
 Тавре ки дида мешавад, наҳви умумии ин функсия ҳам ба функсияи printf
 монанд буда, танҳо бо як оператори адрес фарқ мекунад. Ҳангоми додаҳои 
 сатрӣ ро ба барнома ворид намудан пеш аз тағйирёбанлаи сатрӣ ҳоҷати 
 навиштани оператори адрес нест, зеро сатрҳо дар забони С++ ҳамчун 
 массивҳои рамзӣ муаррифӣ карда мешаванд ва номи массив бошад, адреси 
 аввалаи онро нишон медиҳад. Мисол: 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 char name[]; 
 printf("Input Name "); 
 scanf("%s", name); 
 printf("Output Name = %s", name); 
 cin.get(); 
 return; 
 } 
 Рамзҳои идоракунандаи функсияи мазкур монанди рамзҳои идо- 
 ракунандаи функсияи printf() мебошанд 
 Код Маънои фармони қолаб( навъи иттилооти чопшаванда) 
 %c (character data Item)- Додаҳои навъи рамзӣ 
 %d (Signed decimal Integer)-Додаҳои навъи бутуни аломатдор 
 %i Додаҳои навъи бутуни аломатдор (Signed decimal integer) 
 %u (Unsigned decimal integer)-Додаҳои навъи бутуни беаломат 
 %f,%e,%g Додаҳои навъи ҳақиқӣ 
 %h Додаҳои навъи бутуни кӯтоҳ (short int) 
 %s Додаҳо аз намуди як сатре, ки ҳангоми воридшавӣ тавассути рамз 
 non_white_space оғоз гардида, ба рамзи white_space ба охир мерасад
 (Ба охири сатр ба таври автомати рамзӣ % илова мегардад) 
 %o Додаҳо аз намуди бутуни ҳаштӣ 
 %x,%X (unsigned hexadecimal integer)- Додаҳо аз навъи адади бутун дар
 системаи ҳисоби шонздаҳӣ 
 %p (display a pointer)-Додаҳо аз навъи ишорагар 
 Илова бар ин, дар библиотекаи stdio функсияҳои дигари дохилкунӣ ва 
 хориҷкунӣ мавҷуданд, ки маъмултаринашонро дида мебароем. 
 Функсияи getchar() ва putchar() 
 Функсияи getchar барои хондани як рамз хизмат карда, дорои аргумент 
 намебошад, балки амали бахшиш (ҷойгузори)–ро иҷро мекунад, яъне рамзи 
 воридшударо ба тағйирёбандае, ки дар тарафи чапи он воқеъ аст, бахшида 
 мешавад. Наҳви умумии ин функсия чунин аст: 
 character variable =getchar() ё Тағйирёбандаи рамзи=getchar() 
 Функсияи putchar барои навиштан ё чоп намудани як рамз дар саҳифаи 
 тасвир хизмат мекунад. Наҳви умумии ин функсия чунин аст: 
 putchar(Character variable ) ё putchar (Тағйирёбандаи рамзӣ) 
 Функсияҳои дохилкунӣ ва хориҷкуни дар забони С++ 
 Дар забони С++ дохилкунӣ ва хориҷкунии додаҳо ба барнома ҳамчун 
 ҷараёни байтҳо (ҷараён-пайдарпайи байтҳо) сурат мегирад. Ба намуди пешфарз
 барои дохил нимудани иттилоот ба компютер клавиатура, дисковод, 
 флейшдискҳо, сет, сканер ва ғайра истифода шуда, барои хориҷкунӣ бошад, 
 принтер, дисковод ба ғайра хизмат мекунанд. 
 Дар забони С++ барои пайдарпайии байтҳоро ба компютер дохил ва ё аз 
 он хориҷ намудан аз функсияҳои (объектҳои) зиёде истифода мебаранд. Барои
 аз функсияҳо (объектҳои) истифода бурдан, пеш аз ҳама, библиотекае, ки дар
 он фармонҳои дохилкунӣ ва хориҷкунӣ мавҷуд аст, пайваст карда мешавад. 
 #include <iostream> 
 Ин китобхона дорои якчанд шаблонҳо мебошад. 
 Тавре ки аз нақша мушоҳида карда мешавад, шаблонҳои basic_istream ва
 basic_ostream меросгири рости шаблони базавии basic_ios буда, шаблони 
 iostream бошад, меросбари якчанд синф basic_istream ва basic_ostream мебошад.
 Барои дохил намудани маълумотҳо аз объекти cin, ки аз шаблони синфи 
 istream мебошад, истифода бурда мешавад. Сабаби объект ном бурдани cin ва
 cout дар он аст, ки онҳо объекти класси iostream мебошанд. Калимаи cin шакли
 тахфифи ду калимаи англисии с-номи забон ё ҳарфи аввали console ва in ду 
 ҳарфи аввалаи калимаи input-дохилкунӣ буда, маънои аз клавиатура дохил 
 намудани маълумотҳоро дорад. Ин чунин амалгарҳои кӯчиш (лағжиш) ба рост 
 (сдвиг вправо) << дар объекти хориҷкунӣ ва лағжиш (кӯчиш) ба чап (сдвиг 
 влево) >> дар объекти хориҷкунӣ истифода бурда мешаванд. Истифодаи 
 амалгарҳои мазкур маъно аз рӯи байтҳо хондан ва навиштани додаҳоро дорад.
 Функсия (Объект )-ҳои хориҷкунӣ 
 Синфи ostream дар забони С++ имконият медиҳад, ки додаҳо ба таври 
 шаклбандишуда ва бешаклбандишуда ба саҳифаи тасвир ба-роварда шаванд. 
 Синфи мазкур дорои объектҳои хориҷкунии зиёде мебошад, ки 
 муҳимтаринашон дар ҷадвалии зерин оварда шудаанд. 
 Номи Маъно ва мафҳум 
 объект 
 Cout Барои хориҷкунии додаҳои навъҳои стандартӣ истифода бурда 
 мешавад. 
 Put Барои хориҷкунии рамзҳо истифода бурда мешавад. 
 write Барои хориҷкунии битҳо (маълумотҳо) 
 Get Барои хориҷкунии як рамз истифода бурда мешавад. 
 getline Монанди get буда, барои хориҷкунии якчанд рамз истифода 
 бурда мешавад. 
 Ин объектҳо якҷоя бо объекти якум, яъне cout истифода бурда мешаванд.
 Дар оянда ҳар яке аз ин объектҳоро муфассал дида мебароем. Ҳоло бошад, 
 объекти cout-ро мавриди баҳс қарор медиҳем. Тавре ки пештар гуфтем, объекти
 cout барои аз барнома ба саҳифаи тасвир баровардани маълумотҳои навъҳои 
 стандартии ва инчунин сатрҳо истифода бурда мешавад. Худи объекти мазкур 
 ҳам аз ду калимаи англисии С-номи забон ё ҳарфи аввали калимаи console ва
 out шакли кӯтоҳшудаи output-хориҷкунӣ гирифта шудааст. Мисол: 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 cout << "Istifodai obekti cout dar C++"; 
 cin.get(); 
 return; 
 } 
 Ҳангоми пахши тугмачаи F дар саҳифаи тасвир пайғоми: Istifodai obekti
 cout dar C++ чоп карда мешавад. 
 Тавре ки дидем, пас аз чопи сатри додашуда курсор дар паси матн (сатр)
 қарор гирифт. Агар хоҳем, ки он дар сатри нав ҷойгир шавад, пас аз сатри 
 навишташуда, пеш аз пӯшидани нохунак рамзи хати каҷ (слейш-\ ) ва ҳарфи n-
 ро мегузорем. Матни барномаи мо намуди зеринро мегирад. 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 cout << "Istifodai obekti cout dar C++\n"; 
 cin.get(); 
 return; 
 } 
 Натиҷаи барнома намуди зеринро дорад: 
 Istifodai obekti cout dar C++ 
 -| 
 Тавре ки мушоҳида гардид, пас аз гузоштани хати каҷ ва ҳарфи n курсор
 дар сатри нав қарор гирифт. Ҳарфи n, ки мо дар ин ҷо истифода бурдем, ҳарфи
 аввали калимаи NewLine-хати нав мебошад. Хати каҷ бошад, маънои escape 
 (переход) –гузаштан ва ё озод шуданро дорад. Дар забони С++ якчанд рамзҳое
 (ҳарфҳое) мавҷуданд, ки онҳоро рамзҳои идоракунанда мегӯянд. Ҳоло дар 
 ҷадвали зерин якчандтои онҳоро меорем. 
 Рамз Маъно ва мафҳум 
 \n Барои ба сатри нав (newline) кӯчонидани курсор 
 \t Барои дар сатри мавҷудбуда сархати горизонталӣ (horizontal 
 tab) гузоштан 
 \r Барои ба аввали сатр овардани мавқеи курсор 
 \a Садои зангулаи системавӣ (сигнал тревога) 
 \\ Слеши баракс барои чопи рамзи слеши чаппа 
 \” Барои чоп намудани нохунак 
 Ин рамзҳо кариб дар тамоми компиляторҳои забонҳои оилаи С/C++ якхел 
 истифода бурда мешаванд. 
 Функсияи put 
 put функсия набуда, балки функсия-аъзо (функсия-член) мебо-шад ва он
 якҷоя бо оператори хориҷкунии cout истифода бурда шуда, имконияти чопи 
 танҳо як рамзро дорад. Бо ибоаи дигар, аргументи он танҳо як рамзи ASCII-код
 мебошад. Масалан, фармони зерин дар саҳифаи тасвир ҳарфи A-ро ба чоп 
 медиҳад. 
 std::cout.put('A'); 
 Ин сатри фармони дар саҳифаи тасвир ҳарфи A-ро намош дода, курсор 
 дар пасаш қарор мегирад. Барои курсорро ба сатри навбати овардан аз рамзҳои
 идоракунанда истифода бурда мешавад. 
 std::cout.put(‘A’).put(‘\n’); 
 Оператори мазкур метавонад, ба сифати аргумент кодҳои ASCII-ро 
 истифода барад. Мисол фармони зерин дар саҳифаи тасвир ҳарфи A-ро намоиш 
 медиҳад, зеро ки ASCII-коди ҳарфи А мебошад. 
 std::cout.put().put('\n'); 
 Функсияҳои get ва getline 
 Функсияи get барои дохилкунии як рамз, дар ҷои муайяншуда истифода 
 бурда мешавад. Ин функсия ҳангоми дохилкунӣ метавонад дорои аргумент ва ё
 бе аргумент бошад. Дар сурати истифодабарии аргумент символи 
 воридкардашуда ба он бахшида мешавад. Ва дар акси ҳол, бояд функсияи 
 мазкур тавассути тағйирёбандаи дигар даъват карда шавад. 
 Мисол. 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 char chr; 
 chr = cin.get(); 
 cout.put(chr); 
 cin.get(); 
 return; 
 } 
 Тавре ки аз ин мисол бармеояд, функсияи мазкур якҷоя бо оператори 
 дохилкунии cin истифода шуда, қимати воридшударо ба тағйирёбандаи chr 
 бахшид, ҳол он ки мо метавонистем онро ба сурати зерин истифода барем. 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 char chr; 
 cin.get(chr); 
 cout.put(chr); 
 cin.get(); 
 return; 
 } 
 Тавре ки мушоҳида шуд, дар ин ин ҷо функсияи get() тағйирёбандаи 
 лозимиро ҳамчун аргумент қабул намуда, қимати онро вориди барнома сохт. 
 Агар дар саҳифаи тасвир ҳангоми дохил намудан якчанд рамз нависем, аз он 
 рамзҳо танҳо аввалинашро вориди барнома мекунаду халос. 
 Равиши дуюми истифодабарии ин функсия то расидан ба нишонаи 
 интиҳои матн ба аргументи символӣ пайиҳам рамзҳоро мебахшад. Ин равишро 
 баъдтар ҳангоми истифодабарии операторҳои идоракунӣ дида мебароем. 
 Равиши сеюми истифодаи ин функсия бошад, дорои се параметр 
 мебошад. Массиви рамзӣ (ягон сатр), адади максималии микдори рамзҳои 
 массив ва рамзи идоракунанда хусусан (‘\n’). Ин равиши истифодабарӣ 
 рамзҳоро то замоне ки аз микдори максимали додашуда як воҳид хурданд 
 мехонад, яъне (max-)-рамзро мехонад. Мисол: 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 const int Size =; 
 char Satr[Size]; 
 cin.get(Satr, Size); 
 cout << Satr << "\n"; 
 cin.get(); 
 return; 
 } 
 Функсияи getline () бошад, монанди равиши сеюмӣ буда, чи кадаре ки 
 микдори максималӣ бошад, ҳамон қадар рамзро мехонад. Яъне он рамзи 
 махдудкунанда (рамз ограничитель)-ро аз ҷараён нест карда, онро ба массив
 илова наменамояд. 
 #include <iostream> 
 #include <conio.h> 
 using std:: cout; 
 using std:: cin; 
 using std:: endl; 
 int main(){ 
 const int Size =; 
 char Satr[Size]; 
 cin.getline(Satr, Size); 
 cout << Satr << "\n"; 
 cin.get(); 
 return; 
 } 
 Функсияи мазкур бештар ҳангоми ягон файли маълумотиро хондан 
 истифода бурда мешавад, ки дар оянда дар мавзӯи файлҳо муфассал ин 
 матолибро дида мебароем. 
 Тавре ки мушоҳида кардем, барои истифодабарии ҳар як объекти 
 библиотекаҳои додашуда мо баъд аз муаррифӣ намудани библиотека using std::
 номи объект ва ё пеш аз ҳар объект дар дилхоҳ ҷои барнома фармони std::номи
 объект-ро менавистем. Ин амал метавонад моро дилгир созад ва матни 
 барномаро зиёд гардонад. Ҳоло равишеро дида мебароем, ки дар ин ҳолат 
 навиштани ин калимаҳо шарт намегардад. Барои иҷрои ин амал пас аз номи 
 библиотека «.h» менависем, ки дар ин ҷо h ҳарфи аввалаи калимаи header- 
 сарлавҳа мебошад. Тарзи истифодаи ин равиш шакли зеринро дорад: 
 #include <номи китобхона.h>. 
 Мисол #include <iosteram.h> 
 Аз ин ҷо мисоли дар боло овардашударо метавон ба сурати зерин низ 
 навишт. 
 #include <iostream.h> 
 int main(){ 
 const int Size =; 
 char Satr[Size]; 
 cin.getline(Satr, Size); 
 cout << Satr << "\n"; 
 cin.get(); 
 return; 
 } 
 Тавре ки мушоҳида кардем, дар ин равиш се сатр коди барномаи ки аз 
 фармонҳои зерин иборат буданд, ихтисор гардид. 
 using std:: cout; 
 using std:: cin; 
 using std:: endl; 
 Қайд. Дар станарти нави С++ ба ҷойи.h фармони using namespace std 
 навишта мешавад. 
 Беқолаббанди дохил ва хориҷ намудани маълумотҳо 
 Бо истифода аз функсияҳои read ва write синфҳои istream ва ostream 
 маълумотҳоро метавонем бе қолиббандӣ дохил ва ё хориҷ кунем. Ҳар яке аз ин
 функсияхо метавонад микдори нишондодашудаи рамзҳоро ворид ва ё хориҷ 
 кунанд. Ҳоло ҳар яке аз ин функсияҳоро диде мебароем. 
 Функсияи write()-ин функсия якҷои бо оператори cout истифода шуда, 
 дорои ду аргумент массиви рамзӣ ва андозаи он мебошад, яъне миқдори ба 
 саҳифаи тасвир чоп намудаи рамзҳо нишон дода мешавад. Агар миқдори 
 рамзҳои массив аз адади нишондодашуда кам бошанд, он гоҳ дар саҳифаи 
 тасвир ба ҷои ҳар як рамз як ҷои холӣ мегузорад. Мисол: 
 char chr[] = "ABCDEFGHIJ"; 
 cout.write(chr, ); 
 Ин мисол рамзи аввалаи массиви chr-ро ба чоп медиҳад. Ҳар як рамз ба
 адреси аввалаи худ ишора мекунад. Ин мисолро метаво-нистем ба сурати зерин
 нависем. 
 cout.write("ABCDEFGHIJ",); 
 Функсияи мазкур аз массиви рамзии додашуда метавонад микдори 
 дилхоҳи рамзҳои аввалаашро ба чоп диҳад. 
 Функсияи read бошад, баръакси функсияи write амал намуда, микдори 
 нишондодашудаи рамзҳоро ба барнома дохил мекунад. Ин функсия ҳам дорои 
 ду аргумент яке рамзи ва яке адади бутуни мусбат мебошад, ки аргументи 
 рамзи адрес ё номи массиви рамзӣ буда, адади бутуни мусбат бошад, микдори
 рамзҳои лозимиро нишон медиҳад. Мисол: 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 char chr[]; 
 cin.read(chr, ); 
 cout.write(chr, ); 
 cin.get(); 
 return; 
 } 
 Функсияи gcount бошад, оид ба миқдори рамзҳои охирони воридшуда 
 хабар (ахбор) медиҳад. Мисол: 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 char chr[]; 
 cin.read(chr, ); 
 cout.write(chr, cin.gcount()); 
 cin.get(); 
 return; 
 } 
 Тавре ки дидем, дар ин ҷо микдори рамзи чопшаванда нишон дода 
 нашуда аст, вале он микдоре, ки ҳангоми дохилшавӣ нишон додашуда буд ба 
 чоп бароварда шудааст. 
 Ҳарфҳои криллӣ дар C++ 
 Дар хати фармони Windows асосан аз кодгузории OEM ва дар худи СО 
 Windows бошад, аз кодгузории ANSI истифода бурда мешавад. Аз ин ҷо дар 
 С++ ҳангоми ба сифати пайғом ё натиҷа хориҷ кардани ҳарфҳои криллӣ, дар 
 вақти иҷроиши барнома ҳарфҳои шикастае пайдо мешаванд, ки хондан ва дарки
 онҳо ғайриимкон мегардад. 
 Барои аз ин душвори халос шудан роҳҳои гуногуе мавҷуд аст. Масалан, 
 дар Borland C++ Builder одатан аз функсияи CharToOem() истифода бурда 
 мешавад. Дар забони Dev C++ бошад, аз барномаҳои gccrus.exe ва g++rus.exe.
 Функсияи CharToOem() функсияи мантиқӣ буда, барои сатри додашударо 
 бо стандарти ANSI мувофиқ ё табдил додан истифода бурда мешавад. Наҳви 
 умумии функсияи мазкур намуди зеринро дорад: 
 bool CharToOem( STR Src, STR Dst ) 
 дар ин ҷо Src сатри додашуда ва Dst ҳофиза (буфер) барои нигоҳ 
 доштани сатри табдилдодашуда мебошад. Барои аз функсии мазкур истифода 
 кардан бояд китобхонаи windows.h пайваст карда шавад. 
 Ҳангоми истифодаи функсияи мазкур маслиҳат он аст, ки функсияе 
 муаррифӣ карда шуда, дар ҳолати лозими аз он истифода бурда шавад. Мисол,
 дохил ва хориҷ кардани ҳарфҳои криллӣ. 
 #include <iostream> 
 #include <windows.h> 
 using namespace std; 
 char* Krill(char* s) { 
 static char buf[]; 
 CharToOem(s, buf); 
 return buf; 
 } 
 int main() { 
 cout << Krill("Номатонро дохил кунед:\t"); 
 char Name[]; 
 cin >> Name; 
 cout << Krill("Салом\t"); 
 cout << Name << "!" << endl; 
 cin.get(); 
 return; 
 } 
 Дар ин ҷо аввал бо ними Krill функсияе навишта шуда, сипас он дар 
 функсияи асосӣ истифода шудааст. Натиҷаи барнома намуди зеринро дорад: 
 Номатонро дохил кунед: Саид 
 Салом Саид! 
 Дар барномаҳои корбурди консолӣ ҳарфҳои русӣҳамчун стандарти 
 рамзгузории CP- намоиш дода мешаванд. Дар муқоваи Dev-C + + бошад, 
 ҳамчун кодгузории CP- истифода мешаванд. Ин маънои онро дорад, ки 
 ҳангоми истифодаи ҳарфҳои криллӣ дар саҳифаи тасвир ҳарфҳои шикастае 
 пайдо мешаванд, имконияти хондани онҳо вуҷуд надорад. Барои аз ин душвори
 раҳо шудан аз барномаҳои (файлҳои) gccrus.exe ва g++rus.exe истифода бурда
 мешавад. 
 Алгоритми истифодаи ин барномаҳоро дар Dev-C++ шакли зеринро 
 дорад: 
 ) Файли архиве, ки дар дохили он барномаҳои gccrus.exe ва g++rus.exe
 ҷойгиранд, аз интернет берун меоварем. Ҳаҷми архив тақрибан Кб аст. 
 ) Барномаҳои gccrus.exe ва g++rus.exe –ро дар суроғаи зерин 
 нусхабардорӣ мекунем: “C:\Dev-Cpp\bin” (яъне дар каталоги bin, ки 
 зеркаталоги каталоге ки дар он ҷо Dev-C ++ насб шудааст.) 
 ) Dev-C++ро ба кор омода сохта, аз менюи Tools (Сервис) фармони 
 Compiler Options (Параметры компилятора)-ро иҷро мекунем. 
 ) Дар варақии Programms номи ду барномаи авваларо ба таври зерин 
 тағйир медиҳем, яъне тугмачаи охири сатри gcc ва g++ -ро пахш карда, аз онҷо
 мувофиқан файлҳои gccrus.exe ва g++rus.exe –ро аз каталоги bin мекушоем 
 (расми зерин). 
 ) Баъд аз иҷрои ин амалиёт бе душворӣ метавонем аз ҳарфҳои криллӣ 
 истифода барем. 
 Мисол. Истифодаи ҳарфҳои криллӣ дар Dev c++ 
 #include <cstdlib> 
 #include <iostream> 
 using namespace std; 
 int main() { 
 cout << "Номатонро дохил кунед:\t"; 
 char Name[]; 
 cin >> Name; 
 cout << "Салом\t"; 
 cout << Name << "!" << endl; 
 return; 
 } 
 Натиҷаи барнома намуди зеринро дорад: 
 Номатонро дохил кунед: Саид 
 Салом Саид! 
 Саволҳо барои мустаҳкамкунӣ 
 ) Функсияҳои дохилкунӣ ва хориҷкунӣ дар забони С кадомҳоянд? 
 ) Объекти cin аз функсияи scanf() чӣ фарқ дорад? 
 ) Насби библиотека магар зарур аст? 
 ) Оё мумкин аст дар як барнома ҳангоми пайваст намудани ягон 
 библиотека ҳам.h ва ҳам using namespage std истифода бурда шавад? 
 ) Дар функсияҳои дохилкунию хориҷкунӣ кадом синфҳо дар забони С++ 
 мавҷуданд? 
 ) Синфи ifstream чӣ гуна синф аст? 
 ) Библиотекаҳои С++ дар куҷо нигоҳ дошта мешаванд? 
 ) Оператори std::cout чӣ амалро иҷро мекунад? 
 ) Чи тавр ҳарфҳои крилли дар саҳифаи тасвир хориҷ карда мешаванд? 
 )Чӣ тавр ҳарфҳои криллӣ дар С++ истифода бурда мешаванд? 
 Намунаи ҳалли масъалаҳо 
 ) Тарафҳои росткунҷа a ва b дода шудааст. Барномае нависед, ки 
 перимери росткунҷа-ро ҳисоб кунед. 
 #include <iostream> 
 using namespace std; 
 int main() { 
 float a, b, P; 
 cout << "Adadhoi a va b - ro dohil kuned!\n"; 
 cin >> a >> b; 
 P = a*b; 
 cout << "Perimetri rostkunja ba " << P << " barobar ast.\n"; 
 return; 
 } 
 ) Дарозии тарафҳои секунҷа a,b,c дода шудаанд. Барномае нависед, ки бо
 истифода аз формулаи Герон масоҳати онро ҳисоб кунед. 
 Қайд: Формулаи Герон намуди зеринро дорад, 
 ки дар ин ҷо r-нимпериметр мебошад. Ва аз геометрия маълум аст, ки 
 √ 
 P=a+b+c ва 
 #include <i o s t r eam> 
 #inc l ude <cma th> 
 using namespace std; 
 int main() { 
 float a, b, c, r, S; 
 cout << "Adadhoi a b va c - ro dohil kuned!\n"; 
 cin >> a >> b >> c; 
 r = (a + b + c) /; 
 S = sqrt(r*(r - a)*(r - b)*(r - c)); 
 cout << " S = " << S; 
 return; 
 } 
 ) Ададҳои бутуни b ва р дода шудаанд. Барномае нависед, ки р фоизи 
 адади b-ро муайян кунад. 
 Қайд. «Барои p фоизи адади b-ро ёфтан р ва b- ро бо ҳам зарб намуда,
 натиҷаро ба тақсим кардан лозим аст.» 
 #include <iostream> 
 #include <cmath> 
 using namespace std; 
 int main() { 
 int p, b; 
 float s; 
 cin >> p >> b; 
 s = p*(float)b /; 
 cout << p << " Foizi adadi " << b << " ba " << s << " barobar 
 ast.\n"; 
 return; 
 } 
 ) Адади f дар қолаби ҳақиқӣ дода шудааст. Барномае нависед, ки он-ро
 ба қолаби пулӣ гардонад. 
 #include <stdio.h> 
 #include <iostream> 
 using namespace std; 
 int main() { 
 int r, k; 
 float f; 
 printf("adadi hakiki - ro dohil kuned->"); 
 scanf("%f", &f); 
 r = (int)f; 
 k = f * - r *; 
 printf("%.f in %i somoni va %i diram meboshad\n", f, r, k); 
 cin.get(); 
 return; 
 } 
 ) Адади серақмае дода шудааст. Барномае нависед, ки суммаи рақамҳои
 адад ва ҳосили зарби рақамҳои ададро ҳисоб кунед. 
 #include <iostream> 
 using namespace std; 
 int main() { 
 int a, b, max, c; 
 cout << "Adadi seraqamai a - ro dohil kuned!\n"; 
 cin >> a; 
 b = (a / ) + (a % % ) + (a % / ); 
 c = (a / )*(a % % )*(a % / ); 
 cout << "Summai raqamho = " << b << ": Zarbi raqamho = " << c << 
 "\n"; 
 return; 
 } 
 ) Функсияи f(x)=sinx+cosx дода шудааст. Барномае нависед, ки бо дода
 шудани қиматҳои a ва b қимати ифодаи зеринро ҳисоб кунад. 
 Z=f(f(a+b)) 
 #include <iostream> 
 #include <cmath> 
 using namespace std; 
 int main() { 
 float a, b, Y, Z; 
 cout << "Qimarhoi a va b - ro dohil kuned!\n"; 
 cin >> a >> b; 
 Y = sin(a + b) + cos(a + b); 
 Z = sin(Y) + cos(Y); 
 cout << "Z = " << Z << "\n"; 
 return; 
 } 
 ) Солшумории ҳиҷрӣ аз соли аз рӯзи ҳиҷрати Пайғомбари Ислом 
 (Муҳаммад (с)) оғоз гардидааст. Барномае нависед, ки дилхоҳ соли ҳиҷриро ба
 мелодӣ гардонад. 
 Қайд. Метавонем барои баргардонидани ин солшуморӣ аз формулаҳои 
 зерин истифода барем. 
 #include <iostream> 
 using namespac e std; 
 int main() { 
 int H, M; 
 cout << "Soli hijriro dohil kuned!\n"; 
 cin >> H; 
 M = (int)(H - H / + ); 
 cout << "M = " << M << "\n" << "H = " << H << "\n"; 
 return; 
 } 
 ) Барномае нависед, ки андоза ё тӯли ҳамаи навъҳои додаҳоро ба 
 ҳисоби байт муайян кунад. 
 Қайд. Ин барномаро бо ёрии оператори ҳофиза sizeof() иҷро мекунем. 
 #include <iostream> 
 using namespace std; 
 int main() { 
 long double S, r, h; 
 cout << "Darozii tiphoi dodaho!\n\n"; 
 cout << "RT\tNamei tip andozai tip\n"; 
 cout << "\tchar\t\t" << sizeof(char) << " byte\n"; 
 cout << "\tshort\t\t" << sizeof(short) << " byte\n"; 
 cout << "\tint\t\t" << sizeof(int) << " byte\n"; 
 cout << "\tlong\t\t" << sizeof(long) << " byte\n"; 
 cout << "\tfloat\t\t" << sizeof(float) << " byte\n"; 
 cout << "\tdouble\t\t" << sizeof(double) << " byte\n"; 
 cout << "\tlong double\t" << sizeof(long double) << " byte\n"; 
 return; 
 } 
 ) Шахсе дар бонк бо фоизи солонаи P% S миқдор пул гузошт. 
 Барномае нависед, то муайян кунед, ки пули гузоштаи он дар муддати вақти t
 чӣ қадар зиёд мешавад ва чӣ қадар даромад меоварад? 
 #include <iostream> 
 using namespace std; 
 int main() { 
 float summ; //Пули гузошташуда 
 int muhl; //Муҳлати гузоштан 
 float P; //Фоизи зиёдшави 
 float dar; // Даромад аз пули гузошташуда 
 cout << "Miqdori puli guzoshtashuda\n"; 
 cin >> summ; 
 cout << "Muhlati puli guzoshtashuda\n"; 
 cin >> muhl; 
 cout << "Foizi ziyodshavii pul\n"; 
 cin >> P; 
 dar = summ*P / / * muhl; //Ҳисоб намудани даромад 
 summ = summ + dar; //Даромад бо пули гузошташуда якҷоя 
 cout << "daromad = " << dar << " somoni\n"; 
 cout << "Puli ziyodshuda = " << summ << " somoni\n"; 
 return; 
 } 
 Қайд. Ҳамаи барномаҳои дар дастур овардашударо метавон дар дигар 
 компиляторҳои С++ бо таҳрири кучаке навишт. Масалан, барномаи мисоли - 
 ро агар дар компилятори Microsoft Visual C++ нависем шакли зеринро мегирад.
 #include "stdafx.h" 
 #include <iostream> 
 using namespace std; 
 int _tmain(int argc, _TCHAR* argv[]){ 
 float a, b, P; 
 cout << "Adadhoi a va b-ro dohil kuned!\n"; 
 cin >> a >> b; 
 P = a*b; 
 cout << "Perimetri rostkunja ba " << P << " barobar ast.\n"; 
 cin.get(); 
 return; 
 } 
 Тавре ки дида мешавад, дар ин ҷо ибтидо китобхонаи мавҷуд буда, 
 функсияи асосӣ шакли int _tmain(int argc, _TCHAR* argv[])-ро дорад. Илова бар
 ин ба ҷойи функсияи getch() аз функия-аъзои cin.get() истифода карда шудааст.
 Дар саросари ин дастури таълимӣ ҳарчанд, ки барои фаъол гардонидани 
 барнома аз “.h” ва барои нигоҳ доштани равзанаи вуруд-хуруҷӣ аз getch() 
 истифода бурда шудааст, вале маслиҳат дода мешавад, ки равиши намунаи 
 мисоли дар қайд овардашуда истифода карда шавад. 
 Барои иҷро намудани барнома дар компилятори Microsoft Visual C++ 
 тугмачаи F пахш карда мешавад. 
 Масъалаҳо барои кори мустақилона 
 Масъалаҳои гурӯҳи Begin 
 арифметикӣ ва геометрии онҳоро ҳисоб кунад. 
 даҳии онро иваз кунад. 
 лаҳзаи вақтро h бо соат ва m бо дақиқа ифода мекунад. Вақти кӯтоҳтарине
 (бо дақиқа), ки то бо ҳам в о хӯр д а ни а қр аб а кҳ о мегузарад, муайян карда
 шавад. 
 онро ҳисоб кунад. 
 Қайд. Периметри рос ткунҷа бо ёрии формулаи ҳисоб 
 карда мешавад. 
 ҳолати тоқ будани онҳо қимати, дар дигар ҳолатҳо қимати аз як 
 фарқкунанда хориҷ кунад. 
 Қайд. Аз оператори шартӣ ва даврӣ истифода бурдан мумкин нест. 
 якум бар сеюм ва дуюм бар чорум пайдо мешавад, ёфта шавад. 
 арифметикӣ ва геометрии рақамҳои онро ҳисоб кунад. 
 давр зад. Муайян карда шавад, ки аз оғози шабонарӯз чанд дақиқаи пурра 
 гузаштааст. 
 рақамҳои онро ҳисоб кунад. 
 ро муайян кунад. 
 Қайд. Барои p фоизи адади b-ро ёфтан р ва b- ро бо ҳам зарб намуда, 
 натиҷаро ба тақсим кардан лозим аст. 
 қолаби пулӣ гардонад. 
 шудани қиматҳои a ва b қимати ифодаи Z=f(f(a+b)) - ро ҳисоб кунад. 
 нависед, ки дилхоҳ соли ҳиҷриро ба мелодӣ гардонад. 
 Қайд. Барои соли ҳиҷриро ба мелодӣ гардонидан, аз формулаи 
 ва соли мелодиро ба ҳиҷрӣ гардонидан, аз формулаи 
 истифода карда мешавад. 
 пули гузоштаи он дар муддати вақти t чӣ қадар зиёд мешавад ва чӣ қадар 
 даромад меоварад? 
 ва фарқи он ҳисоб кунед. 
 Масоҳат ва периметри онро ёбед. 
 Фаренгейт" навиштааст. Ин ҳароратро бо селсия га р д о н е д. 
 махраҷи он ҳисоб кунед. 
 -ро ҳаноми мавҷуд будани реша, б о д о д а шу д а н и к оэ ффитсиентҳо,,,,
 {, бо истифода аз формулаҳои, 
 y= ( · – · )/D (дар ин ҷо D = · – · аст) ҳисоб кунед. 
 Масъалаҳои гурӯҳи Integer – 
 ) А д ад и се ра қ а ма дода шудааст. А д ад е ёф та ш авад, ки ҳангоми ҷойивазкунии
 рақамҳои якуму дуюми он ҳосил мешавад ( натиҷа: ). 
 ) Адади чоррақама дода шудааст. Ҳосили зарб ва ҳосили чамъи квадрати 
 рақамҳои он ёфта шавад. 
 ) Адади чоррақама дода шудааст. Ададе, ки ҳангоми аз рост ба чап хондани ин
 адад пайдо мешавад ёфта шавад. ( натиҷа: ) 
 ) Адади чоррақама дода шудааст. Ададе, ки ҳангоми ҷойивазкунии рақами 
 якум бар дуюм ва сеюм бар чорум пайдо мешавад ёфта шавад. Масалан аз 
 адади адади пайдо мешавад. 
 ) Аз адади серақамаи x рақами якуми он партофта шуд. Адади боқимонда ба 
 зарб карда, пас аз он ба рақами сеюми партофташуда ҷамъ карда шуд. Дар 
 натиҷа адади ҳосил гардид. Адади x- ро ёбед. 
 ) Аз адади серақамаи x рақами дуюми он партофта шуд. Ҳангоми ба адади 
 ҳосилшудаи дурақама аз тарафи рост рақами дуюми х-ро ҳамроҳ намуданд 
 адади ҳосил шуд. Адади x- ро ёбед. 
 ) Аз адади серақамаи x рақами охирони он партофта шуд. Пас аз он амали 
 ҷойивазкунии рақамҳо дар адади дурақамаи ҳосилшуда иҷро гашт. Ба ин адад
 аз тарафи чап рақами охирони партофташудаи адади х ҳамроҳ карда шуд. Дар
 натиҷа адади n ҳосил гардид. Ҳангоми дохил намудани қимати n адади x 
 ёфта шавад ( ). 
 асри он муай ян к ар д а шавад. Ба назар гирифта шавад, ки оғози асри -ум
 соли аст. 
 бутун) давр зад. Муайян карда шавад, ки аз оғози шабонарӯз чанд дақиқаи
 пурра гузашт. 
 бурда, рақами садии онро хориҷ кунед. 
 бурда, рақами ҳазории онро хориҷ кунед. 
 даҳии онро хориҷ кунед. 
 кунед. 
 он нависед. 
 нависед. 
 чоршанбе, - панҷшанбе, - ҷумъа, - шанбе, - якшанбе. Адади бутуни К,
 ки дар фосилаи - мехобад дода шудааст. Рақами ҳафтаи рузи К-уми сол
 ёфта шавад, агар маълум бошад, ки дар ин сол -уми январ рӯзи … буд. 
 a) якшанбе 
 b) душанбе 
 c) сешанбе 
 d) чоршанбе 
 e) панҷшанбе 
 f) ҷумъа 
 g) шанбе 
 чоршанбе, - панҷшанбе, - ҷумъа, - шанбе, - якшанбе. Адади бутуни К,
 ки дар фосилаи - ва адади бутуни N, ки дар фосилаи - мехобад дода
 шудааст. Рақами ҳафтаи рузи К-уми сол ёфта шавад, агар маълум бошад, ки
 дар ин сол -уми январ рӯзи ҳафтаи N-ум буд. 
 Масъалаҳои гурӯҳи Boolean 
 чап ва аз чап ба рост якхел хонда мешавад. 
 яке аз ададҳои А ва В тоқ нестанд» санҷида шавад. 
 a.... мебошад» 
 a) «мусбат» 
 b) «манфӣ» 
 c) «тоқ» 
 d) «ҷуфт» 
 e) «дурақамаи ҷуфт » 
 f) « дурақамаи тоқ» 
 a) «Суммаи рақамҳои адади n адади ҷуфт мебошад» 
 b) «Қимати миёнаи арифметикии рақамҳои адади n адади тоқ мебошад» 
 c) «Адади n аз рост ва аз чап якхел хонда мешавад (Палиндром).» 
 d) «Рақамҳои адади n бо тартиби афзуншавӣ ҷойгир мебошанд» 
 e) «Рақамҳои адади n бо тартиби камшавӣ ҷойгир мебошанд» 
 санҷед. «Секунҷаи тарафҳояш ба a, b ва c баробар мавҷуд аст.» 
 бутуни аз то ) дода шудаанд. Бо назардошти он ки катакчаи поёнии тарафи
 рости тахтаи шоҳмот (,) сиёҳ аст, дурустии мулоҳизаи зеринро санҷед. 
 «Катакчаи (майдони) додашуда ранги сафед дорад». 
 ( ) (ададҳои бутуни аз то ) дода шудаанд. Бо назардошти он ки 
 катакчаи поёнии тарафи рости тахтаи шоҳмот (,) сиёҳ аст, ду ру стии 
 м ул о ҳизаи зеринро санҷед. «Майдонҳои додашуда ранги якхела доранд». 
 )-ро ба назар гирифта, дурустии мулоҳизаи «муодилаи квадратии 
 решаҳ о и ҳ ақ иқ ӣ дорад» санҷида шавад. 
 «Н о ба р об ариҳои ҷой доранд». 
 «Нобаробариҳои ҷой доранд». 
 санҷед: «Нобаробарии ҷой дорад». 
 мекунанд, дода шудаан д. Ду р у с ти и мулоҳизаи зеринро санҷед. 
 a) «Нуқта бо координатаҳои x ва y дар чоряки якуми ҳамвории декартӣ 
 мехобад.» 
 b) «Нуқта бо координатаҳои x ва y дар чоряки дуюми ҳамвории декартӣ 
 мехобад.» 
 c) «Нуқта бо координатаҳои x ва y дар чоряки сеюми ҳамвории декартӣ 
 мехобад.» 
 d) «Нуқта бо координатаҳои x ва y дар чоряки чоруми ҳамвории декартӣ 
 мехобад.» 
 e) «Нуқта бо координатаҳои x ва y дар чоряки якуми ё дуюми ҳамвории 
 декартӣ мехобад.» 
 f) «Нуқта бо координатаҳои x ва y дар чоряки якуми ё сеюми ҳамвории 
 декартӣ мехобад.» 
 g) «Нуқта бо координатаҳои x ва y дар чоряки дуюм ё чоруми ҳамвории 
 декартӣ мехобад.» 
 ( ) (ададҳои бутуни аз то ) дода шудаанд. Дурустии мулоҳизаи 
 зеринро санҷед: «... бо як ход метавонад аз катакчаи ба к ат а кчаи 
 гузарад.» 
 a) «шоҳ» 
 b ) « ф и л » 
 c) «асп» 
 d) «пиёдагард» 
 e) «фарзин» 
 f) «рух» 
 хобанда) муайян карда мешавад. Адади якум рақами амудиро (ҳангоми аз 
 поён ба боло шуморидан) ва адади дуюм рақами уфуқиро (ҳангоми аз чап ба
 рост шуморидан) ифода мекунад. Ададҳои натуралии a, b, c, d дода шудаанд.
 а) дар майдони (a, b) фил истодааст. Муайян карда шавад, ки фил ба 
 майдони (c, d) таҳдид карда метавонад ё не? 
 б) дар майдони (a, b) шоҳ истодааст. Муайян карда шавад, ки оё шоҳ бо як
 равиш (ҳаракат) ба майдони (c, d) гузашта метавонад ё не? 
 в) дар майдони (a, b) рух истодааст. Муайян карда шавад, ки оё рух бо як
 равиш (ҳаракат) ба майдони (c, d) гузашта метавонад ё не? 
 г) дар майдони (a, b) пиёдагард истодааст. Муайян карда шавад, ки оё
 пиёдагард бо як равиш (ҳаракат) ба майдони (c, d) гузашта метавонад ё
 не? 
 Боби. Сохтори операторҳои идоракунӣ 
 Муқаддима 
 Дар ҳар забони барномасозӣ операторҳои идоракунӣ мавқеи махсусро 
 ишғол мекунанд. Ин операторҳо ба компилятор (ва ё барномасоз) имконият 
 медиҳанд, ки як қитъаи барнома аз рӯи шарти гузошташуда як ё якчанд 
 маротиба иҷро намояд. Тавре ки дар мавзӯи операторҳо гуфта будем, 
 операторҳои мураккаб операторҳое буданд, ки бо ин операторҳо масъалаҳое ҳал
 мешаванд, ки бо операторҳои идоракунӣ дохил мешаванд. Шумо бо 
 операторҳои даврии for…next, while ва операторҳои шартии if..then ( инчунин
 if…then…else) дар забонҳои Basic, Паскал ва ё дигар забонҳо шояд шинос 
 бошед. Забони С++ нисбат ба забонҳои номбурда ин операторҳоро ба таври 
 васеътар истифода мебарад. Барои бо ин операторҳо сарукор гирифтан, бояд ду
 мафҳуми true ва false –ро дар ёд гирифт, зеро ҳар оператори идоракунӣ рӯи
 шарти гузошташуда амал мекунад ва то замоне ки шарт дуруст аст иҷро 
 мегардад. Тавре ки дар мавзӯъҳои гузашта қайд кардем, дар забони С++ ҳар 
 гуна адади ғайринулӣ ҳамчун қимати ҳақ фаҳмида шуда, қимати ноҳақ бошад, 
 адади нол аст. Операторҳои идоракунӣ дар забони С++ инҳо мебошанд: 
 ) Операторҳои шартӣ ё сохторҳои тасмимгирӣ ( decision making 
 constructs): switch, if 
 ) Операторҳои такрорӣ (loop iteration constructs): do/while, while,for
 ) Операторҳои goto, continue, break 
 ) Операторҳои return-барои баргардонидани қимат аз зербарнома ба 
 барномаи аслӣ. 
 Операторҳои шартӣ 
 Яке аз намудҳи алгоритмҳо алгоритми шартӣ мебошад, ки он дар забони 
 С++ истифодаи васеъ дорад. Алгоритми мазкур дар забони С++ бо ёрии ду 
 оператор switch ва if иҷро карда мешавад. Ба монанди ин навъи алгоритм, 
 операторҳои шартӣ операторҳое мебошанд, ҳангоми ҷой доштани шарт баъзе 
 қисматҳои барнома иҷро мешаванду баъзеашон не. 
 ) Оператори if-оператори шартӣ буда, бо ду тарз истифода бурда мешавад: if
 ва else if. Навъи якум дар ҳолате истифода бурда мешавад, ки барнома аз як
 шарт иборат бошад. Навъи дуюм бошад, барои ҳалли масъалаҳое, ки дорои 
 якчанд шарт мебошанд, истифода бурда мешаванд. Тарзи умумии 
 истифодабарии навъи якум яъне if ба сурати зерин аст: 
 if (condition) ё i f ( и ф о д а и мантиқӣ) 
 statement; оператор; 
 Дар ин оператор ҳангоми дуруст будани шарти гузошташуда, 
 операторҳои баъди шарт иҷро мегарданд. Агар пас аз оператори if (condition)
 символи нуқта вергул гузорем, дар ин сурат шарт шарти маҳдуд номида шуда,
 иҷро намегардад. Дар ҳолати акс, операторҳои баъди шарт иҷро мегарданд. 
 Агар ҳангоми иҷрои шарт якчанд операторҳо вобаста ба шартро иҷро карданӣ 
 шавем, он гоҳ операторҳои мазкур дар дохили қавси системавӣ навишта 
 мешаванд, яъне: 
 if (condition) ё i f ( и ф о д а и мантиқӣ) 
 { { 
 statement; оператор; 
 } } 
 Тавре ки мушоҳида кардем, агар пас аз шарт зарурати иҷроиши якчанд 
 ифода (дастур) пеш ояд, он гоҳ, дастурҳои мавриди назар дар дохили қавси 
 фигуравӣ навишта мешаванд. Ин оператор ҳам монанди оператори пешина 
 ҳангоми ҳақ будани шарти гузошташуда операторҳои дохили қавси системавӣ 
 иҷро мешаванд ва дар сурати нодуруст будани шарт операторҳои берун аз қавси
 системавӣ иҷро карда мешаванд. 
 Мисоли. Истифодаи оператори шартӣ. 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 int a, b, S =, Z =; 
 cout << "Adadhoi a va b - ro dohil kuned!\n"; 
 cin >> a >> b; 
 if (a > b) 
 { 
 Z = * a; 
 } 
 S = * b; 
 cout << "S = " << S << " Z = " << Z << "\n"; 
 return; 
 } 
 Қайд: Дар ин барнома аввал қиматҳои a ва b вориди барнома карда 
 мешаванд ва шарти a>b санҷида мешавад. Дар сурати нодуруст (false) будани
 ин шарт, ифодаи S=*b иҷро гардида, қимати S=*b ва Z= ба чоп дода 
 мешаванд. Дар сурати дуруст (true) будани шарти гузошташуда аввал ифодаи 
 Z=*a ва баъд ифодаи S=*b ҳисоб шуда, ба чоп дода мешаванд. 
 A d a d h oi a va b-ro dohil kuned! Adadhoi a va b-ro dohil kuned!
 S= Z= S= Z= 
 а) Дар ҳолати a>b будан б) Дар ҳолати a<b будан 
 Дар ин мисол тавре ки дидем, оператори шартӣ аз рӯи шарти гузошташуда
 амал мекардааст. Аз расми а) дида мешавад, ки ҳангоми а аз b калон будан ифодаи
 Z=*a сарфи назар шуда, танҳо қимати ифодаи S=*b ҳисоб карда шудааст. Агар
 барномаи мо аз якчанд шартҳои бо ҳам вобаста иборат бошад, дар ин сурат ин
 оператор ба кор намеояд. Масалан, бигзор ҳисоб намудани решаҳои муодилаи 
 квадратӣ талаб карда шавад. Аз нуқтаи назари математика чи тавре. Ки медонеи
 муодилаи квадратӣ дорои се шарт ё ҳолат мебошад. 
 ) Ҳолати D< будан «муодила ҳалҳои ҳақиқи надорад». 
 ) Ҳолати D> будан, муодила дорои ду решаи ҳақиқӣ аст, яъне х,х. 
 ) Ҳолати D= будан, решаҳои муодила баробаранд, яъне х =х. 
 Барои ҳалли ин гуна масъалаҳо ва масъалаҳое, ки дорои якчанд шарт 
 мебошанд, аз намуди дуюми оператори if, ки if_ else ном дорад, истифода 
 мебарем. Тарзи истифодабарии ин оператор чунин аст: 
 if (condition) ё i f ( и ф о д а и мантиқӣ) 
 { { 
 stements; Маҷмӯи операторҳои; 
 } } 
 else { else { 
 Statements М аҷмӯи операторҳои; 
 } } 
 Next statements М а ҷ м ӯ и операторҳои дигар 
 Дар ин ҷо ҳам condition-ифода (ифода)-и мантиқӣ буда, ҳангоми дуруст
 (true) будани он маҷмӯи операторҳои дохили қавси якум иҷро мешаванд ва 
 идоракунӣ ба сатри маҷмӯи операторҳои дигар (Next statements) мегузарад. 
 Ҳангоми нодуруст (false) будани он ифодаи дохили қавси системавии яъне 
 маҷмӯи операторҳои (Statements) иҷро мегарданд. 
 Мисоли. Ду адади бутун дода шудааст, хурдтарини онҳоро ёбед. 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 int a, b, min; 
 cout << "Adadhoi a va b - ro dohil kuned!\n"; 
 cin >> a >> b; 
 if (a < b) 
 min = a; 
 else 
 min = b; 
 cout << "min = " << min << "\n"; 
 return; 
 } 
 Иҷроиши ин мисол чунин аст: аввал шарти санҷида мешавад, агар 
 қимати а аз b хурд бошад, қимати он ба тағйирёбандаи min бахшида мешавад,
 вагарна (else) қимати b ба тағйирёбандаи min бах ш ид а мешавад. Иҷроиши ин
 барнома ба оператории шарти (тернари) эквивалент мебошад, яъне 
 min=(a<b)?a:b 
 Операторҳои шартии мураккаб(nested if-else) 
 Оператори if мутавонад ба намуди мураккаб ичро гардад. Ин сохтори 
 оператори шартӣ барои масъалаҳое, ки дорои шартҳои зиёд мебошанд истифода
 мешаванд. Тарзи истифодабарии ин оператор шакли зайлро дорад: 
 if (condition) { 
 Statements 
 } 
 Else if (condition) { 
 Statements 
 } 
 Else if (condition) { 
 Statements 
 } 
 -------------- - - -- -- 
 Else if (conditionN) { 
 Statements N 
 } 
 Else (condition N+){ 
 Statements N+ 
 } 
 Мисол. Решаҳои муодилаи квадратии ax +bx+c= – ро ёбед. 
 Қайд. Маълум аст, ки буда, 
 карда мешаванд. 
 формулаи зерин ҳисоб карда мешаванд. 
 Матни барнома: 
 #include <iostream> 
 #include <cmath> 
 using namespace std; 
 int main(){ 
 float a, b, c, D, X, X; 
 cout << "Adadhoi a,b va c - ro dohil kuned!\n"; 
 cin >> a >> b >> c; 
 D = pow(b, ) - * a*c; 
 if (D > ) 
 { 
 X = (-b - sqrt(D)) / * a; 
 X = (-b + sqrt(D)) / * a; 
 cout << "D = " << D << " X = " << X << " X = " << X << "\n"; 
 } 
 else if (D == ) 
 { 
 X = -b / * a; 
 X = X; 
 cout << "D = " << D << " X = " << X << " X = " << X << "\n"; 
 } 
 else if (D < ) 
 { 
 cout << "Muodila reshahoi hakiki nadorad!\n"; 
 } 
 return; 
 } 
 Тавре ки дар ин ҷо дидем, дар операторҳои шартӣ операторҳои мантиқӣ 
 (logical operators) ё булӣ (Boolean opretors) ва ё ифодаҳое, ки аз онҳо таркиб
 ёфтааанд ба сифати шарт (condition) истифода шудаанд. Операторҳои мантиқӣ
 ҳатман бо яке аз операторҳои шартии ==; >=; <=;!=; >; < истифода бурда
 мешаванд. Мисол: 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 int a; 
 cin >> a; 
 if (a > && a < ) 
 cout << "Adeadi " << a << " dar porchai[; ] mehobad." 
 << endl; 
 return; 
 } 
 Мисол. Қимати ифодаи шартии зерин ҳисоб карда шавад. 
 { 
 #include <iostream> 
 #include <cmath> 
 using namespace std; 
 int main(){ 
 double f, x, y; 
 cout << "Adadhoi x va y - ro dohil kuned!\n"; 
 cin >> x >> y; 
 if ((x >= && x <= ) || (y!= && x!= )) 
 f = (x + y) / ( * x*y); 
 else 
 f = * x*y; 
 cout << "f = " << f << "\n"; 
 return; 
 } 
 Оператори switch 
 Бигзор масъалае дорои якчанд шарт бошад ва талаб карда шавад, ки аз 
 маҷмӯи шартҳои гузошташуда як ва ё якчанд шарти интихобшудааш иҷро 
 карда шаванд. Барои иҷрои ин амал аз оператори switсh истифода бурда 
 мешавад. Агар дар оператори if-else ҳангоми дурустии шарт яке аз ду дастурҳо
 интихоб ва иҷро карда шаванд. Вале дар оператори switch бошад, аз маҷмӯи 
 дастурҳо (шартҳо) танҳо дастури интихобшуда, ки ба шарти гузошташуда 
 мувофиқ аст, иҷро карда мешавад. Наҳви умумии истифодаи ин оператор 
 шакли зеринро дорад: 
 switch (expression) 
 { 
 case: statement; break; 
 case: statement; break; 
 - - - - - - - - - - - - - - - - - - - - - - - - 
 default; statements; break; 
 } 
 Ин оператор чунин иҷро карда мешавад. Агар қимати дохили қавси баъди
 switch омада (шарти гузошташуда) ба кадоме аз ин қиматҳо мувофиқ ояд, он 
 гоҳ идоракунии ин барнома ба он сатр равона карда мешавад. Оператори 
 мазкур фақат қимати бутун қабул мекунад. Дар ин сохтор case маънои интихоб,
 break маънои танаффус ва default бошад, маънои вагарнаро дорад. 
 Қайд: Ҳамаи калимаҳои (case, break ва default) бояд пурра бо ҳарфи хурд
 навишта шаванд. 
 Мисол. Барномае нависед, ки ҳангоми дохил намудани рақам номи онро 
 барорад. 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 int adad, i =; 
 cout << "Adadro dohil kuned!\n"; 
 while (i++ < ) 
 { 
 cin >> adad; 
 switch (adad) { 
 case: cout << "one\n"; break; 
 case: cout << "two\n"; break; 
 case: cout << "thre\n"; break; 
 case: cout << "four\n"; break; 
 default: cout << "namedonam"; break; 
 } 
 } 
 return; 
 } 
 Дар ин барнома тавре ки дида мешавад, оператории даврии while(i++<)
 истифода шудааст. Оператори мазкур то ҳангоме ки қимати i ба баробар 
 шудан саҳифаи тасвирро дар ҳолати дохилкунӣ нигоҳ медорад. Дар ҳар як 
 дохилкунӣқимати i як воҳид афзоиш меёбад. Пас аз дохилкунӣ қимати adad 
 санҷида мешавад. Дар вақти санҷиш қимати он ба кадом сатре, ки мувофиқ ояд,
 он сатр иҷро мешавад. Яъне ҳангоми то ба чор баробар будани қимати adad дар
 саҳифаи тасвир мувофиқан one,two,thre, four ба чоп дода мешаванд. Дар ҳолате,
 ки қимати adad аз боло ва ё аз як хурд бошад, калимаи «namedonam» ба чоп
 дода мешавад. Яъне, калимаи default маънои вагарна (ва ё case else)-ро дорад. Ба
 ғайр аз ин як оператор дар баъзе ҳолатҳо метавонад барои якчанд қимат иҷро
 гардад. 
 Мисол. Барномае нависед, ки ҳангоми дохил кардани ҳарфҳо миқдори 
 ҳарфҳои садонок ва ҳамсадоро ҳисоб кунад. 
 #include <iostream> 
 #include <cmath> 
 using namespace std; 
 int main(){ 
 char chr; 
 int vowels =, consonants =, i =; 
 cout << "Harfi anglisi dohil kuned\n"; 
 while (i++ < ) 
 { 
 cin >> chr; 
 switch (chr) 
 { 
 case ’a’: 
 case ’e’: 
 case ’i’: 
 case ’o’: 
 case ’u’: 
 vowels++; 
 break; 
 default: 
 consonants++; 
 } 
 } 
 cout << "Sadonocho = " << vowels << "\t" << "Hamsado= " << consonants 
 << "\n"; 
 return; 
 } 
 Операторҳои swich ()-и дохилиҳам 
 Оператори swith() дар намуди дохилиҳам метавонад низ иҷро гардад. 
 Агар доимие, ки барои иҷроиши оператори swith() дар оператори swith()-и 
 берунӣ гузошта шудааст, ба доимии swith()-и дохилӣ якхела бошад низ барнома
 ба хатогӣ рӯбурӯ намешавад. Мисол.: 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 int m, n; 
 cout << "n = "; cin >> n; 
 cout << "m = "; cin >> m; 
 switch (n) { 
 case: cout << "Adadi az switchi beruni ast!" << endl; 
 switch (m) { 
 case: cout << "Adadi az switchi dohili ast!" << endl; 
 break; 
 case: cout << "Adadi az switchi dohili ast!" << endl; 
 break; 
 } 
 break; 
 case: cout << "Adadi az switchi beruni ast!" << endl; 
 break; 
 } 
 return; 
 Тавре ки дида мешавад, дар ин ҷо ду оператори swith() дар намуди 
 дохилиҳам омадаанд. Қимати шартҳои ҳар ду якхела мебо-шанд. Забони С++ 
 ба зудӣ метавонад байни онҳо фарқ гузорад. Натиҷаи барнома шакли зеринро 
 дорад: 
 Операторҳои такрорӣ 
 Дар табиат ҳама гуна ҳодисаҳо ба намуди даврӣ иҷро мешаванд. Масалан,
 гардиши шабонарӯз, ақрабаки соъат, Замин дар атрофии Офтоб ва ғайра. Дар 
 забонҳои барномасозӣ низ барои ҳалли масъалаҳои хусусияти даврӣ дошта, ба
 монанди ҳисоб намудани суммаҳо, факториали адад, якчанд маротиба иҷро 
 намудани ягон қисмати барнома ё дастур ва ғайра операторҳои даврӣ вуҷуд 
 доранд. Ин операторҳо имконияти якчанд маротиба иҷроиши як дастур ва ё як
 қитъаи барномаро фароҳам меоранд. Пайдарпайии дастурҳое, ки ҳангоми дар 
 дохили давр иҷро мешаванд, тани давр номида мешавад. Як маротиба иҷроиши 
 операторро як қадам ё итератсия меноманд. Шарте, ки дар аввал гузошта 
 шудааст ва ба охиррасии даврро муайян мекунад, параметри давр номида 
 мешавад. Муҳимтарин ва ё асоситарин операторҳои даврӣ дар забони С++ сето
 мебошанд, ки дутоашонро операторҳои даврӣ бо шарти пешоянду пасоянд ва 
 яктоашро оператори даврии параметрдор меноманд. 
 Оператори даврӣ бо шарти пешоянд 
 Дар оператори даврӣ бо шарти пешоянд шарти баохиррасии давр дар 
 аввал гузошта мешавад ва чанд маротиба такрор шудани ин оператор дар аввал
 муайян нест ва то шарти гузошташуда ҳақ будан иҷро карда мешавад. Аввал 
 шарти гузошташуда санҷида мешавад, баъд операторҳои дохили ҳалқа иҷро 
 мешаванад. Тарзи истифодабарии ин оператор шакли зайлро дорад: 
 Тарзи истифодаи Тарзи истифодаи оператор 
 оператор 
 while(condition) while(шарт) 
 { { 
 Statements маҷмӯи операторҳо 
 } } 
 Маҷмӯи операторҳои дохили ҳалқа то он замоне такроран иҷро 
 мешаванд, ки шарти гузошташуда ҳақ бошад. Намуди умумии иҷроиши 
 оператори мазкур ба намуди зерин иҷро мешавад: Қимати операторҳои 
 дохилии ҳалқа як маротиба иҷро гардида, шарти гузош-ташуда санҷида 
 мешавад агар он ҳақ бошад, маҷмӯи операторҳо аз нав иҷро карда мешаванд, то
 он замоне ки шарти гузошташуда ҳақ бо-шад. Шарти гузошташуда пеш аз ҳар 
 як итератсия санҷида мешавад. Чанд итератсия иҷро шудани давр дар ибтидо 
 маълум нест. 
 Мисол. Ҳамаи ададҳои натураалии аз як то -ро дар саҳифаи тасвир 
 бароред. 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 int i =; 
 while (i < ) 
 { 
 ++i; 
 cout << i << "\t"; 
 } 
 return; 
 } 
 Дар ин ҷо i++ ва cout<<i<<«\t» операторҳои дохили давр буда, ифодаи 
 i++ пас аз ҳар итератсия ба i як воҳид илова намуда, шарти гузошташударо 
 месанҷад, агар қимати i ба баробар шавад, дигар иҷроиши давр боздошта 
 шуда, идоракунӣ ба операторҳои баъдидаврӣ мегузарад. 
 Мисол. Ду адади бутун дода шудаанд КТУ-и ин ададҳоро ёбед. 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 int adad, adad, S, KTU; 
 cout << "Adadi yakum va duyum - ro vorid kuned!\n"; 
 cin >> adad >> adad; 
 while (S > ) 
 { 
 S = adad%adad; 
 adad = adad; 
 adad = S; 
 KTU = adad; 
 } 
 cout << "KTU = " << KTU << "\n"; 
 return; 
 } 
 Оператори даврии бо шарти пасоянд do/while 
 Оператори do/while ҳам монанди оператори while амал мекунад, вале дар
 ин оператор аввал операторҳои дохили ҳалқа иҷро гардида, баъд шарти 
 гузошташудак санҷида мешавад. Аз ин рӯ, оператори мазкурро оператори даврӣ
 бо шарти пасоянд меноманд. Тарзи истифодабарии ин оператор чунин аст: 
 do 
 { 
 Statements-Маҷмӯи операторҳои дохили давр 
 } 
 while (condition-шарт) 
 Мисол. Мисоли пешинаро бо ёрии оператории даврии бо шарти пасоянд 
 иҷро кунед. 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 int i =; 
 do 
 { 
 i++; 
 cout << i << "\t"; 
 } while (i < ); 
 return; 
 } 
 Мисол. Суммаи ҳамаи ададҳои ҷуфти порчаи […]-ро ҳисоб кунед. 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 int i =, Summa =; 
 do 
 { 
 i +=; 
 Summa += i; 
 } while (i < ); 
 cout << "Summai adadhoi jufti az to barobar ast ba: " << Summa 
 << "\n"; 
 return; 
 } 
 Қайд. Дар ин мисол як тағйирёбанда ба номи Summa муаррифӣ карда 
 шудааст ва ба он ба сифати қимати ибтидои бахшидем. Ифодаи i+=- 
 қимати i-ро дар ҳар як итератсия ду воҳид зиёд мекунад, то замоне ки қимати
 i ба баробар шавад. Ифодаи Summa+=i бошад, дар ҳар зиёдшавии i қимати 
 i-ро ба Summa мебахшад ва дар охир қимати Summa ба чоп дода мешавад. 
 Оператори даврии параметрдор 
 Оператори даврии параметрдор операторе мебошад, ки дар он оператор 
 қимати ибтидоӣ, интиҳоӣ ва қадами зиёдшавии давр нишон дода мешавад. 
 Тарзи истифодабарии ин оператор шакли зайлро дорад: 
 for(variable; shart; change-var) 
 { 
 statements 
 } 
 Дар ин ҷо variable ифодае мебошад, ки ба тағйирёбанда (пара-метр)-и давр
 қимати аввала мебахшад, change-var –ифодаест, ки қи-мати variable–ро тағйир
 медиҳад ва shart бошад, ифодаеаст, ки шарти баитмомрасии даврро муайян 
 мекунад. Ба таври дигар гӯем, variable-як ифодаи бахшиш буда, ба 
 тағйирёбандаи давр қимати аввала мебахшад, shart –ифодаи мантиқиест, ки 
 шарти баитмомрасии даврро муайян мекунад ва change-var бошад, як ифодаи 
 унарӣ (ягона) ва ё бахшиш буда, қимати тағйирёбандаи даврро тағйир медиҳад.
 Оператори мазкур монанди оператори while амал мекунад, яъне пас аз ҳар
 итератсия шарти гузошташуда санҷида мешавад ва то замоне ки он ҳақ аст, 
 давр такрор меёбад. 
 Мисоли. Суммаи ҳамаи ададҳои натуралии аз то -ро ҳисоб кунед. 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 int i, Summa =; 
 for (i =; i <; i++) 
 Summa += i; 
 cout << "Summai adadhoi naturalii az to barobar ast: " << Summa 
 << "\n"; 
 return; 
 } 
 Қайд. Дар ин барнома ду тағйирёбанда аз навъи бутун Summa ва i 
 муаррифӣ карда шудааст. Сипас, оператори for (i=;i<;i++), ки дорои се 
 параметр мебошад, иҷро карда мешавад. Параметри якум ба тағйирёбандаи i 
 қимати ибтидоии нолӣ мебахшад. Параметри дуввум ифодаи шартии i< 
 ҳалқаро маҷбур месозад, ки то қимати i баробари шудан, иҷро гардад. 
 Параметри сеюм бошад, ифодаи унари i++ қимати i-ро дар ҳар итератсия як 
 воҳид афзоиш медиҳад. Ин барномаро метавонем низ ба суратҳои зерин 
 нависем. 
 ) 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 int i =, Summa =; 
 for (; i <; i++) 
 Summa += i; 
 cout << "Summai adadhoi naturalii az to barobar ast: " << Summa 
 << "\n"; 
 return; 
 } 
 ) 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 int i =, Summa =; 
 for (; i <;) 
 Summa += i++; 
 cout << "Summai adadhoi naturalii az to barobar ast: " << Summa 
 << "\n"; 
 return; 
 } 
 ) 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 int Summa, i; 
 for (Summa =, i =; i <; i++) 
 Summa += i; 
 cout << "Summai adadhoi naturalii az to barobar ast: " << Summa 
 << "\n"; 
 return; 
 } 
 ) 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 int Summa =, i =; 
 for (;;) { 
 Summa += i; 
 i++; 
 if (i >= ) break; 
 } 
 cout << "Summai adadhoi naturalii az to barobar ast: " << Summa 
 << "\n"; 
 return; 
 } 
 Тавре ки дидем, як оператори for-ро ба чандин тарз истифода бурдан 
 мумкин аст. Аз ин ҷо чунин хулоса мебарояд, ки барои компилятор фаҳмо 
 будани параметр аст на тарзи навишти он. Дар мисоли сеюм бошад, оператори
 коммо истифода шудааст ва он нишон медиҳад, ки дар дохили қавси ин 
 оператор якчанд ифода навишта мешавад ва онҳо аз ҳамдигар бо оператори 
 мазкур ҷудо карда шудаанд. 
 Сохтори даврҳои мураккаб ё дохилиҳам 
 Дар дохили як ҳалқа ба сифати операторҳои дохилӣ, яъне statements 
 метавонем ҳалқаи дигарро нависем, вале дар ин навишт бояд диққат дод, ки 
 ҳалқаҳо ҳамдигарро маҳдуд накунанд. Дар ин на-муд операторҳо аввал 
 оператори берунӣ иҷро мешавад, баъд операторҳои дохилӣ. 
 Мисол. Даврҳои дохилиҳам. 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 int i, j; 
 for (i =; i <=; i++) 
 for (j =; j <=; j++) 
 cout << i << "\t"; 
 return; 
 } 
 Барномаи мазкур ҳар як қимати i- дар ҷои худ маротибагӣ чоп мекунад.
 Натиҷаи барнома намуди зеринро дорад: 
 Барномаи зерин бошад, ҳар маротиба қиматҳои j-ро маротиба ба чоп 
 медиҳад. 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 int i, j; 
 for (i =; i <=; i++) 
 for (j =; j <=; j++) 
 cout << j << "\t"; 
 return; 
 } 
 Натиҷаи ин барнома ба сурати зерин аст: 
 Мисол. Барномае нависед, ки ҷадвали зарбро дар саҳифаи тасвир ба чоп
 диҳад. 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 int i, j; 
 for (i =; i <=; i++) 
 { 
 for (j =; j <=; j++) 
 cout << i*j << "\t"; 
 cout << endl; 
 } 
 cout << endl; 
 return; 
 } 
 Ин барнома як қимати i-ро интихоб карда, ба ҳамаи қиматҳои j зарб 
 мекунад, то он замоне ки шартҳои гузошташуда дуруст (true- ҳақ) бошанд. 
 Натиҷаи ин барнома ба сурати зерин аст: 
 Мисол. Барномае нависед, ки ададҳои натуралии аз то -ро ба сурати
 зерин чоп кунад. 
 Матни барнома: 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 int i, j; 
 for (i =; i <=; i++){ 
 for (j =; j <=; j++) 
 cout << * (j - ) + i << " "; 
 cout << endl; 
 } 
 cout << endl; 
 return; 
 } 
 Мисол. Барномае нависед, ки ададҳои ба панҷ каратиро аз поён ба боло ва
 ададҳои каратии даҳро аз боло ба поён чоп кунад. 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 int i, j; 
 for (i =, j =; i < j; i +=, j -= ) 
 cout << i << " " << j << endl; 
 cout << endl; 
 return; 
 } 
 Оператори коммо (the comma operators) 
 Тавре ки қаблан гуфтем, оператори комо операторе мебошад, ки ба ҷои як
 ифода имконияти иҷрошавии якчанд ифодаро фароҳам меорад. Ин оператор 
 бештар бо оператори for истифода мегардад ва он имконият медиҳад, ки якчанд
 ифодаи дар дохили қавси баъди оператори for омада иҷро гарданд. 
 Мисол: Суммаи n адади аввалаи натуралиро ҳисоб кунед. 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 int Summa, i, n; 
 for (cout << "n = ", cin >> n, Summa =, i =; i <= n; Summa = 
 Summa + i, i = i + ); 
 cout << "Summa = " << Summa << "\n"; 
 return; 
 } 
 Тавре ки мушоҳида кардем, оператори коммо иҷозат дод, ки ба ҷои як 
 expression якчанд expression-иҷро гардид. Тарзи истифодабарии ин оператор
 чунин аст: 
 for (expressiona, expressionb; expression; expression) statements
 Дар ин ҷо expressiona, expressionb ифодаҳое ҳастанд, ки аз ҳамдигар бо
 ёрии оператори коммо ҷудо карда шудаанд. 
 Ин оператор аз чап ба рост амал мекунад, яъне иҷрои амалҳо аз чап ба
 рост аст. Ҳангоми муаррифӣ намудани тағйирёбандаҳо оператори коммо танҳо 
 онҳоро аз ҳамдигар ҷудо мекунад. Дар забони С++ оператори мазкур ҳамчун 
 оператори сатҳи поён шинохта мешавад. 
 Операторҳои continue ва break 
 Операторҳои continue ва break операторҳое мебошанд, ки ҷараёни 
 барномаро қатъ мекунанд. Оператори break операторе мебошад, ки идоракунӣ 
 (контролӣ) барномаро ба поёнии сохторе, ки break дар дохили он аст, интиқол
 медиҳад, яъне ин оператор сабаби баромадан аз барнома мегардад. 
 Тавре ки аз мисолҳои боло дидем, ин оператор идоракунии ба сатри 
 навбатӣ ва ё ба сатре, ки қимате он ба қимати додашуда мувофиқ меояд, 
 интиқол медиҳад. Аслан ин оператор бо операторҳои даврии while, do/while ва
 for истифода мешавад ва сабаби баромадан аз давр мешавад. Мисол: 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 int i =; 
 while (++i < ) 
 { 
 if (i == ) 
 break; 
 cout << i << "\t"; 
 } 
 cout << "\nHalka hangomi i = budan qat meshavad.\n"; 
 return; 
 } 
 Аз матни барнома айён аст, ки ҳангоми i< будан қимати i-ро ба чоп 
 медиҳад ва оператори break қиматҳои дигарро сарфи назар мекунад. Оператори
 мазкур сабаби баромадан аз дохили оператори даврӣ ва ё шартӣ мегардад. 
 Оператори continue (идома) бошад операторест, ки барои гузаштан аз як
 қисмати барнома ба қисмати дигари он истифода бурда мешавад, яъне ин 
 оператор аз такрори ҷории давр як ҳалқаро сарфи назар меку-над ва ё як 
 ҳалқаро нодида мегузарад. Ин оператор ҳам дар операторҳои даврии while, 
 do/while ва for истифода мешаванд. 
 Мисол. Истифодаи оператори continue бо оператори даврии while 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 int i =; 
 while (++i < ) { 
 if (i == ) 
 continue; 
 cout << i << "\t"; 
 } 
 cout << "\nHalka qimati i = -ro sarfi nazar mekunad.\n"; 
 return; 
 } 
 Чунончи мушоҳида гардид, оператори continue дар оператории даврии 
 while як итератсияро, яъне i=-ро сарфи назар мекунад, яъне онро нодида 
 мегузарад. 
 Оператори гузариши бешарт (goto) 
 Оператори goto барои гузаштан аз як қисмати барнома ба қисмати дигар
 ба кор бурда мешавад. Ҳангоми истифодаи оператори мазкур барои гузаштан 
 ба мавқеи лозимӣ бояд нишонае истифода бурда шавад. Нишона метавонад 
 ягон калимаи ёрирасон ва ё калимаи дигар бошад. Нишона ҳатман бо ҳарф ва ё
 рамзи хати поён сар мешавад. Тарзи истифодабарии ин оператор чунин аст: 
 goto label, ки дар ин ҷо label нишонаест, ки дар аввали ягон сатри барнома
 навишта шудааст. Бояд пас аз он ҳатман ду нуқта гузошта шавад. Мисол. 
 { 
 goto end; 
 } 
 e nd: cout<<”Barnamea ba ohir 
 rasid!\n”; 
 Бояд қайд кард, ки монанди забони Паскал дар забони С++ нишона 
 (Label)-е ки бояд идоракуни ба он гузашта шавад, муаррифӣ карда намешавад.
 Мисол. Барномае нависед, ки суммаи n адади аввалаи натуралиро ҳисоб 
 кунад. 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 int Summa =, i =, n; 
 cout << "n = "; 
 cin >> n; 
 label: 
 Summa += i; 
 i++; 
 if (i <= n) goto label; 
 cout << "Summa = " << Summa << "\n"; 
 return; 
 } 
 Қайд. Пас аз иҷрои ҳар як давр қимати i санҷида мешавад, агар шарт 
 дуруст бошад, идоракунӣ ба сатре, ки оператори goto ба он ишора кардааст 
 (дар ин мисол label), мегузарад. Ва бо ҳамин монанд ин амал то замоне ки 
 шарти гузошташуда дуруст аст, такрор мегардад. 
 Саволҳо барои мустаҳкамкунӣ 
 бурда мешавад? 
 мешаванд? 
 ҳам оператори do … while истифода бурда шавад? 
 шартӣ якҷоя истифода шаванд? 
 чанд ҳалқа метавонанд дохилиҳам бошанд? 
 шартии if истифода бурда шавад? 
 Намунаи ҳалли масъалаҳо 
 #include <iostream> 
 #include <cmath> 
 using namespace std; 
 int main(){ 
 double x, p; 
 char op; 
 cout << "\n >> "; 
 cin >> x; 
 p = x; 
 while () { 
 cout << "\n >> "; 
 cin >> op; 
 if (op == ’ = ’) { 
 cout << "--->" << p << endl; 
 exit(); 
 } 
 cout << " >> "; 
 cin >> x; 
 switch (op) { 
 case ’ + ’: p += x; break; 
 case ’ - ’: p -= x; break; 
 case ’*’: p *= x; break; 
 case ’ / ’: p /= x; 
 } 
 cout << p; 
 } 
 return; 
 } 
 тақсим шавад. Барномае нависед, ки миқдори ададҳои содаи фосилаи [; N]-ро
 ҳисоб кунад ва ададҳои содаро ба чоп диҳад. 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 int i, j, N; 
 bool d; 
 cout << "N = "; cin >> N; 
 for (i =; i <= N; i++) 
 { 
 d = false; 
 for (j =; j <= i /; j++) 
 if (i%j == )d = true; 
 if (!d) cout << i << "\t"; 
 } 
 return; 
 } 
 тақсимкунандаҳояш ғайр аз худаш баробар бошад. Масалан, адади мукаммал 
 аст, чунки =++. Барномае нависед, ки ҳангоми дохил намудани адад агар
 мукаммал бошад, сатри «мукаммал». Ва худи ададро ба чоп диҳад. 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 int i, N, S =; 
 cout << "N = "; cin >> N; 
 for (i =; i <= N /; i++) 
 if (N%i == ) S += i; 
 if (S == N) 
 cout << S << " Addadi mukammal meboshad: " << endl; 
 return; 
 } 
 ин пайдарпайи мебошад. Аз ин ададҳои додашуда калонтаринашро бароред. 
 Инчунин миқдори ададҳои калонтаринро барорад. 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 int N, Max, k; 
 for (cout << "N = ", cin >> N, k =; N!=; cout << "N = ", cin 
 >> N) 
 if (k == ) { 
 k =; Max = N; 
 } 
 else if (N > Max) { 
 Max = N; 
 k =; 
 } 
 else if (N == Max) k++; 
 if (k) 
 cout << "Max = " << Max << "\n" << "k = " << k << "\n"; 
 return; 
 } 
 ин пайдарпайи мебошад. Барномае нависед, ки қимати миёнаи арифметикии ин 
 ададҳоро ҳисоб кунад. 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 float N, k, S =, MArif; 
 for (cout << "N = ", cin >> N, k =; N!=; cout << "N = ", cin 
 >> N, k++) 
 S += N; 
 MArif = S / k; 
 cout << "k = " << k << "\t" << "MArif = " << MArif; 
 return; 
 } 
 барорад. Масалан: 
 Дохилкунӣ: 
 Хориҷкунӣ: 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 int ruz, moh, sol, k =; 
 cout << "Ruz moh sol\n"; 
 cin >> ruz; 
 cin >> moh; 
 cin >> sol; 
 if (moh == ) { 
 if ((sol % )!= && ruz == ) k =; 
 if ((sol % ) == && ruz == ) k =; 
 } 
 else if ((moh == || moh == || moh == || moh == ) && (ruz 
 == )) 
 k =; 
 else if (ruz == ) k =; 
 if (k == ) { 
 cout << "ogohi: Ohiri ruzi moh ast!\n"; 
 ruz =; 
 if (moh == ) { 
 moh =; 
 sol++; 
 cout << "Soli nav omad, shodu gazalhon.\n"; 
 } 
 else moh++; 
 } 
 else ruz++; 
 cout << ruz << " " << moh << " " << sol << "\n"; 
 return; 
 } 
 намуди дуӣ гардонад. 
 #include <iostream> 
 #include <cmath> 
 using namespace std; 
 int main(){ 
 int N, k, b =; unsigned long summa =; 
 cout << "N = "; cin >> N; 
 while (N) { 
 k = N %; 
 k = k*b; 
 summa += k; 
 b = b *; 
 N /=; 
 } 
 cout << "N / = " << summa << "\n"; 
 return; 
 } 
 ∑∑ 
 #include <iostream > 
 #include <cmath> 
 using namespace std; 
 int main(){ 
 int i, j, n, m; 
 float S =; 
 cout << "n = "; cin >> n; 
 cout << "m = "; cin >> m; 
 for (i =; i <= m; i++) 
 for (j =; j <= n; j++) 
 S += i + j; 
 cout << "S = " << S << "\n"; 
 return; 
 } 
 барорад. Масалан: 
 Дохилкунӣ: 
 Хориҷкунӣ: Сешанбе 
 Қайд. Барои ёфтани рақами рӯзҳои ҳафта бо дода шудани таърихи рӯз 
 аз формулаи 
 истифода бу(р д а м[еш а ва д, ки д]а р и н ҷо[ d]-р ӯз[и ]ҳа ф т а, m –р а)қ ам и м о ҳ, с, у
 рақами аср ва сол дар ин аср буда, []-ишораи қисми бутун мебошад. Инчунин
 рӯзҳои ҳафта чунин рақамгузорӣ мебошанд. 
 -Якшанбе, -душанбе,…, -шанбе 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 int ruz, moh, sol; 
 int c, y, m, d; 
 cin >> ruz >> moh >> sol; 
 if (moh == || moh == ) 
 sol--; 
 m = moh -; 
 if (m <= ) m +=; 
 c = sol /; 
 y = sol - c *; 
 d = (ruz + ( * m - ) / + y + y / + c / - * c + ) %; 
 switch (d) { 
 case:puts("Dushanbe"); break; 
 case:puts("Seshanbe"); break; 
 case:puts("Chorshanbe"); break; 
 case:puts("Panjshanbe"); break; 
 case:puts("Juma"); break; 
 case:puts("Shanbe"); break; 
 case:puts("Yakshanbe"); break; 
 } 
 return; 
 } 
 мешавад. Агар тақсим шавад, натиҷаи тақсимро бароред. Ва дар акси ҳол 
 пайғоми «намешавад» хориҷ карда шавад. 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 int N; 
 bool bl; 
 cout << "N = "; cin >> N; 
 bl = (N % ); 
 if (bl) 
 cout << "Adadi dodashuda ba taqsim nameshavad\n"; 
 else 
 cout << "N / = " << N /; 
 return; 
 } 
 #inclu de <√i os tr√e am > √ √ 
 #include <cmath> 
 using namespace std; 
 int main() 
 { 
 float S =; 
 int i =; 
 while (i >= ){ 
 S = sqrt(S + i); 
 i -=; 
 } 
 cout << "S = " << S << " \n "; 
 return; 
 } 
 Масъалаҳо барои кори мустақилона 
 Масъалаҳои гурӯҳи If 
 гоҳ бо ҳам зарб карда шаванд. Дар ҳолати акс ба онҳо қимати сифр бахшида
 шавад. 
 онҳо ёфта шавад. 
 хурдтарин ва калонтарин ҷойгир аст) хориҷ карда шавад. 
 қуллаҳои секунҷаро ифода мекунан ё не. 
 Кадоме аз ин суръатҳо тезтар мебошад? 
 Кадоме аз ин ду ҷисмҳо зиччии зиёд дорад? 
 ёфта шаванд. 
 а) доира дар дохили квадрат ҷой мегирад ё не? 
 б) квадрат дар дохили доира ҷой мегирад ё не? 
 тақсим шавад натиҷаи тақсим ва дар ҳолати акс иттилооти матнии «адади m
 ба адади n бебақия тақсим намешавад» бароварда шавад. 
 а) оё суммаи рақамҳои он адади дурақама мешавад ё не? 
 б) оё он аз суммаи рақамҳояш калон аст ё не? 
 а) оё рақами дуюми он сифр аст? 
 б) оё рақами якуми он тоқ аст? 
 баробартараф мебошад ё не. 
 оё роткунҷаи бо тарафҳои бударо дар дохили росткунҷаи бо тарафҳои c 
 ва d буда ҷойгир кардан мум к и н а с т ё не. 
 будани онро муайян кунед. 
 мавҷуд буда муайян карда шавад. 
 шабонарӯз иборат аст, агар он бе бақия ба тақсим шавад, ба истиснои
 солҳое, ки ба тақсим мешаванду ба не. Дар акси ҳол аз шаонарӯз
 иборат мебошад. 
 муайян карда шавад. 
 ақибмонӣ идома ёбад, баъд аз кадом муддати камтарини вақт соат боз аз нав
 вакти аниқро нишон хоҳад дод? 
 Масъалаҳои гурӯҳи Case 
 феврал,…., декабр) ва фасли сол (зимистон, баҳор, тобистон, тирамоҳ) хориҷ
 карда шавад. 
 -ҷамъ, -тарҳ, -зарб, - тақсим. Рақами иҷроиши амал ва ду адади бутуни
 мусбати ғайрисифрӣ дода мешавад. Амали интихобшуда бо ин ададҳо иҷро 
 гашта натиҷа ба чоп бароварда шавад. 
 -якшанбе. Адади бутуни -и фосилаи - ҷойгирбуда дода шудааст. Номи 
 рӯзи ҳафтаро барои рӯзи уми сол муайян кунед, агар маълум бошад, ки 
 якуми январи ин сол сешан бе аст. 
 ададҳои,,, рақамгузорӣ гаштааст. Дар ҳолати дохил намудани адади
 чоррақамаи ихтиёрӣ ва дохил намудани яке аз ададҳои муайянкардашуда, 
 қисми интихобшудаи адади чоррақама ба чоп бароварда шавад. 
 Адади натуралии n, ки рақами солро ифода менамояд, дода шудааст. Таърихи
 ҳамаи рӯзҳоеро, ки дар моҳҳои январ, феврал, …., декабри ин сол рӯзи 
 санитарӣ ба онҳо мувофиқ меояд, ба тартиб бароред. 
 шанбе, -якшанбе. Адади бутуни К-и фосилаи - ҷойгирбуда дода 
 шудааст. Номи рӯзи ҳафтаро барои рӯзи К-уми сол муайян кунед, агар 
 маълум бошад, ки якуми январи ин сол шанбе аст. 
 шанбе, -якшанбе. Адади бутуни К-и фосилаи - ҷойгирбуда дода 
 шудааст. Номи рӯзи ҳафтаро барои рӯзи К-уми сол муайян кунед, агар 
 маълум бошад, ки якуми январи ин сол чоршанбе аст. 
 шанбе, -якшанбе. Ададҳои бутуни ва m дода шудааст. 
 Номи рӯзи ҳафтаро барои рӯзи К-уми сол муайян кунед, агар маълум бошад,
 ки якуми январи ин сол рузи m аст. 
 хобанда ) дода шудааст. Сиёҳ будани майдони поёнии чапи тахта (х)-ро ба
 назар гирифта, муайян кунед, ки оё майдони сафед аст? 
 дар фосилаи - хобанда ) дода шудааст. Си ё ҳ б удани катакчаи чапи поёнии
 тахта (х)-ро ба назар гирифта, муайян кунед, ки оё ра н ги майдонҳои (х, у)
 ва якхела аст? 
 мек у н а нд, дода шудааст. Қиматҳои D ва М-ро барои санаи ба санаи 
 додашуда гузаштаро муайян кунед. 
 мекунанд, дода шудааст. Қиматҳои D ва М-ро барои санаи ба санаи 
 додашуда баъдинаро муайян кунед. 
 гаштаанд: - катет a, – гипотенуза, – баландӣ h, ки ба гипотенуза 
 фароварда шудааст(h=c/), – масоҳат S=c·h/. Рақами яке аз ин элементҳо
 бо қиматаш дода шудааст. Қимати ди г ар э√ле ментҳои секунҷа ёфта шавад.
 D=R, -дарозӣ,, -масоҳати давра,. Рақами яке аз ин 
 элементҳо ва қимати он дода шудааст, қимати элементҳои боқимондаро 
 ҳисоб кунед. 
 … дода шудаанд. Номи адади k –ум муайян карда шавад. 
 …..… дода шудаанд. Номи адади k –ум муайян 
 карда шавад. 
 лаҳзаи ҳар як соат тӯли дақиқа ранги сабз равшанӣ медиҳад, пас аз он тӯли
 як сония ранги зард ва баъд тӯли ду сония ранги сурх, тӯли се сония боз ранги
 сабз ва ғ. (ва боз такрор меёбад). Қимати ҳақиқии t, ки вақтро бо дақиқа аз
 оғози вақти гузашта ифода мекунад дода шудааст. Муайян карда шавад, ки 
 дар ин лаҳзаи вақт кадом ранг равшанӣ медиҳад. 
 «Ҷ» — ҷануб, «Ғ» — ғарб, «С» — шарқ) фармони рақамӣ қабул кунад: — 
 давом додани ҳаракат, — гардиш ба чап, – — гардиш ба рост. Рамзи s —
 мавқеи ҷории робот ва адади бутуни N — фармони ба он равонкардашуда 
 дода шудааст. Самти роботро пас аз қабул кардани ин фармон муайян кунед.
 Масъалаҳои гурӯҳи For 
 ) Ададиҳои бутуни n ва k дода шудаанд. n маротиба адади k-ро хориҷ кунед.
 ) Суммаи ҳамаи ададҳои мукаммали порчаи [..]-ро ҳисоб кунед. 
 ) Суммаи қисмҳои даҳии ҳамаи ададҳои серақамаро ҳисоб кунед. 
 ) Ададҳои содаи порчаи аз то ёфта шаванд. 
 ) Суммаи ҳисоб карда шавад. 
 ) Суммаи ҳисоб карда шавад. 
 ) Суммаи ҳисоб карда шавад. 
 ) Суммаи ҳисоб карда шавад. Оператори шартӣ 
 истифода бурд а н ашавад. 
 ) Барномае нависед, ки бо дода шудани қимати )- ро, ки ба намуди 
 қатор дода шудааст ҳисоб кунад. 
 ) Адади бу т у н и N ( N >) д ода шудаа ст. С у∑ммаи зеринро ҳисоб кунед.
 ) Маблағи дар бонк гузошташуда сомонӣ аст. Ҳар моҳ ҳаҷми он Р фои з
 зиёд м е ша ва д (Р-адади ҳақиқӣ Бо фоизи додашудаи Р муайян 
 кунед, ки пас аз чанд моҳ маблағи гузошташуда аз с. зиёд мешавад. 
 Миқдори ёфташудаи моҳҳо K ( а д ади б ут у н ) ва ҳаҷми умумии маблағи дар
 бонк гузошташуда пас аз зиёдшавӣ S (S-адади ҳақиқӣ)-ро хориҷ кунед. 
 ) Барномае нависед, ки маълумотҳои зеринро дар чунин шакл хориҷ кунад: 
 а) б) 
 ) Барномае нависед, ки дар намуди ҷадвали зерин ададҳоро хориҷ кунад: 
 ) Барномае нависед, ки дар намуди ҷадвали зерин ададҳоро хориҷ кунад: 
 ) Барномае нависед, ки ҷадвали зерин хориҷ кунад: 
 ) Барномае нависед, ки ҷадвали зерин хориҷ кунад: 
 ) Адади натуралии n ( дода шудааст. Талаб карда мешавад, ки 
 барномаи ҳисобкунии қимати ифодаи барнома 
 тартиб дода шавад. ⏟ 
 ) Адади натуралии n ( дода шудааст. Талаб карда мешавад, ки 
 барномаи ҳисобкунии қимати ифодаи +++…n… барнома 
 тартиб дода шавад. 
 ) Адади натуралии дода шудааст. N –то ададҳои аввале, ки аз 
 тақсимкунандаҳои сода танҳо,, -ро доранд (пайдарпайии Ҳемминг), бо
 тартиби афзуншави а ш он б а чо п бароред. Масалан адади аввалае, ки ин
 шартро қаноат мекунонанд, инҳоянд:,,,,,,,,, 
 ) Барномае нависед, ки қимати суммаи зеринро ҳисоб кунад. 
 ) Адади натуралии х д∏ода∑ шу∏даа с т. М иқд о ри тарзҳои дар суммаи чор адади
 натуралӣ тасвир кардани он: -ро ёбед, ки дар ин ҷо 
 мебошанд 
 ) Адади натуралии n ( д о да шу д аа ст. Талаб карда меша ва д, к и
 ба рн омаи ҳисобкунии қимати ифодаи +++n…n барнома тартиб дода 
 шавад. 
 ) Ададҳои аз то n ро бо миқдори имконпазири максималии 
 ҷуфтҳо тавре ҷудо кардан лозим аст, ки суммаи ададҳо дар ҷуфтҳо адади сода
 бошад. Миқдори ҷуфтҳоро чоп кунед. Масалан, ҳангоми n= як ҷуфт (,) ва
 ҳангоми n= сетои ин гуна ҷуфт-(,), (, ) ва (, ) мешаванд. 
 ) Пайдарпайии ададҳои бутун,,,… дода шудааст. Чор аъзои навбатии
 ин пайдарпайиро муайян кунед. 
 Масъалаҳои гурӯҳи While 
 ) Адади натуралӣ дода шудааст. Муайян карда шавад, ки оё пайдарпаии 
 рақамҳои он аз тарафи рост ба чап ба таври афзуншавӣ ҷойгир шудаанд ё не.
 Масалан, барои адади ҷавоб дуруст аст, барои адади бошад ҷавоб
 нодуруст аст. 
 ) Адади ҳақиқии а дода шудааст. Қимати n, ки барояш 
 а аст, ёфта шавад. 
 ) Адади бутуни мусбат дода шудааст, муайян кунед, ки он ба каратӣ 
 мебошад?. 
 ) Ду адади бутуни мусбати А ва В дода шудааст. Амалҳои тақсимро 
 истифода набурда муайян кунед, ки натиҷаи тақсими В бар А чанд мешавад?
 ) Шаҳрванд дар бонк барои худ с у ра тҳ ис о б кушода дар он сомонӣ
 гузошт. Ҳар моҳ маблағи гузошташуда % аз ҳисоби маблағи мавҷудбуда 
 зиёд мешавад. Муайян карда шавад, ки суммаи маблағи гузошташуда пас аз,, …, моҳ чанд сомониро ташкил медиҳад. 
 ) Суммаи ҳамаи ададҳои дурақамаро ёбед, ки решаи квадратии онҳо адади тоқ
 мебошад. 
 ) Қори Исмат як миқдор тангаҳои тиллоиро дар сандуқ ҷойгир намуда, соли 
 дуюм аз он ҷо якчанд тангаро гирифт. Аз соли сеюм сар карда, вай ба сандуқ
 ба миқдори тангаҳои ду соли пешина танга ҳамроҳ мекард. 
 Талаб карда мешавад, ки барномаи муайянкунии миқдори тангаҳоеро, ки 
 дар соли дуюм аз сандуқ гирифтан лозим аст, сохта шавад, агар дар соли якум
 ба сандуқ У-то танга ҷойгир намуда, дар соли Х-ум дар сандуқ Z-то танга
 мавҷуд бошад. 
 ) Маблағи дар бонк гузошташуда сомонӣ аст. Ҳар моҳ ҳаҷми он Р фоиз 
 зиёд мешавад (Р-адади ҳақиқӣ Бо фоизи додашудаи Р муайян 
 кунед, ки пас аз чанд моҳ маблағи гузошташуда аз зиёд мешавад. 
 Миқдори ёфташудаи моҳҳо K ( а д ади б ут у н ) ва ҳаҷми умумии маблағи дар
 бонк гузошташуда пас аз зиёдшавӣ S (S-адади ҳақиқӣ)-ро хориҷ кунед. 
 ) Адади бутуни а дода шудааст. Муайян карда шавад, ки он адади дараҷаи 
 аст. 
 ) Адади бутуни а дода шудааст. Муайян карда шавад, ки он адади дараҷаи 
 аст. 
 ) Адади бутуни а дода шудааст. Муайян карда шавад, ки дар навишти он 
 адади вомехурад ё не? 
 ) Адади бутуни N (> ) дода шудааст. Чунин адади хурдтарини K-ро ёбед ки
 квадратии он аз N зиёд шавад:. Функсияи аз решабарорӣ истифода 
 бурда нашавад. 
 ) Адади бутуни N (> ) дода шудааст. Чунин адади калонтарини K-ро ёбед ки
 квадрати он аз N зиёд нашавад:. Функсияи аз решабарорӣ истифода 
 бурда нашавад. 
 ) Адади бутун дода шудааст. Ададеро хориҷ кунед, ки аз рақамҳои он вале бо
 тартиби баръакс ҷойгир бошанд. 
 ) Адади бутуни N (> ) дода шудааст. Чунин адади хурдтарини K-ро ёбед ки
 барои он нобаробарии иҷро шавад. 
 ) Адади бутуни N (> ) д ода шудааст. Чунин адади калонтарини K-ро ёбед ки
 барои он нобаробарии < N иҷро шавад. 
 ) Адади ҳақиқии ( > ) дода шудааст. Пайдарпайии ададҳои ҳақиқии A 
 K 
 чунин муайян кра мешаванд: 
 A =, A = + /A, K =,, …. 
 K K– 
 Рақами тартибии нахустини K ёфта шавад, ки барои он шарти зерин иҷро
 мегардад 
 |A – A | <, 
 K K– 
 аъзоҳои A ва A хориҷ карда шаванд. 
 K– K 
 ) Адади ҳақиқии ( >) дода шудааст. Пай дарпайии ададҳои ҳақиқии A 
 K 
 чунин муайян карда мешаванд: 
 A =, A =, A = (A + ·A )/, K =,, …. 
 K K– K– 
 Рақами тартибии нахустини K ёфта шавад, ки барои он шарти зерин иҷро 
 мегардад 
 |A – A | <, 
 K K– 
 аъзоҳои A ва A хориҷ карда шаванд. 
 K– K 
 ) Факториали адад дода шудааст. Худи адад му айян карда шавад. 
 ) Хурдтарин каратноки умумии ду адади натуралии додашуда ёфта шавад. 
 ) Адади натуралӣ дода шудааст. Миқдори рақамҳои он ва суммаи рақамҳои 
 он ҳисоб карда шавад. 
 Боби. Функсияҳо(functions) 
 Муқаддима 
 Дар мавзӯъҳои қаблӣ мо ба функсияҳои математикӣ ва ё стандартии 
 забони С++ шинос шудем ва аз онҳо ҳам истифода кардем. Тавре ки дидем, ин
 функсияҳо дар китобхонаи cmath (math.h) ҷойгир буда, ҳангоми даъват дар 
 дихоҳ ҷойи барнома ҳозир шуда, амали хоссеро анҷом медиҳанд. Аксари 
 забонҳои барномасозӣ имконият медиҳанд, ки барномаҳои ҳаҷман калонро ба 
 якчанд қисматҳои ба ҳам вобаста ҷудо намуда, ҳал кунем ва дар охир онҳоро
 якҷоя намуда, ҳалли матлубро ба даст оварем. Таҷрибаҳо нишон доданд, ки 
 агар барномаи калонро ба қисматҳои хурд ба номи «unit» ва ё «modul» ҷудо 
 кунем, идора намудани онҳо хеле сода мешавад. Дар охир ин қисматҳоро гирд
 оварда, дар дохили барномаи асосӣ истифода мебарем. Масалан, талаб карда 
 шавад, ки қимати ифодаҳои зерин ҳисоб карда шавад. 
 ) 
 ∑ 
 ) S =! +!+!∑+! - 
 { Ба намуди умумӣ ба рои ҳал намудани ин ифодаҳо, ба барноманавис 
 лозим аст, ки барои якчан д қисматҳоро такроран код нависад. Масалан, барои
 ҳал намудани мисоли ду бояд барои ҳар як қимат алоҳида факториалро ҳисоб 
 намуда, сипас онҳоро якҷоя намуда ҳалли матлубро ба даст орад. (Ин мисолҳо
 танҳо барои намуна оварда шудаанд, ҳол онки метавон мисолҳои дигар низ 
 овард ва ҳар як мисолро бо роҳ ва усулҳои гуногун ҳал кард). 
 Барои ба таври содатар ҳал намудани ин ифодаҳо оҳоро ба қисматҳо ҷудо
 намуда, барои ҳар қисмати барномаи алоҳида менависем ва дар охир онҳоро 
 ҷамъ намуд, ҳалли лозимиро меёбем. Барои фаҳмо шудан мисоли дуввумро бо 
 ду роҳ ҳал мекунем, то хонандаи азизи мо ба ин матлаб беҳтар сарфаҳм равад.
 #include <iostream> 
 #include <cmath> 
 using namespace std; 
 int main(){ 
 long int S =, S =, S =, S =, S =, S =, S =; 
 float S; 
 for (int i =; i <=; i++) 
 S = S*i; 
 for (int i =; i <=; i++) 
 S = S*i; 
 for (int i =; i <=; i++) 
 S = S*i; 
 for (int i =; i <=; i++) 
 S = S*i; 
 for (int i =; i <=; i++) 
 S = S*i; 
 for (int i =; i <=; i++) 
 S = S*i; 
 for (int i =; i <= ( - ); i++) 
 S = S*i; 
 S = S + S - S + S - (S) / (S*S); 
 cout << S << "\n"; 
 return; 
 } 
 Тавре ки дида мешавад, дар ин ҷо аз тағйирёбанда (ба ғайр аз i) ва 
 давр (сикл) истифода шудааст. Чи таре ки медонем, истифодаи тағйирёбандаи
 зиёд аз як тараф хотираи зиёдро банд намуда, қобиляти иҷроиши барномаро 
 суст мегардонанд. Аз тарафи дигар бошад, чанд маротиба такроран навиштани
 як қитъаи барнома хело дилгиркунанда буда, матни барномаро зиёд мекунад ва
 ба вуҷудоии хатогиҳоро сабаб мешавад. Агар монанди функсияҳои стандартӣ 
 дар китобхонаи С++ як функсия барои ҳисоб намудани факториал вуҷуд 
 медошт матни барнома ин қадар калон намешуд. Чунин функсияҳоро дар 
 забони С++ худи барномасоз метавонад низ эҷод кунад. Ҳоло мисоли болоро 
 бо истифода аз функсияи навиштаи барномасоз ҳал мекунем. 
 #include <iostream> 
 using namespace std; 
 long int fact(int n){ 
 long int P =; 
 for (int i =; i <= n; i++) 
 P = P*i; 
 return P; 
 } 
 int main(){ 
 float S; 
 S = fact() + fact() - fact() + fact() – 
 fact() / (fact()*fact( - )); 
 cout << S << "\n"; 
 return; 
 } 
 Тавре ки дида мешавад, дар ин барнома ягон қисмат такрор нашуда, 
 тағйирёбандаҳои иловагӣ низ вуҷуд надоранд. Амалкарди барномаро баъдтар 
 ширҳ медиҳем. 
 Ҳангоми ба қисматҳо ҷудо намудани барнома, ҳар қисматро зербарнома 
 (sub program) мегӯянд. Зербарнома дар ҳар забонҳои барноманависӣ ба таври
 гуногун буда, номҳои махсусро дорад. Маса-лан, дар забонҳои Паскал 
 зербарномаро модул ё проседуре ва дар забонҳои Бейсик function мегӯянд. Дар
 забони С++ бошад, ин қисматҳоро функсия (тобеъ) мегӯянд. Пас, барои ҳалли
 масъалаи калон онро ба қисматҳо ҷудо намуда, барои ҳар қисмат барномаи 
 алоҳида менависем ва дар охир ҳамаи қисматҳоро дар як функсияи асосӣ якҷо
 ҷамъ мекунем. Ин равишро барномасозии модулӣ (modular programming) 
 мегӯянд. 
 Дар забони С++ чунон ки қаблан ишорат кардем, як функсияи аслӣ ба 
 номи main () вуҷуд дорад, ки барнома кори худро аз он оғоз мекунад. Инчунин,
 тамоми функсияҳои фаръӣ дар он гирд оварда мешаванд. Дар забони С++ ду 
 намуди функсияҳо мавҷуданд: якум, функсияҳои стандартӣ ва ё китобхонаӣ 
 (library functions), ки онҳо функсияҳои тайёр (build in functions) низ мегӯянд, ки
 бо пайваст кардани китобхонаи лозимӣ ба кор омода мегарданд, ба монанди 
 функсияҳои математикӣ, дохилкунию хориҷкунӣ ва ғайра. Дуюм, функсияҳое, 
 ки худи барномасоз барои осон намудани идоракунии барнома менависад ва 
 дар ҷои лозимии барнома аз онҳо истифода мекунад. Ин намуд функсияҳоро 
 функсияҳои фаръӣ меноманд. Ба намуди диаграмма силсилаи функсияҳо 
 намуди зеринро доранд. 
 Шояд баъзе хонандагони мо суол кунанд, ки ба таври мушаххас функсия 
 барои чӣ лозим аст ва он барномасоз чӣ имкониятро медиҳад? 
 Барои ба ин савол ҷавоб гирифтан матлаби зеринро дида мебароем, ки 
 иборат аст аз чунин имкониятҳои функсия: 
 бузург ба якчанд қисматҳо тақсим карда шуд. Ҳар як қисмат алоҳида буда, 
 амали хоссеро иҷро мекунанд, аз ин рӯ, метавонем ҳар яки онҳоро ба таври 
 алоҳида навишт ва ҳар кадоми онҳоро санҷиш намуд. Агар онҳо бехато бошанд,
 пас, дар функсияи асосӣ онҳоро ба кор мебарем. Ин амал ислоҳи хатогиҳо ва
 тағйири барномаро хеле осон мегардонад. 
 ки ба як қисмати барнома тағйироте дохил карда шавад, зарур нест, ки тамоми
 барнома аз назар гузаронида таҳлил кард, балки тағйироти зарурӣ вобаста ба
 функсияе, ки ба он тағйирот алоқаманд аст дохил карда мешавад. 
 қисмати барнома дар якчанд ҷойҳо пеш меояд. Агар он қисматро ба намуди як
 функсия нависем, дигар зарурате намешавад, ки он қисматро пурра дар ҷойи 
 лозимӣ аз сари нав навишта шавад, танҳо даъват намудани он кифоя аст. Ин 
 амал коди барномаро хело сода ва кӯтоҳ мегардонад. 
 Барои ба моҳияти функсия сарфаҳм рафтан мисолеро дида мебароем: 
 ҳамаи мо медонем, ки ҳар давлат дар худ шоҳ ҳукмрон дорад. Ҳуди шоҳ 
 наметавонед тамоми корҳои давлатиро иҷро намояд ва ҳамаи қисматҳои 
 давлатро идора кунад, аз ин ҷо зарурат ба шахсоне пайдо мешаванд, ки бо 
 корҳои давлатӣ ва идоракунӣ ба ӯ кӯмак кунанд. Аз ин рӯ, давлатро ба 
 вилоятҳо, шаҳрҳо, ноҳияҳо, ҷамоаҳо ва деҳаҳо тақсим мекунанд ва барои ҳар
 кадомаш як роҳбаре таъйин мекунад. Роҳбарони мазкур бар замми он ки дар 
 ягон ҷо роҳбаранд, ба роҳбари олӣ, яъне шоҳ итоат мекунанд. Бо ин равиш 
 идоракунии як давлати бузург хеле сода мегардад. Функсияҳо дар забони С++
 низ ба ин сурат амал мекунанд. Тавре ки қаблан гуфтем, функсияи асосӣ (main)
 ҳамчун шоҳ хизмат намуда, функсияҳои боқимонда ба он пайравӣ мекунанд ва 
 ҳамчуноне, ки як вилоят ба ноҳияҳо тақсим мешавад ва ё дар дохилаш якчанд
 вилоятҳоро дар бар мегирад. Як функсия ҳам метавонад дар дохилаш функсияи
 дигареро нигоҳ дорад, яъне барои функсияи дигар функсияи аслӣ бошад. 
 Мисоли овардаамонро метавонем тавассути нақшаи зерин тасвир кунем. 
 Тарзи муаррифӣ (declaration) намудани функсияҳо 
 Тарзи муаррифӣ намудани як функсияро дар мавзӯи гузашта баён карда 
 будем. Ҳоло бошад, дар ин мавзӯъ онро ба таври пурратар дида мебароем. Ба
 намуди умумӣ тарзи муаррификунии як функсия шакли зеринро дорад: 
 data_type func_name(data_type argv, data_typе argv,…) 
 { 
 title function; 
 return value 
 } 
 Ё ба таври дигар: 
 <навъи функсия> <номи функсия > <аргументҳои функсия> 
 Муаррифӣ намудани тағйирёбандаҳо 
 { 
 Муаррифӣ намудани тағйирёбандаҳои маҳаллӣ 
 Тани функсия (яъне маҷмӯи операторҳо) 
 Қимат баргардонидани функсия 
 } 
 Дар ин ҷо func_name-номи функсия (яъне ҳар функсияе, ки мо менависем,
 дорои ном аст, ки он ном дар функсияи аслӣ даъват карда мешавад.), data_type-
 навъи функсия (функсия бояд муайян бошад, ки чӣ гуна қимат бармегардонад,
 яъне қимати баргарданда аз кадом навъи стандартӣ аст), ва argv, argv,…-
 аргументҳои функсия мебошанд (дар сурати вуҷуд доштани аргумент.), title
 func-тан ва ё амали иҷро мекардаи функсия, қавсҳои фигуравӣ ({}) маънои 
 ибтидо ва интиҳо (bagin ва end)-и функсия (ҳар функсия ва барнома дар дилхоҳ
 забони барномасозӣ бо калима ва ё мафҳуме оғоз гардида бо мафҳуме ба охир
 мерасад) ва return value бошад, қимате, ки функсия бармегардонад мебошад.
 Тавре ки мушоҳида кардем, як функсия дорои ном ва навъ буда, дар 
 дохили қавс аргументҳо ва навъи онҳо навишта мешаванд, албатта, дар сурати
 вуҷуд доштани аргументҳо. Яъне бояд функсия пурра муайян бошад, ки чӣ гуна
 аргумент қабул мекунад ва чӣ гуна қимат бармегардонад. 
 Дар функсия ба ғайр аз аргументҳо, Тавре ки пештар гуфтем, 
 тағйирёбандаҳои дохили қавси баъди номи функсия омада, инчунин 
 тағйирёбандаҳои маҳаллӣ (local variables declaration) метавонанд муаррифӣ ва
 истифода шаванд. 
 Тағйирёбанда агар ҷузъи аргументҳои функсия набошад, яъне худ 
 функсия бошад, маҳаллӣ номида мешавад. Тағйирёбандаҳои маҳаллӣ пас аз 
 унвони функсия навишта мешаванд. 
 Унвони функсия - ин номи функсия, навъи функсия, аргументҳои функсия
 ва навъи аргументҳои функсия мебошад. 
 Оператори return 
 Барои баромадан аз функсия дар вақти ба интиҳои функсия расидан 
 оператори return истифода бурда мешавад. Агар лозим шавад, ки функсия ягон
 қимат баргардонад, оператори мазкур дорои аргумент мешавад. Ба намуди 
 пешфарз аргументи ин оператор (сифр) мебошад. Ин оператор аргументашро 
 аввал ба номи функсия ихтисос медиҳад ва баъд идоракунӣ ба функсияи дигар
 мегузарад. 
 Мисол. Функсияе нависед, ки квадрати ададҳои натуралии фосилаи аз 
 то –ро ҳисоб намуда, ба функсияи аслӣ баргардонад 
 #include <iostream> 
 using namespace std; // номи функсия, навъи функсия 
 int Kvadrat(int n), аргументи функсия ва навъи 
 { аргументи функсия 
 return n*n; // оператори return қимати n*n 
 } -ро бармегардонад. 
 int main() 
 { 
 for (int i =; i <=; i++) 
 cout << i << " ^ = " << 
 Kvadrat(i) << " \n "; 
 return; 
 } 
 Тавре ки мушоҳида гардид, ин функсия қимати i-ро аз функсияи аслӣ 
 (main) ба параметри n нусхабардорӣ намуда, баъд бо ёрии оператори return n*n
 қимати онро ба квадрат бардоштаб ба фкнсияи аслӣ бармегардонад. 
 Маҳдудияти оператори return дар он аст, ки он фақат як миқдорро ба 
 функсия бармегардонад. 
 Навъи void навъест ягон қимат барнамегардонад. Вақте ки функсия бо ин
 навъ навишта мешавад, зарурати истифодаи оператори return ба миён намеояд.
 Масалан, мисоли пешина ҳангоми навъи функсия void-будан дар шакли зерин 
 навишта мешавад. 
 #include <iostream> 
 #include <cmath> 
 using namespace std; 
 void Kvadrat(int n){ 
 for (int i =; i <= n; i++) 
 cout << i << " ^ = " << i*i << " \n "; 
 } 
 int main() { 
 Kvadrat(); //даъвати функсия 
 return; 
 } 
 Функсияи мазкур қимате барнамегардонад, зеро он аз навъи холӣ (void)
 муаррифӣ шудаст ва дар фурухонии функсия номи он фақат дар як оператор 
 истифода шудааст. Натиҷаи ин мисол низ монанди мисоли боло мебошад. 
 Тавре ки аз ин мисолҳо мушоҳида шуд, номи функсия фақат дар оператори 
 чопкунӣ навишта шуд, яъне функсия дар вақти чоп намудан даъват карда шуд,
 илова бар ин, метавон номи функсияро дар ягон ифодаи ҳисобкунӣ истифода 
 кард. Мисол: 
 #include <iostream> 
 #include <cmath> 
 using namespace std; 
 int Kvadrat(int n) { 
 return n*n; 
 } 
 int main(){ 
 double LOG; 
 for (int i =; i <=; i++) { 
 LOG = log((double)Kvadrat(i)); // Истифодаи функсия 
 cout << "log(" << i << ") = " << LOG << " \n "; 
 } 
 return; 
 } 
 Оператори return на танҳо дар интиҳои барнома, инчунин метавонад дар
 дилхоҳ ҷойи барнома, ки зарурат бошад, истифода шавад. 
 Мисол: Қимати ифодаи зеринро бо истифода аз функсия ҳисоб кунед. 
 Матни барнома. 
 { 
 #include <iostream> 
 using namespace std; 
 double F(double x){ 
 if (x < ) 
 return - * x +; 
 else 
 return * x -; 
 } 
 int main(){ 
 double x, i =; 
 while (++i <= ) { 
 cout << "x = "; cin >> x; 
 cout << "F(" << x << ") = " << F(x) << " \n "; 
 } 
 return; 
 } 
 Тавре ки дидем, дар ин барнома оператори return дар функсия ду 
 маротиба истифода шуд, ба ҳамин шаклаш метавонад дар дилхоҳ ҷойи функсия 
 истифода шавад. Дар функсияи аслӣ истифодаи дастури даврии бо шарти 
 пешоянд саҳифаи тасвирро то дохил кардани ду рақам нигоҳ медорад. 
 Аз мисолҳои фавқ маълум гардид, ки дар функсияи фаръӣ 
 тағйирёбандаҳое, ки ба сифати аргумент истифода шуданд, аз тағйирёбандаҳои
 функсияи аслӣ истифодашуда фарқ мекунанд. Инчунин онҳо метавонанд 
 ҳамном бошанд. Монанди мисоли дидабаромадаамон ҳам дар функсияи фаръӣ 
 ва ҳам дар функсияи аслӣ аргумент тағйирёбандаи х истифода шудааст. 
 Тағйирёбандаҳои функсияи фаръӣ тағйирёбандаҳои маҷозӣ (dummy variables) 
 номида мешаванд. Барои онҳо дар хотира катакча (ҷое) ҷудо карда мешавад. 
 Ба функсия равон кардани параметрҳо 
 Аз функсияи аслӣ ба функсияи фаръӣ аргументҳо бо ду тарз интиқол 
 дода мешаванд: 
 ) Интиқол аз рӯи қимат (pass-by value) 
 ) Интиқол аз рӯи истинод (pass- by reference) 
 Дар равиши аввал худи аргументҳо ба функсияи фаръӣ фиристода 
 намешаванд, танҳо нусха (copy)-и онҳо фиристода мешавад. Аз ин сабаб ҳар 
 тағйироте, ки дар функсияи фаръӣ ба амал меояд, ҳеҷ таъсире ба функсияи аслӣ
 намегузорад. Мисол: 
 #include <iostream> 
 using namespace std; 
 int davatazruiqim(int adad){ 
 adad +=; 
 return adad; 
 } 
 int main(){ 
 int N; 
 cout << "N = "; cin >> N; 
 cout << "Istifodai tobei davatazruiqim = " << davatazruiqim(N) << 
 endl; 
 cout << "N = " << N << endl; 
 return; 
 } 
 Дар мисоли мазкур пас аз даъ-вати функсия, қимати тағйирбан-даи N 
 тағйир наёфт, балки ҳамон тавре, ки буд, чоп гардид. Натиҷаи барнома ба 
 сурати зерин аст. 
 N= 
 Istifodai tobei davatazruiqim= 
 N= 
 Дар равиши дуюм бошад, суроғаи аргументҳо дар функсияи аслӣ нишон 
 дода мешавад, аз ин рӯ, функсия метавонад бе нусхабардории аргумент бо он
 дастрас шавад ва ҳар амале, ки дар функсияи фаръӣ болои аргумент ба амал 
 меояд, он дар функсияи аслӣ низ болои он аргумент таъсир мерасонад. Барои
 равон кардани истиноди параметрҳо ба функсия аз оператори амперсанд (&) 
 истифода бурда мешавад. Мисол: 
 #include <iostream> 
 using namespace std; 
 int davatazruiqim(int &N){ 
 N +=; 
 return N; 
 } 
 int main(){ 
 int N; 
 cout << "N = "; cin >> N; 
 cout << "Istifodai tobei davatazruiqim = " << davatazruiqim(N) << 
 endl; 
 cout << "N = " << N << endl; 
 return; 
 } 
 Натиҷаи барнома намуди зеринро дорад: 
 N= 
 Istifodai tobei davatazruiqim= 
 N= 
 Дар ин равиш тавре ки аз натиҷа бармеояд, тағйиротеро ки дар функсияи
 фаръӣ болои аргумент ба амал омад, он тағйирот ба аргумент дар функсияи 
 фаръӣ асар гузошт. (Минбаъд дар ин бора эзоҳи пурратар дода мешавад.) 
 Мисол. Барномае нависед, ки факториали дукаратаи адади натуралии n- 
 ро ҳисоб кунад. 
 Қайд: Факториали дукарата дорои ду махсусияти зерин аст: 
 { #include <iostream> 
 using namespace std; 
 double Fact(double n){ 
 double f =, k; 
 k = ((int)n % == )?:; 
 for (int i = k; i <= n; i += ) f = f*i; 
 return f; 
 } 
 int main() 
 { 
 int N; 
 cout << "N = "; cin >> N; 
 cout << N << "!!= " << Fact(N) << " \n "; 
 return; 
 Функсияҳои бозгаштӣ (Рекурсивний функция ) 
 Функсияҳои бозгаштӣ функсияҳое мебошанд, ки дар онҳо аз дохили 
 функсия боз худи функсия ҷеғ зада мешавад. Барои ба ин матлаб пурратар 
 шинос шудан биёед факториали ададро дида мебароем. Факториали адади 
 бутуни n чунин муайян карда мешавад: 
 Ба мо маълум аст, ки факториа л и а д а д ҳ оси ли зарби ададҳои аз як то худи
 { 
 адад мебошад, яъне 
 n!=**…*(n-)*n 
 аз ин ҷо n!=n*(n-)! 
 Тавре ки дидем, дар сатри дуввум факториал мустақиман ҳисоб нашуда, 
 балки ба намуди n(n-)! таъриф шудааст. 
 Дар функсияҳои бозгаштӣ ин амал чунин иҷро карда мешавад: 
 n!=n*(n-)*(n-)*… 
 Ин амал то замоне давом мекунад, ки аргументи функсия ба баробар 
 шавад, яъне: n!=n*(n-)*(n-)*…* 
 дар охир сар карда, ҳамаи элементҳоро ба ҳамдигар зарб мекунад: 
 Ҷараёни даъвати бозгашт(рекурсия). Миқдоре, ки аз ҳар даъват 
 бармегардад. 
 Мисол. Адади бутуни n дода шудааст, факториалӣ онро бо истифода аз 
 функсияи бозгаштӣ ҳисоб кунед. 
 #include <iostream> 
 using namespace std; 
 unsigned long int factorial(unsigned int n){ 
 if (n <= ) 
 return; 
 else 
 return n*factorial(n - ); 
 } 
 int main() { 
 unsigned int n; 
 cout << "n = "; cin >> n; 
 cout << n << "!= " << factorial(n) << endl; 
 return; 
 Дар забонҳои Basic ва Fortran равиши бозгаштӣ пешбинӣнашудааст. 
 Дар баъзе забонҳои дигар ин равиш пешбинӣ шудааст, вале ҳангоми муаррифӣ 
 намудани функсия бояд ба таври сареъ муайян карда шавад, ки функсия аз 
 навъи бозгаштӣ аст ё не, то компилятор онро аз дигар функсияҳо фарқ кунад.
 Барои ба моҳияти ин навъ функсияҳо шинос шудан мисоли зеринро дида 
 мебароем. 
 Мисол. Суммаи n ададӣ аввали натуралӣро ҳисоб кунад. 
 #include <iostream> 
 using namespace std; 
 long int Summa(unsigned int n){ 
 if (n <= ) 
 return n; 
 else 
 return n + Summa(n - ); 
 } 
 int main(){ 
 unsigned int n; 
 cout << "n = "; cin >> n; 
 cout << "Summai " << n << " adadi avalai naturali\nSumma = " << 
 Summa(n) << endl; 
 return; 
 } 
 Пешнамунасозӣ аз функсия (Function Prototypes) 
 Дилхоҳ функсия дар забони C++ бояд то замони даъват муаррифӣ карда 
 шавад. Ин хел тавсифнамоиро пешнамунасозии функсия меноманд. Наҳви 
 пешнамунасозии функсия ба сурати зерин аст: 
 data_type func_name(data_type, data_typе,…) 
 Ин навъ имконият медиҳад, ки дар сурати яксон (якнавъ) набудани 
 аргументҳо ва ё дар сурати баробар набудани миқдори ар-гументҳо аз вуҷуд 
 омадани хатогиҳо пешгирӣкунад. 
 Дилхоҳ функсияе, ки пеш аз функсияи асосӣ муаррифӣ мегардад, ҳамчун 
 пешнамуна фаҳмида мешавад. 
 Мисол. Функсияе нависед, ки суммаи ададҳои тоқи натуралии аз то 
 -ро ҳисоб кунад. 
 #include <iostream> 
 using namespace std; 
 int SummaAToq(int n); 
 int main(){ 
 cout << "SummaAToq = " << SummaAToq() << endl; 
 return; 
 } 
 int SummaAToq(int n){ 
 int S =; 
 for (int i =; i <= n; i += ) 
 S += i; 
 return S; 
 } 
 Натиҷаи барнома: SummaAToq= 
 Истифодаи якчанд функсия дар як барнома 
 Дар забони С++ ба ҳар миқдоре, ки лозим бошад, метавон функсия 
 навишта (муаррифӣ кард) истифода кард. Ҳар функсия метавонад функсияи 
 дигарро даъват кунад. Дар забони Паскал ва дигар забонҳо функсияе, ки дар
 дохили як функсия таъриф шудааст, наметавонад бо ёрии функсияи дигар ҷеғ 
 зада шавад. Дар забони С++ ҳамаи функсияҳо баробар буда, ҳуқуқҳои баробар
 доранд ва ҳар функсия метавонад функсияи дигарро фурӯхонӣ (даъват) кунад.
 Робитаи байни функсияҳо дар забони С++ ба сурати зерин аст: 
 Тавре ки аз ин расм бармеояд, ҳар функсия имконият дорад, ки бо 
 функсияи дигар мустақиман ва ё ғайримустақиман робита дошта бошад. 
 Мисол. Барномае нависед, ки дар он аз якчанд функсия истифода карда 
 шавад. 
 #include <iostream> 
 using namespace std; 
 double Kvadrat(double x){ 
 return x*x; 
 } 
 double Cube(double x) { 
 return Kvadrat(x)*x; 
 } 
 double DarChor(double x) { 
 return Kvadrat(x)*Kvadrat(x); 
 } 
 double DarPanj(double x) { 
 return Kvadrat(x)*Cube(x); 
 } 
 int main(){ 
 double x; 
 cout << "x = "; cin >> x; 
 cout << x << " ^ = " << Kvadrat(x) << endl; 
 cout << x << " ^ = " << Cube(x) << endl; 
 cout << x << " ^ = " << DarChor(x) << endl; 
 cout << x << " ^ = " << DarPanj(x) << endl; 
 return; 
 } 
 Чунончӣ аз дида мешавад, дар функсияи Cube () функсияи Kvadrat 
 истифода шудааст. Дар функсияи DarPanj() бошад, ҳам функсияи Cube () ва 
 ҳам Kvadrat() истифода шудааст. Натиҷаи ин барнома ба сурати зерин аст: 
 Қаламрави тағйирёбандаҳо 
 Дар забони С++ ду намуди тағйирёбандаҳо ба кор бурда мешаванд: 
 ) Тағйирёбандаҳое, ки дар дохили як функсия ё як блок муаррифӣ карда
 мешаванд, тағйирёбандаҳои маҳаллӣ номида мешаванд. Ин гуна 
 тағйирёбандаҳо фақат дар дохили як функсия шинохта мешаванд. Онҳоро ҳатто
 функсияи аслӣ ҳам намешиносад, аз ин хотир онҳоро тағйирёбандаҳои маҳаллӣ
 ё хусусӣ меноманд. Дар забони С++ ин навъи тағйирёбандаҳоро 
 тағйирёбандаҳои худкора (automatic) низ мегуянд. 
 Тағйирёбандаҳои мазкур дар вақти иҷроиши барнома, ҳангоме ки 
 идоракуни дохили он блок ё функсияе, ки дар он муаррифӣ шудаанд, мегардад,
 арзи вуҷуд мекунанду халос. Ҳарчанд ки дар блокҳо ё функсияҳои дигар бо ин
 ном тағйирёбандаҳо мавҷуд бошанд, онҳо байни ҳам ҳеҷ робитае надоранд. Ин
 ба монанди он аст, ки дар як шаҳр ду одам бо як ном мавҷуданд ва бо ҳамдигар
 ҳеҷ робитае надоранд. Мисол: 
 Func() 
 { 
 int d=; 
 } 
 Func() 
 { 
 int d=-; 
 } 
 Тавре ки аз ин мисол айён аст, ду функсия тағйирёбандаҳои бо номи d 
 муаррифӣ ва истифода шудаанду миқдорашон аз ҳамдигар фарқ мекунад. Ин 
 тағйирёбандаҳо бо як ном муаррифӣ шудаанд, вале байни ҳам ҳеҷ робита ё 
 алоқамандие надоранд, яъне тағйирёбандаи d-и функсияи дуюм аз 
 тағйирёбандаи d-и функсияи якум фарқ мекунад. Онҳо метавонанд аз навъҳои 
 гуногун иборат бошанд. 
 Тағйирёбандаҳои маҳаллӣ метавонанд дар як функсия дар дохили ҳар 
 блокҳо тавсиф карда шаванд. Мисол: 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 double x, S; 
 cout << "x = "; cin >> x; 
 S = x /; 
 cout << "S = " << S << endl; 
 { 
 int x, S; 
 cout << "local variables " << endl; 
 cout << "x = "; cin >> x; 
 S = * x; 
 cout << "S = " << S << endl; 
 } 
 cout << "\nS = " << S << endl; 
 return; 
 } 
 Дар ин ҷо чи хеле ки гуфтем, дар дохили блок тағйирёбандаи x ва S аз
 навъи бутун ҳамчун тағйирёбандаи маҳаллӣ муаррифӣ шудааанд. Вақте ки 
 иҷроиши барнома дохили блок мешавад, онҳо вуҷуд доранд, вале дар ҳолати 
 берун шудан аз блок дигар онҳо вуҷуд надоранд ва ҳофиза аз онҳо холӣ карда
 мешавад. Аз натиҷаи барнома, ки сурати зеринро дорад метавон сареътар 
 мушоҳида кард: 
 x= 
 S= 
 local variables 
 x= 
 S= 
 S= 
 Тағйирёбандаҳои умумӣ бошанд, тағйирёбандаҳое ҳастанд, ки дар тамоми
 тӯли барнома шинохта шуда, ҳар куҷо метавонанд мав-риди истифода қарор 
 гиранд. Инчунин миқдори худро дар тамоми вақти иҷроиши барнома нигоҳ 
 доранд. Тағйирёбандаҳои мазкур пеш аз функсияи аслӣ муаррифӣ карда 
 мешаванд. Барои ба онҳо зудтар дастрас шудан ва аз тағйирёбандаҳои маҳаллӣ
 фарқ карданашон, аз оператори ягонаи иҷозати ҳудуди фаъолият:: истифода 
 бурда мешавад. 
 Мисол. Барномае нависед, ки дар он аз тағйирёбандаҳои маҳаллӣ 
 истифода шуда бошад. 
 #include <iostream> 
 using namespace std; 
 const double PI =.; 
 int main(){ 
 float PI =.; 
 cout << "Qimati Localii PI = " << PI << endl; 
 cout << "Qimati globalii PI = " <<::PI << endl; 
 return; 
 } 
 Тавре ки аз ин мисол маълум гардид, ду тағйирёбанда бо номи PI 
 муаррифӣ шудаанд, ки якеаш тағйирёбандаи маҳаллӣ аз навъи float буда, дорои
 қимати PI=. мебошад. Тағйирёбандаи дигар бо ин ном ҳамчун 
 тағйирёбандаи умумӣ аз навъи double муаррифӣ шуда, дорои қимати 
 PI=. мебошад. Дар операторҳои хориҷкунӣ нахуст қимати тағйирёбандаи
 PI, ки аз навъи маҳаллӣ аст, дар саҳифаи тасвир хориҷ карда шудааст. Дар 
 оператори хориҷкунии дуввум бошад, қимати тағйирёбандаи умумии PI бо ёрии
 оператори ягонаи иҷозати ҳудуди фаъолият (::) дар саҳифаи тасвир навишта 
 шудааст. 
 Тағйирёбандаҳои умумӣ корбурди зиёде доранд, вале бар замми ин аз 
 норасоӣ холӣ нестанд. Бинобар ин, бо далелҳои зерин бояд аз истифодаи ин 
 навъ тағйирёбандҳо худдорӣ кард. 
 сабабҳо шинохта нашаванд, дар натиҷа барнома ба хатогӣ рӯбарӯ мешавад. 
 дар баъзе қисмат дигар карда, дар ҷои дигар боз ба қимати аввала соҳиб шавад.
 Тағйирёбандаҳои умумӣ бошанд, Тавре ки гуфтем, дар тамоми тӯли барнома 
 қимати худро тағйир намедиҳанд. 
 Class-ҳои ҳофиза 
 Class-ҳои ҳофиза қаламрав ва бақои як тағйирёбандаро дар як барнома 
 муайян мекунанд, яъне дар куҷо дастрас будан ва дар куҷо дастрас набудани
 тағйирёбандаро муайян мекунанд. Дар забони С++ чунин class-ҳо и ҳофиза 
 вуҷуд доранд: 
 № Номи class Истифодаи class дар 
 забони С++ 
 Синфи ҳофизаи худкор (automatic) auto 
 Синфи ҳофизаи доимӣ ва ё собит static 
 (static) 
 Синфи ҳофизаи registerӣ (register) register 
 Синфи ҳофизаи хориҷӣ (external) external 
 Тарзи истифодаи ин class-ҳо ба сурати зерин аст: 
 auto int variable, variable, 
 static int variable =; 
 register int variable; 
 Дар сатри дуюм илова бар он ки variable аз навъи бутун муаррифӣ 
 шудааст, ба он қимати аввала бахшида шудааст. Ҳоло барои пурратар шинос 
 шудан ҳар яке аз ин class-ҳоро дар алоҳидагӣ дида мебароем. 
 Синфи ҳофизаи худкор (automatic) 
 Тағйирёбандаҳои синфи худкор ( automatic) ҳамеша дар дохили як 
 функсия муаррифӣ ва истифода мешаванд, яъне қаламрави исти-фодаи онҳо 
 танҳо дохили як функсия ва ё як блок мебошанд. Бинобар ин, бо ин ном 
 тағйирёбандаҳое, ки дар дигар ҷойҳо муаррифӣ мешаванд, аз ҳамдигар ҷудо 
 буда мустақил мебошанд. 
 Ба ҳар ҳол, Тавре ки гуфтем, тағйирёбандаҳои худкор ба берун шудан аз
 функсия ё блоке, ки дар дохили он муаррифӣ шудаанд, миқдори худро аз даст
 медиҳанд. Аз мантиқи барнома дида мешавад, ки ҳар гоҳ ки функсия ё блоке 
 вобаста ба он иҷро гардад, тағйир-ёбандаи худкорӣ боз аз сари нав шинохта
 мешавад. 
 Мисол. Барномае нависед, ки дар он аз тағйирёбандаҳои навъи худ-кора
 истифода карда шавад. 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 int a =; 
 cout << a << endl; 
 { 
 auto int a = -; 
 cout << "auto a = " << a << endl; 
 } 
 cout << a << endl; 
 return; 
 } 
 Тавре ки айён аст, дар ин мисол тағйирёбандаи a аввал аз навъи бутун
 муаррифӣ гардидааст ва дар дохили як блок низ бо ин ном тағйирёбандаи 
 худкоре муаррифӣшудааст. Вақте ки идоракунии барнома вориди блок 
 мегардад, қимати ин тағйирёбанда шинохта мешавад ва ҳангоми хориҷ шудан 
 аз блок қимати ин тағйирёбанди дигар мешавад ва боз қимати аввалаи а дар 
 саҳифаи тасвир хориҷ карда мешавад. 
 Синфи ҳофизаи доимӣ (static) 
 Тағйирёбандҳои доимӣ тағйирёбандҳое мебошанд, ки дар тамоми 
 барнома то замоне ки барнома истифода мешаванд, қимати худро тағйир 
 намедиҳанд. Тағйирёбандҳои синфи мазкур, Тавре ки тағйирёбандҳо синфи 
 худкор буданд, дар дохили як функсия муаррифӣ ва истифода мешаванд, ба ин
 фарқият, ки пеш аз онҳо калимаи калидии static навишта шуда, барои онҳо низ
 қимати аввала бахшида мешаванд. Дар ҳолати ба онҳо набахшидани қимати 
 аввала ба таври автоматӣ барои худ қимати нол қабул мекунанд. Онҳо 
 метавонанд ба тағйирёбандҳои беруни ҳамном бошанд. 
 Мисол. Барномае нависед, ки дар он тағйирёбандаҳои классиstatic 
 истифода шаванд. 
 #include <iostream> 
 using namespace std; 
 float a =, b =; 
 int main(){ 
 cout << "a = " << a << endl; 
 cout << "b = " << b << endl; 
 static int a =, b; 
 cout << "static a = " << a << endl; 
 cout << "static b = " << b << endl; 
 return; 
 } 
 Тавре ки аз ин мисол маълум шуд, тағйирёбандҳои a ва b аз навъи умумӣ
 муаррифӣ шуда, дар функсияи асосӣ хориҷ карда шудаанд, сипас, дар дохили 
 ҳамон функсия ду тағйирёбанда ба ҳамин ном аз синфи static муаррифӣ шуда,
 ба якеаш қимати аввала бахшида шуда, ба дигараш қимате бахшида нашудааст.
 Бинобар ин, ба таври автомати қимати қабул мекунад. Натиҷаи барнома 
 намуди зеринро дорад: 
 a= 
 b= 
 static a= 
 static b= 
 Синфи ҳофизаи registerӣ (register) 
 Синфи ҳофизаи registerи (register)-як навъи дигари мушах-хаскунии 
 ҳофиза мебошад, ки он фақат барои тағйирёбандаҳои навъи бутун (int) ва рамзӣ
 (char) хос буда, бештар дар операторҳои даврӣ барои зуд иҷро намудани давр
 истифода мешаванд. Тағйирёбандаҳои навъи мазкур имконият медиҳанд, ки ба 
 ҷойи ҳофизаи компютер, ки дар он ҳамаи тағйирёбандаҳо нигоҳ дошта 
 мешаванд, ҳофизаи registerӣ (яъне ҳофизаи худашон) (CPU) истифода шавад. 
 Дар ин сурат амалиёт болои ин навъ тағйирёбандаҳо хеле дуруст ва саҳеҳ амалӣ
 мегардад. Аз сабаби он ки CPU маҳдуд аст, миқдори барномаҳое, ки дар онҳо
 тағйирёбандаҳои синфи мазкур истифода мешаванд, кам аст. Инчунин ин навъ 
 синфи ҳофиза танҳо барои тағйирёбандаҳои маҳалли хос мебошад. 
 Мисол. Барномае нависед, ки дар он тағйирёбандаҳои класси register 
 истифода шаванд. 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 register int k; 
 int S =; 
 for (k =; k <=; k++) 
 S += k; 
 cout << "S = " << S; 
 return; 
 } 
 Натиҷаи ин барнома S= мешавад. 
 Синфи ҳофизаи хориҷӣ (external) 
 Тавре ки қаблан гуфтем, барои суръати иҷроиши барномаро зиёд намудан
 дар забони С++ барномаи бузургро ба якчанд қисмҳо бо номи unit-воҳид ё 
 modul ҷудо намуда, дар дар файлҳои ҷудогона қарор дода, баъдан якҷоя намуда
 тарҷума (Compile) мекунанд. Дар ин равиш агар бихоҳем, ки тағйирёбандаҳоро
 дар воҳиди аслӣ муаррифӣ кунем ва онҳоро дар функсияҳои фаръӣ истифода 
 барем (бе он ки дар функсияҳои фаръӣ барои онҳо ҳофиза ихтисос диҳем), 
 зарурат мешавад, ки онҳоро аз навъи хориҷӣ муаррифӣ кунем. Барои дар 
 функсияи лозимӣ онҳоро истифода бурдан, пеш аз навъи тағйирёбандаҳо, 
 калимаи калидии extern навишта мешавад ва он ба компилятор мегӯяд, ки 
 тағйирёбанда аз навъи берунӣ аст ва барои он ҳофиза ҷудо карда нашавад. Агар
 як тағйирёбандаи хриҷӣ дар дохили функсияе, ки тағйирёбандаҳои умумӣ дар 
 онҷо муаррифӣ шудаанд истифода шавад, пеш аз он навиштани калимаи extern 
 зарур намебошад. Вақте ки компилятор ба мавқеъе, ки дар он тағйирёбанда 
 муаррифӣ нашудааст, расад ташхис мекунад, ки оё он аз навъи умумӣ аст, агар
 бошад, онро ҳамчун extern дар назар мегирад. 
 Агар тағйирёбандаҳои хориҷӣ ба намуди умумӣ (global) муар-рифӣшуда 
 бошанд, қаламрави истифодаи онҳо аз мавқеи муар-рифишуда то охири 
 барнома мебошад. Дар ҳар функсияе, ки мо ба ин навъ тағйирёбандаҳо қимат 
 бахшем, бо баромадан аз функсия низ қимати худро аз даст намедиҳанд. Барои
 тағйирёбандаҳо навъи мазкур бахшидани қимати аввала хос нест, бо истиснои
 навъи умумӣ будани онҳо. Ба ҳар ҳол, муаррифӣ намудани функсия агар пеш аз
 муаррифӣ намудани тағйирёбандаҳои хориҷи биёяд, бояд тағйирёбандаҳои 
 мазкур дар дохили ин навъи функсия ҳамчун хориҷӣ муаррифӣ гардад. 
 Мисол. Дар ин мисол тарзи истифодаи тағйирёбандаҳои класси extern 
 истифода шудаанд. 
 #include <iostream> 
 using namespace std; 
 extern int d=; 
 int main(){ 
 cout<<"d="<<d<<endl; 
 { 
 d=; 
 cout<<"d="<<d<<endl; 
 } 
 cout<<"d="<<d<<endl; 
 { 
 d=; 
 cout<<"d="<<d<<endl; 
 } 
 cout<<"d="<<d<<endl; 
 return; 
 } 
 Тавре ки дида мешавад, дар ин мисол тағйирёбандаи d аз навъи умумӣ ва
 хориҷӣ муаррифӣ гардида, дар дохили функсия бо ёрии оператори ҳоиҷкунӣ ба
 чоп дода шудаааст, сипас, дар дохили блоки якум ба он қимати d= бахшида
 шуда, бо ёрии оператори хориҷкунӣ низ ба чоп дода шудааст. Берун аз блок 
 бори дигар бо ёрии оператори хориҷкунӣ d-ро ба чоп дода шудааст ва Тавре ки
 дида мешавад, қимате, ки дар дохили блок омадааст, ба қимати пас аз он омада
 якхела мебошад. Баъд аз ин, бори дигар дар дохили блоки дигаре ба 
 тағйирёбандаи мазкур қимати d= бахшида, бо ёрии оператори хориҷкунӣ ба 
 чоп дода шудааст. Пас аз ин функсия бошад, қимати d низ бо ёрии оператори
 хориҷкунӣ ба чоп дода шудааст ва Тавре ки маълум мешавад, дар ин ҷо қимати
 d ба қимати аз ҳама охирон бахшидаи он баробар мебошад. Натиҷаи барнома 
 шакли зеринро дорад: 
 d= 
 d= 
 d= 
 d= 
 d= 
 Ба аргументҳои функсия бахшидани қимати аввала 
 Ҳангоми даъвати функсия аргументҳое, ки ба он равона карда мешаванд,
 бояд лорои ягон қиммат бошанд, вагарна барнома ба хатогӣ рӯбарӯ мешавад. 
 Дар забони C++ барномасоз метавонад ҳангоми пешнамунасозӣ ба аргументҳои 
 яунксия қимати ибтидои бахшад. Пас, иҷрои ин амал агар дар вақти даъвати 
 функсия аргументҳо нишон дода нашуда бошанд ҳам, барнома ба хатогӣ рубарӯ
 намешавад. Функсия ба таври автоматӣ ҳамон қимати аргументҳоеро, ки ба он
 пештар бахшида будем, истифода мекунад. 
 Мисол. Функсияе нависед, ки ҳаҷми параллелопипедро ҳангоми дода 
 шудани баландӣ, дарозӣ ва васеъгии он ҳисоб кунад. 
 #include <iostream> 
 using namespace std; 
 int HajmParall(int darozi=, int bar=,int balandy=); 
 int main(){ 
 cout<<"Hajmi Parallelopiped bo qimathoi qably:"<<HajmParall()<<"\n"; 
 cout<<"Hajmi Parallelopiped bo doda shudani darozi va bar 
 ="<<HajmParall(,)<<"\n"; 
 cout<<"Hajmi Parallelopiped bo doda shudani darozi,bar va 
 balandi:"<<HajmParall(,,)<<" \n "; 
 return; 
 } 
 int HajmParall(int darozi, int bar,int balandy){ 
 return darozi* bar* balandy; 
 } 
 Тавре ки аз ин ҷо дида мешавад, ҳангоми пешнамунасозии функсия барои
 аргументҳои он қимати бахшида шудааст. Дар оператори хориҷкунии якум 
 ҳарчанд ки функсия дорои аргумент намебошад, вале ба таври автоматӣ 
 қиматҳои авваларо қабул мекунад. Дар оператори хориҷкунии дуввум бошад, 
 танҳо дарозӣ ва бари параллелопидед нишон дода шудааасту халос, баландии 
 он ба таври автоматӣ қимати авваларо қабул мекунад. Натиҷаи барнома шакли
 зеринро дорад: 
 Hajmi Parallelopiped bo qimathoi qably = 
 Hajmi Parallelopiped bo doda shudani darozi va bar = 
 Hajmi Parallelopiped bo doda shudani darozi,bar va balandi = 
 Сарборгузории функсияҳо 
 Забони С++ имконият медиҳад, ки якчанд функсияҳоро бо як ном ва 
 набори аргументҳои гуногунавъ муаррифӣ кунем. Чунин амалро 
 сарборигузории функсия меноманд. Компилятор ҳангоми даъвати функсия ба 
 навъи аргументҳои он назар меафканад. Агар аргументҳо ба кадом варианти 
 функсия, ки мувофиқ оянд, ҳамон варианти функсия даъват карда мешавад. 
 Мисол. Функсияе нависед, ки квадрати адади навъи дилхоҳро ҳисоб кунад. 
 #include <iostream> 
 using namespace std; 
 int Kvadrat(int n){ 
 return n*n; 
 } 
 double Kvadrat(double n){ 
 return n*n; 
 } 
 float Kvadrat(float n){ 
 return n*n; 
 } 
 int main(){ 
 cout<<"Kvadrati int="<<Kvadrat()<<endl; 
 cout<<"Kvadrati float="<<Kvadrat(.)<<endl; 
 cout<<"Kvadrati double="<<Kvadrat(.)<<endl; 
 return; 
 } 
 Тавре ки дида мешавад, дар ин ҷо се функсия бо як ном вале бо 
 аргументҳои гуногунавъ муаррифӣ шудаанд. Дар функсияи асосӣ бо ёрии 
 оператори хориҷкунӣ ин функсия бо аргументҳои гуногун ба чоп дода шудааст.
 Натиҷаи барнома шакли зеринро дорад: 
 Kvadrati int= 
 Kvadrati 
 float=. 
 Kvadrati 
 double=. 
 Қолаби функсияҳо 
 Тавре ки аз мавзӯи «сарборгузории функсияҳо» мушоҳида кардем, барои 
 онуи функсяамон болои навъи дилхоҳ кор кунад, зарур аст барои ҳар як навъ
 варианти ба он вобастаи функсия навишта шавад. Ин амал хело хуб аст, вале
 вақти зиёд ва ҷои зиёдро банда намуда, матни барномаро зиёд мекунад. Барои
 ин амалро ба таври сода иҷро намудан, ки камтар бошад, аз қолаби функсияҳо,
 ки дар версияҳои охирини С++ ба вуҷуд омаданд, истифода бурдан мумкин 
 аст. Қолабҳои функсия матни барномаро хело кӯтоҳ намуда, аз вуқуи хатогиҳо
 пешгири мекунанд. 
 Мисол. Функсияе нависед, ки аз се адади додашуда калонтаринашро 
 барорад. Ададҳои додашуда метавонанд аз дилхоҳ навъи стандартӣбошанд. 
 Ҳал. Аввал масъалаи додашударо тавассути сарборигузории функсияҳо 
 ва баъд бо истифода аз қолабҳо менависем, то ин ки ба хонанда амалкарди ин
 ду механизм ошкор ва фаҳмо гардад. Ба намуди сарборигузорӣ лозим аст, ки 
 барои ҳар навъи стандарти варианти ба он мувофиқи функсияро нависем. 
 #include <iostream> 
 using namespace std; 
 int Max(int a, int b,int c){ 
 int max=a; 
 if (max<b) 
 max=b; 
 if (max<c) 
 max=c; 
 return max; 
 } 
 double Max(double a, double b,double c){ 
 double max=a; 
 if (max<b) 
 max=b; 
 if (max<c) 
 max=c; 
 return max; 
 } 
 int main() 
 { 
 cout<<"Max int="<<Max(,,)<<endl; 
 cout<<"Max double="<<Max(.,.,.)<<endl; 
 return; 
 } 
 Тавре ки дида мешавад, дар ин ҷо барои ду навъи додаҳо (int ва double)
 варианти функсияро навистем, агар мо барои ҳамаи навъи додаҳо функсия 
 нависем, хело бузург мешавад ва идоракунии он мушкил мегардад. Аз ин рӯ 
 зарурат мешавад, ки роҳеро ҷустуҷӯ кунем, ки матни барномаи мо кӯтоҳ гардад,
 то барои навиштани он вақти камтар сарф шавад. Роҳи аз ҳама хуб истифодаи
 қолибҳои функсия мебошад. Ҳамаи қолабҳои функсия бо калимаи калидии 
 «template» оғоз мешаванд. Тарзи муаррифӣ намудани қолаби функсия бошад, ба
 сурати зерин аст: 
 template <class Type> //сарлавҳа 
 { 
 Тани функсия 
 } 
 Дар ин ҷо template калимаи калидӣ, class Type-навъи класс ё навъи 
 аргументҳо ва натиҷаи функсия. Тани функсия бошад, маҷмӯи амалҳоиҳои 
 иҷроменамудаи функсия мебошанд. Ба сифати мисол метавонем барномаи 
 қаблиро ба сурати зерин навист. 
 #include <iostream> 
 using namespace std; 
 template <class T> 
 T Max(T a,T b, T c){ 
 T max=a; 
 if(max<b) 
 max=b; 
 if(max<c) 
 max=c; 
 return max; 
 } 
 int main(){ 
 cout<<"Max int="<<Max(,,)<<endl; 
 cout<<"Max double="<<Max(.,.,.)<<endl; 
 cout<<"Max char="<<Max(’x’,’y’,’Z’)<<endl; 
 return; 
 } 
 Дар ин ҷо template- калимаи калидӣ, <class T>- номи класс, ва T Max(T a,
 T b, T c)-бошад, функсияе бо номи Max аз навъи қолаб мебошад. Ифодаи T 
 max=a бошад, тағйирёбандаи max-ро аз навъи қолаб муаррифӣ мекунад. Тавре 
 ки дида мешавад, дар ин ҷо бо як қолаб калонтарин қимати дилоҳ навъи додаҳо
 муайян карда мешавад. Ин амал Тавре ки аён аст, вақти камтарро гирифта 
 матнӣ барномаро аз зиёдшавӣнигоҳ медорад. 
 Саволҳо барои мустаҳкамкунӣ 
 дар чист? 
 мешавад? 
 қимати аввала махшем? 
 мегарданд, чӣ гуна тағйирёбандаанд? 
 Намунаи ҳалли масъалаҳо 
 #include <iostream> 
 using namespace std; 
 long int summa(int n){ 
 long int S=; int i; 
 if (n>) 
 for ( i=;i<=n;i++){ 
 if (i%!=) 
 S+=i; 
 } 
 return S; 
 } 
 int main(){ 
 int n; 
 cout<<"n=";cin>>n; 
 cout<<"Summa adadhoi toqi az to "<<n<<" = "<<summa(n)<<endl; 
 return; 
 } 
 ситорача «*» тасвир кунад. 
 #include <iostream> 
 using namespace std; 
 void Sekunja(){ 
 cout<<" *"; 
 } 
 int main(){ 
 int i,j; 
 for(i=;i<=;i++) 
 { 
 for (j=;j<=i;j++) 
 Sekunja(); 
 cout<<endl; 
 } 
 return; 
 } 
 Мақсади бозӣ аз он иборат буд, ки се то сутунча дода мешаванд. Дар сутунчаи
 якум ҳалқаҳо бо тартиби калоншавиашон чида мешаванд. Талаб карда мешавад,
 ки ҳалқаҳоро ба сутунчаи дигар (сеюм) тавре гузаронед, ки тартиби 
 ҷойгиршавиашон дигар нашавад, яъне ҳеҷ гоҳ ҳалқаи калон дар болои ҳалқаи 
 хурд қарор нагирад. Илова бар ин, бояд ҳалқаҳо якто-якто кӯчонида шаванд.
 Дар поён барои се ҳалқа расми бозӣ оварда шудааст. Функсияи бозгаштие 
 нависед, ки кори ин бозиро иҷро кунад. 
 Матни барнома: 
 #include <iostream> 
 using namespace std; 
 int n; 
 void BurjHano(int m, int a,int b, int c){ 
 if (m>){ 
 BurjHano(m-, a, c, b); 
 cout<<"Halkai raqami "<<m<<" az sutuni "<< a<<" ba sutuni 
 "<<b<<" kuchonida shud: "<<endl; 
 BurjHano(m-, c, b, a); 
 } 
 } 
 int main(){ 
 cout<<"n=";cin>>n; 
 BurjHano(n,,, ); 
 return; 
 } 
 Натиҷаи барнома шакли зеринро дорад: 
 n= 
 Halkai raqami az sutuni ba sutuni kuchonida shud: 
 Halkai raqami az sutuni ba sutuni kuchonida shud: 
 Halkai raqami az sutuni ba sutuni kuchonida shud: 
 Halkai raqami az sutuni ba sutuni kuchonida shud: 
 Halkai raqami az sutuni ba sutuni kuchonida shud: 
 Halkai raqami az sutuni ba sutuni kuchonida shud: 
 Halkai raqami az sutuni ba sutuni kuchonida shud: 
 мураттаб намояд. 
 #include <iostream> 
 #include <stdlib.h> 
 #include <string.h> 
 using namespace std; 
 void buble_sort(char *array[], int n){ 
 char *temp; 
 int i, j; 
 for(i=;i<n;i++) 
 for(j=;j<n;j++) 
 if (strcmp(array[i], array[j])<) 
 { 
 temp=array[i]; 
 array[i]=array[j]; 
 array[j]=temp; 
 } 
 } 
 int main(){ 
 char *mass[]= {"Zaripov", "Alimov", "Fozilov", 
 "Qamarov","Nuriddinov", "Davlatov", "Saidov"}; 
 int i; 
 buble_sort(mass, ); 
 for(i=;i<;i++) 
 cout<<mass[i]<<" "; 
 return; 
 } 
 ки қимати миёнаи арифметикии ададҳои содаи воридшуда ва функсияи дигар 
 нависед, ки қимати миёнаи ададҳои содаи воридшударо ҳисоб кунад. Агар 
 чунин ададҳо набошанд, пайғоми муносибе чоп кунад. 
 #include <iostream> 
 #include <cmath> 
 using namespace std; 
 unsigned int sodda(unsigned int N){ 
 int i,k; 
 for(k=,i=;i<=N/;i++) 
 if (N%i==){ k=;break; 
 } 
 return k; 
 } 
 unsigned int Mukammal(unsigned int N){ 
 unsigned int i,S; 
 for (S=,i=;i<=N/;i++) 
 if (N%i==) S+=i; 
 if(S==N)return; 
 else 
 return; 
 } 
 int main(){ 
 unsigned int i,N,X,S,ks,km; 
 long int P; 
 cout<<"N=";cin>>N; 
 for(ks=km=S=,P=,i=;i<=N;i++) 
 { 
 cout<<"X=";cin>>X; 
 if (sodda(X)) 
 { 
 ks++; //Ҳисобкунаки миқдори ададҳои сода 
 P*=X; //Ҳосили зарби ададҳои сода 
 } 
 if (Mukammal(X)) 
 { 
 km++; //Ҳисобкунаки ададҳои мукаммал 
 S+=X; //Суммаи ададҳои мукаммал 
 } 
 } 
 if (ks>) 
 cout<<"MGeom="<<pow(P,(float)/ks)<<" \n "; 
 else 
 cout<<"Adadi sodda nest!\n"; 
 if (km>) 
 cout<<"MArif="<<(float)S/km<<" \n "; 
 else 
 cout<<"Adadi mukammal nest!\n"; 
 cout<<sodda(); 
 return; 
 } 
 мешаванд. Барномае нависед, ки суммаи ададҳои сода ва суммаи ададҳои ғайри
 содаи дохили пайдрпайиро ҳисоб кунед. Барои муайянкунии ададҳои сода 
 функсия нависед. 
 #include <iostream> 
 #include <cmath> 
 using namespace std; 
 unsigned int Sodda(unsigned int N){ 
 int i,k; 
 for(k=,i=;i<=N/;i++) 
 if(N%i==) 
 k=; 
 return k; 
 } 
 int main(){ 
 unsigned int X, M=, S=; 
 for(cout<<"X=",cin>>X;X!=;cout<<"X=",cin>>X) 
 { 
 if (Sodda(X)) 
 S+=X; 
 else 
 M+=X; 
 } 
 cout<<"Murakkab="<<M<<"\nSodda="<<S<<endl; 
 return; 
 } 
 L)-ро ҳисоб кунад. 
 #include <iostream> 
 using namespace std; 
 double DarDavra(double R){ 
 return.**R; 
 } 
 int main(){ 
 double R; 
 cout<<"R=",cin>>R; 
 cout<<"Darozi davra="<<DarDavra(R)<<endl; 
 return; 
 } 
 элементҳои пайдарпайии ададҳои ҳақиқии -ро, ки намуди зеринро доранд, 
 барорад. 
 #include <iostream> 
 using namespace std; 
 double PP(int N){ 
 if (N==) 
 return; 
 else 
 return +/(PP(N-)); 
 } 
 int main(){ 
 int n; 
 cout<<"n=";cin>>n; 
 for (int i=;i<=n;i++) 
 cout<<i <<"."<<" Paydarpai="<<PP(i)<<endl; 
 return; 
 } 
 кунад. 
 #include <iostream> 
 #include <cmath> 
 using namespace std; 
 int KTU(int a,int b){ 
 if(b==) 
 return a; 
 else 
 return KTU(b,a%b); 
 } 
 int main(){ 
 int a,b; 
 cout<<"a=";cin>>a; 
 cout<<"b=";cin>>b; 
 cout<<"KTU("<<a<<","<<b<<")="<<KTU(a,b); 
 return; 
 } 
 Функсияи гиперболи ҳангоми ба қатор паҳн кардан намуди зеринро дорад: 
 ∑ 
 #include <iostre a m> 
 #include <cmath> 
 using namespace std; 
 const int N=; 
 double sh(double z){ 
 int i; 
 double S=z,q=z; 
 for (i=;i<=N;i++){ 
 q*=z*z/(*i)/(*i+); 
 S+=q; 
 } 
 return S; 
 } 
 int main(){ 
 double x; 
 int i; 
 cout<<"x=";cin>>x; 
 cout<<"sh("<<x<<")="<<sh(x)<<endl; 
 cout<<"sinh("<<x<<")="<<sinh(x)<<endl; 
 return; 
 } 
 #includ e < i o s t r e a m >∏ ( ) 
 #include <cmath> 
 using namespace std; 
 double Zarb(double x, int i){ 
 if (i>) 
 return Zarb(x,i-)*(+pow(x,pow(,i))); 
 else 
 return +x; 
 } 
 int main(){ 
 double x; 
 int n,i; 
 cout<<"x=";cin>>x; 
 cout<<"i=";cin>>i; 
 cout<<"Qimati Zarb dar tobe="<<Zarb(x,i)<<endl; 
 cout<<"Qimati Zarb be tobe="<</(-x)<<endl; 
 return; 
 } 
 кунад. 
 #include <iostream> 
 #include <cmath> 
 using namespace std; 
 long SummaSodda(int n){ 
 int i,j,S,k; 
 for (S=,i=;i<=n;i++){ 
 for (k=,j=;j<=(int) sqrt(i);j++) 
 if (i%j==) 
 k++; 
 if(!k) 
 S+=i; 
 } 
 return S; 
 } 
 int main(){ 
 int n,i; 
 cout<<"n=";cin>>n; 
 cout<<SummaSodda(n)<<"\n "; 
 return; 
 } 
 кунад. 
 #include <iostream> 
 using namespace std; 
 template <class A> 
 A KTU (A a,A b){ 
 if(b==) 
 return a; 
 return KTU(b,a%b); 
 } 
 int main(){ 
 int a,b; 
 cout<<"a=";cin>>a; 
 cout<<"b=";cin>>b; 
 cout<<KTU(a,b)<<" \n "; 
 return; 
 } 
 шудани қиматҳои a ва b қимати f(f(a+b))-ро ҳисоб кунад. Барои ҳалли ин мисол
 функсия нависед. 
 #include <iostream> 
 #include <cmath> 
 using namespace std; 
 double F(double x){ 
 return pow(x,(double)/)+pow(x,(double)); 
 } 
 int main(){ 
 double a,b,P; 
 cout<<"a=";cin>>a; 
 cout<<"b=";cin>>b; 
 P=F(a+b); 
 cout<<F(P)<<" \n "; 
 return; 
 } 
 тақсимкунандаҳои дигараш (бе худи адад) баробар бошад. Функсияе нависед, 
 ки ададҳои «дӯст»-и порчаи […n]-ро барорад. 
 #include <iostream> 
 using namespace std; 
 int main() { 
 int n,i,S,k,j; 
 cout<<"n=";cin>>n; 
 for (i=;i<=n;i++) 
 { 
 S=; 
 for (j=;j<=i/;j++) 
 if((i%j)==) S+=i; 
 cout<<S<<endl; 
 for (k=;k<=n;k++) 
 if ((k==S) && (k!=i) ) 
 cout<<k<<" " <<i<<endl; 
 } 
 return; 
 } 
 Масъалаҳо барои кори мустақилона 
 пайдарпайии ададҳои ҳақиқии -ро чоп кунад. 
 намуди зеринро доранд: 
 Функсияе нависед, ки пайдарпайиии элементҳои -ро чоп 
 кунад. 
 ин пайдарпайи мебошад. Функсияе нависед, ки суммаи қисмҳои касрии ин 
 ададҳоро ҳисоб кунад. 
 маълуманд. Функсияе нависед, ки масоҳати секунҷаро ҳисоб кунад. 
 кунад, ки оё бо ёрии ин порчаҳо секунҷа сохтан мумкин аст. 
 { 
 min( m a x (m, n ),m a x (x,y )) 
 cosxtg(x+)+ 
 шудаанд: 
 { 
 бо додашудани адади бутуни n ( n ) элементи n-уми ин пайдарпайиро 
 ёбед. 
 ) ) 
 номи рақамро ба чоп диҳад. Масалан: 
 Дохилкунӣ,,,… 
 Хориҷкунӣ як, ду, се,… 
 квадрати пуррарор ташкил медиҳанд. 
 ки дараҷаи n-и адади х бо ёрии формулаи зерин ҳисоб карда мешавад. 
 { 
 Боби. Массивҳо (arrays) 
 Муқаддима 
 Барои иҷрои ягон амал (масалан ҷамъ) бо ду адади додашуда, се 
 тағйирёбанда гирифта, якеашонро бо a, дигарашро бо b ва натиҷаро бо s ишора
 мекунем. Ба ҳамин монанд барои се адад аз чор тағйирёбанда истифода бурда
 мешавад. Акнун бигзор адад дода шуда бошад. Агар барои ҳар яке 
 аз ададҳо як тағйирёбанда гирифта шавад, матни барнома хело калон шуда, 
 барноманавис дилгир ме ш а ва д. А з ин ҷо зарурати истифодаи роҳи дигаре пеш
 меояд, ки идораи барномаро осон гардонида, матни онро аз зиёдшави нигоҳ 
 дорад. Якчанд роҳи бартараф намудани ин мушкили вуҷуд дорад, ки аз ҳама 
 роҳи содда истифода аз массивҳо мебошанд. 
 Ҳар гоҳ ки маҷмӯи додаҳо дорои хусусият ва сифати якхела бошанд, 
 метавонем барои ҳамаи онҳо як ном гузошта, ҳангоми истифодабари он номро 
 барои ҳамаашон истифода кард. Барои ба ҳар як дода дастрас шудан аз зернавис
 (subscript) ва ё индекси он истифода мебарем, яъне ҳамаи элементҳои дорои як
 ном буда, танҳо аз ҳамдигар бо зернависашон фарқ мекунанд. Зернавис аз 
 нуқтаи назари риёзӣ рақами тартибии додаро ифода мекунад. Масалан, дар 
 дафтари синф ҳар як донишҷӯ дорои ном (фамилия ва ном) ва рақами тартибии
 ҷойгиршавии номҳо ме-бошад. Аз нуқтаи назари риёзӣ бигзор ба мо 
 пайдарпайии дода шуда бошад. Дар ин ҷо a-номи массив ва 
 адади дар тарафи рост ва поён навишташуда зернавис ва ё индекс мебошад. 
 Аъзои к-ум гуф та, эле ме н ти дар назар гирифта мешавад. Ин гуна 
 маҷмӯъҳоро дар забонҳои барноманависи массив (array) мегӯянд. Бинобар ин,
 таърифи илмӣ ва пурраи массивро метавонем ба сурати зерин баён кард: 
 Таъриф. Гурӯҳи элементҳои дорои хусусият ва сифати якхелае, ки аз 
 ҳамдигар танҳо бо зернавис фарқ мекунанд, массив номида мешавад. 
 Аз ин ҷо метавонем маҷмӯи элементҳои якҷинсаро ба як ном муаррифӣ 
 кунем. Ба ғайр аз ин, метавонем ҷадвали дорои m-сатр ва n-сутунеро, ки 
 элементҳои он дорои сифати якхела мебошанд, бо як ном муаррифӣ ккунем. 
 Барои дастрасӣ ба элементҳои ин ҷадвал дар тарафи поёнии ҳар як элементи ду
 зернавис, ки яке нишондиҳандаи сатр ва дигаре нишондиҳандаи сутун 
 мебошад, истифода мекунем. Масалан, бигзор ҷадвале дорои n-сатр ва m-сутун
 буда, катакчаҳои он бо додаҳои якҷинса пур карда шуда бошанд. Метавонем 
 барои ҳамаи додаҳои ҷадвал як ном гузорем. Масалан, а ва барои ба ҳар як 
 элемент дастрас шудан, Тавре ки гуфтем, дар тарафи рости қисми поёнии 
 элементҳо ду зернавис менависем, яъне (i=…n ва j=…m). Аз нуқтаи 
 назари риёзӣ, массивҳое, ки як зернавис доранд, вектор ва массивҳое, ду 
 зернавис доранд, матритса мегӯянд. 
 Эълон ва ё муаррифӣ намудани массивҳо 
 (declaration arrays) 
 Тавре ки қаблан зикр кардем, ҳар гуна дода дар забони С++ пеш аз 
 истифодабарӣ муаррифӣ карда мешавад. Массивҳо низ пеш аз истифодабарӣ 
 муаррифӣ карда мешаванд. Як хусусияте, ки барои дигар додаҳо набуда, танҳо
 барои массивҳо хос мебошад, ин андозаи массив аст, ки дар вақти 
 муаррификунии массивҳо нишон дода мешавад. Андоза ва ё мавқеи 
 ҷойгиршавии массив ҳатман дар дохили қавси фигуравӣ «[]» навишта мешавад.
 Наҳви эълони массив ба сурати зерин аст: 
 data_type array_name[array_Size] 
 ё 
 навъи массив номи массив [андозаи массив] 
 Дар ин ҷо data_type-навъи массив (дилхоҳ навъии стандартӣ), array_name-
 номи массив (номи массив бояд монанди дигар тағйирёбандаҳо бо ҳарф сар 
 шавад) ва array_Size бошад, андозаи массивро нишон медиҳад. Массиви дорои
 элементи аз навъи бутун чунин муаррифӣ карда мешавад: int a[]. 
 Зернависи (Индекси) нахустини массив дар забони С++ аз сар шуда, 
 ҳамаи элементҳои массив ба сурати зерин нишон дода мешаванд: 
 Ба сифати зернависи массив метавон танҳо аз адади бутун ва ё ифодае, ки
 натиҷааш адади бутун истифода кард, яъне ифодае, ки аз ададҳои саҳеҳи бутун
 ва тағйирёбандаҳои бутун, ки бо ёрии операторҳои риёзии + ва - ташкил 
 шудааст, метавонад ба сифати зернависи массив истифода шавад. Масалан, 
 массиви дорои элементро низ метавон ба сурати зерин муаррифӣ кард: 
 const int x=,y=; 
 int a[x+y]; 
 Равиши хуби барномасозӣ он аст, ки андозаи массив ҳамчун як адади 
 доимӣ бо ёрии фармони #define ва ё const муаррифӣ гардад. Навъи массив 
 метавонад дилхоҳ навъҳои стандартӣ бошад ва вобаста ба навъи додашуда 
 барои ҳар як элементи массив дар ҳофиза ҷое банд карда мешавад. Масалан, 
 агар массив аз навъи бутун бошад, барои ҳар як элемент ду байт ҳофиза ҷудо
 карда мешавад. Аз ин ҷо барои массиве, ки мо қаблан муаррифӣ кардем байт
 аз ҳофиза банд карда мешавад. 
 Барои ба элементи дилхоҳи массив дастрас шудан аввал номи массив, 
 баъдан пас аз ном зернависи он дар дохили қавси фигуравӣ навишта мешавад.
 Масалан, барои элементи чоруми массиви пештар муаррифӣ кардаамонро ба 
 тағйирёбандаи с бахшидан ифодаи зерин истифода бурда мешавад: 
 Ин ифодаи як нусхаи элементи чоруми массиви а-ро ба тағйирёбандаи с 
 мебахшад. Элементҳои массив аз нол рақамгузорӣ мешаванд аз ин рӯ, б а р о и ба
 элементи k-уми массив дастрас шудан ифодаи зерин лозим аст:. 
 Ба массивҳо бахшидани қимати аввала 
 (initialization arrays) 
 Ҳангоми муаррификунии массивҳо монанди тағйирёбандаҳои оддӣ 
 метавон ба онҳо қимати аввала бахшид. Элементи аввала дар дохили қавси 
 системави «{ }» навишта шуда, барои аз ҳамдигар ҷудо кардани элементҳо 
 оператори коммо истифода бурда мешавад. Мисол: 
 int array[]={,,,,}; 
 char arraychr[]={’R’,’I’,’y’,’o’, ’z’, ’I’}; 
 Дар ин ҷо - дар сатри якум, массиве аз навъи бутун муаррифӣ карда 
 шудааст, ки дорои элементи бутун мебошад ва дар сатри дуввум бошад, 
 массиве аз навъи рамзи муаррифӣгардидааааст, ки андозааш ба баробар 
 мебошад. Массивҳои навъи рамзиро низ метавон ба таври зерин муаррифӣ 
 кард: 
 char arraychr[]={'Riyozi'}; 
 Агар андозаи массив аз шумораи элементҳои он зиёд бошад, ба таври 
 автоматӣ элементҳои боқимондаи массив бо нулҳо пур карда мешаванд, 
 инчунин метавон ҳангоми муаррификунӣ ба ҳамаи элементҳои массив қимати 
 нолӣ бахшид. Ба дастури зерин диққат диҳед: 
 int array[]={}; 
 Агар дар массив ҳангоми муаррификунӣ ҳамаи элементҳои он нишон 
 дода шуда бошанд, ҳоҷати дар дохили қавси фигуравӣ навиш-тани андозаи он 
 нест, аз ин ҷо мисоли болоро метавонем ба сурати зерин низ муаррифӣкард: 
 int array[]={,,,,}; 
 Ба ҳамин монанд ба массивҳои дилхоҳ навъ қимати аввала бахшида 
 мешавад. 
 Дохилкунӣ ва хориҷкунии элементҳои массив 
 Тавре ки қайд кардем, ҳангоми муаррификунӣ метавон ба массив қимати 
 аввала бахшид, вале баъзан зарурат мешавад, ки элементҳои массивро пас аз ба
 кор даромадани барнома монанди тағйирёбандаҳои муқаррарӣ дохил намоем. 
 Ҳангоме ки элементҳои массив ба барнома дохил карда мешаванд, зарурате 
 дидани натиҷаи амалиёти иҷрошуда ба он элементҳо пеш меояд, яъне лозим 
 мешавад, ки натиҷаи барномаро бинем. Дохилкунӣ ва хориҷкунии элементҳои 
 массив монанди тағйирёбандаҳои муқаррарӣ сурат мегирад, вале фарқияташ 
 дар он аст, ки дар массивҳо зернавис низ нишон дода мешавад, яъне элементҳои
 массив аз рӯи шарти гузошташуда дохил ва хориҷ карда мешаванд. 
 Мисол. Барномае нависед, ки аввал элементҳои массивро дохил намуда, 
 Сипас ба намуди зерин хориҷ кунад: 
 Array[]=el; 
 Array[]=el; 
 - - - - - - - - - - - 
 Array[n-]=eln; 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 const int n=; 
 int massiv[n]; 
 int i; 
 for (i=;i<n;i++) 
 cin>>massiv[i]; 
 for (i=;i<=n;i++) 
 cout<<"massiv["<<i<<"]="<<massiv[i]<<endl; 
 return; 
 } 
 Дар ин ҷо андозаи массив ҳамчун як доимии муаррификардашуда ба 
 баробар мебошад, сипас, то замоне ки шарти оператори даврӣ ҳақ аст, аз 
 клавиатура элементҳои массив дохил карда мешаванд. Ҳангоми ба охир 
 расидани давр идоракунӣ ба даври дуюм мегузарад ва то он замоне ки давр 
 дуруст аст, элементҳои дохил намуда хориҷ карда мешаванд. 
 Агар хоҳем, ки элементҳои массив ба намуди сатр хориҷ карда шаванд, он
 гоҳ дар дастури хориҷкунӣ ба ҷои рамзи идоракунии «\n» рамзи «\t» мегузорем,
 ба ғайр аз ин, бо ёрии функсияҳои забони С низ метавонем элементҳои 
 масссивро хориҷ кунем. Ба барномаи зерин диққат диҳед: 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 const int n=; 
 int massiv[]={,,,,}; 
 for (int i=;i<n;i++) 
 printf("massiv[i]=%i\t",massiv[i]); 
 return; 
 } 
 Агар хоҳем, ки элементҳои массив ба намуди сутун хориҷ карда шаванд,
 ҳангоми хориҷкунӣ ба ҷои рамзи идоракунии «\t» рамзи «\n» мегузорем, дар 
 натиҷа сатре, ки дар он фармони хориҷкунӣ омадааст, намуди зеринро мегирад.
 printf(«massiv[i]=%i\n»,massiv[i]); 
 Сумма ва ҳосили зарби элементҳои массив 
 Бигзор ба мо массиви андозааш муайян дода шуда бошад ва талаб карда 
 шавад, ки суммаи элементҳои онро ҳисоб кунед. Барои иҷрои ин амал дар аввал
 тағйирёбандае ба номи Summa муаррифӣ карда, ба он ба сифати қимати аввала
 мебахшем. Баъд аз он, бо ёрии оператори даврӣ ҳар як элементи массивро ба
 он илова мекунем ва дар охир пас аз тамомшавии давр тағйирёбандаи Summa –
 ро ба чоп медиҳем, ки дар он ҳамаи элементҳо гирд оварда шудаанд. Мисол: 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 const int n=; 
 int summa=; 
 int a[]={,,,,}; 
 for (int i=;i<n;i++) 
 summa+=a[i]; 
 cout<<summa<<endl; 
 return; 
 } 
 Ин барномаро метавон бо истифода аз оператори коммо ба намуди зерин 
 низ навишт. Мисол: 
 #include <iostream> 
 #include <cmath> 
 using namespace std; 
 int main(){ 
 const int n=; 
 int summa,i; 
 int a[]={,,,,}; 
 for (summa=, i=;i<n;summa+=a[i],i++); 
 cout<<summa<<endl; 
 return; 
 } 
 Барои зарб намудани элементҳои массив дар аввал тағйирёбандае 
 муаррифӣ мекунем ва ба он ба сифати қимати аввала мебахшем ва баъд ба 
 ёрии оператори даврӣ ҳамаи элементҳои массивро ба қимати тағйирёбандаи 
 мазкур зарб мекунем, дар натиҷа ҳосили зарби элементҳои массив ба даст 
 меоянд. Мисол: 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 const int n=; 
 long int Z; 
 int i; 
 int a[]={-,,,,-}; 
 for (Z=, i=;i<n;Z*=a[i],i++); 
 cout<<"Z="<<Z<<endl; 
 return; 
 } 
 Ба намуди диаграмма тасвир намудани элементҳои массив 
 Элементҳои массивро метавонем ба намуди график, яъне гистограмма низ
 тасвир кард. Вобаста ба миқдори ҳар як элементи массив дар саҳифаи тасвир
 ягон рамз чоп карда мешавад. 
 #include <iostream> 
 #include <iomanip> 
 using namespace std; 
 int main(){ 
 const int n=; 
 int i,j; 
 int a[]={,,,,}; 
 cout<<"Element"<<setw()<<"Qimat" <<setw()<<"histogramma"<<endl; 
 for (i=;i<n;i++){ 
 cout<<setw()<<i<<setw()<<a[i]<<setw(); 
 for(j=;j<a[i];j++) 
 cout<<"*"; 
 cout<<endl; 
 } 
 return; 
 } 
 Тавре ки дида мешавад, дар ин мисол функсияи setw () аз библиотекаи 
 «iomanip.h» истифода бурда шудааст. Функсияи мазкур барои пур намудани 
 саҳифаи тасвир ба ҷои холӣ истифода бурда мешавад, ки дар оянда дар борааш
 пурратар эзоҳ медиҳем. Ду ҳалқаи такрории дигар, ки якеаш барои элементои
 массивро дар саҳифаи тасвир чоп намудан ва дигараш бошад, ба миқдори аз 
 то ҳар як элементи массив дар саҳифаи тасвир рамзи ситорача «*» чоп мекунад.
 Натиҷаи барнома ба сурати зерин аст: 
 Element Qimat histogramma 
 ******************** 
 ******** 
 ************************* 
 ***************** 
 ********** 
 Бо ададҳои тасодуфи пур намудани элементҳои массив 
 Агар массив барои ягон масъалаи санҷишӣ истифода шуда бошад, пас, 
 метавон элементҳои онро аз ададҳои тасодуфӣ пур кард. Барои иҷрои ин амал
 аз функсияи rand() ва ё randomize() истифода бурда мешавад. Дар функсияҳои
 мазкур метавонем ҳудуди болоии массивро нишон диҳем. Масалан, агар талаб 
 карда шавад, ки элементҳои массиверо аз ададҳои тасодуфии аз калон 
 набуда пур кунед, барои ин яке аз операторҳои зерин истифода бурда 
 мешаванд: 
 A[i]=rand()% ё A[i]=random(). 
 Барои массивро аз ададҳои манфӣ пур кардан бошад, ин операторҳо ба 
 суратии зерин истифода бурда мешаванд: 
 A[i]=rand()%- ё A[i]=random()-. 
 Агар ҳудуди болоӣ дар массив нишон дода нашуда бошад, компилятор ба 
 таври ихтиёрӣ аз ададҳои бузург массивро пур мекунад. 
 Мисол. Барномае нависед, ки дар он элементҳои массив ба таври 
 тасодуфӣ интихоб карда шуда бошанд ва дар саҳифаи тасвир нишон дода 
 шаванд. 
 #include <iostream> 
 using namespace std; 
 #define n 
 int main() 
 { 
 int a[n]; 
 for (int i=;i<n;i++){ 
 a[i]=rand()%; 
 cout<<a[i]<<" "; 
 } 
 cout<<endl; 
 return; 
 } 
 Тавре ки мебинед, дар ин ҷо аввал андозаи массив ҳамчун адади доимӣ 
 тавассути роҳнамуни #define муаррифӣ карда шудааст. Дар дохили функсияи 
 асосӣ массиве бо андозаи n муаррифӣгардида, дар дохили ҳалқаи такрорӣаз 
 ададҳои тасодуфӣ пур карда шудааст. Дар дохили ҳалқаи мазкур элементҳои 
 массив дар саҳифаи тасвир ба чоп омода карда шудаанд. Натиҷаи барномаи 
 мазкур намуди зеринро дорад. 
 Ҷустуҷӯи элементи калонтарин ва рақами тартибии он дар массив 
 Масъала: Массиви а дорои n элемент мебошад. Барномае нависед, ки 
 элементи калонтарин ва рақами тартибии онро муайян кунад. 
 Алгоритми ин масъала чунин аст: дар аввал ду тағйирёбандаро ба номи 
 max ва nmax муаррифӣ мекунем ва фарз мекунем, ки элементи аввала 
 калонтарин аст. Элементи мазкурро ба тағйирёбандаи max ва рақами тартибии
 онро ба тағйирёбандаи nmax мебахшем. Баъд аз он max ба элементҳои ояндаи 
 массив муқоиса карда мешавад, агар max аз он бузургтар бошад, ҷойи уро ба
 max иваз мекунем ва агар max аз он элемент хурд бошад, элементи мазкурро ба
 max мебахшем, яъне ба ҷои он элементи max навишта мешавад ва рақами 
 тартибии он ба nmax бахшида мешавад. Ин амалро ба элементҳои боқимондаи 
 массив низ иҷро мекунем. Барои пурратар фаҳмо шудани ин амал онро дар 
 ҷадвали зерин гирд овардем. 
 № 
 Массиви додашуда 
 Қимати max 
 Қимати nmax 
 Барномаи алгоритми ёфтани элементи калонтарин. 
 #include <iostream> 
 using namespace std; 
 int main() 
 { 
 const int n=; 
 int i,j,max,nmax,a[n]; 
 for (i=;i<n;i++) 
 { 
 a[i]=rand()%; 
 cout<<"a["<<i<<"]="<<a[i]<<endl; 
 } 
 for (max=a[],nmax=,i=;i<n;i++) 
 if (max<a[i]) 
 { 
 max=a[i]; 
 nmax=i; 
 } 
 cout<<"\nmax="<<max<<" \n "; 
 cout<<"nmax="<<nmax<<" \n "; 
 return; 
 } 
 Тавре ки дида мешавад, дар ин ҷо элементҳои массив аз ададҳои 
 тасодуфии аз калон набуда, пур карда шудаанд, сипас барнома аз рӯи 
 алгоритми дар боло овардашуда амал намуда, элементи калонтарин ва рақами 
 тартибии онро мебарорад. 
 Равон кардани массив ба функсия ба сифати аргумент 
 Тавре ки қаблан гуфтем, дар забони С++ ҳангоми ба функсия равон 
 кардани аргумент ду роҳ мавҷуд аст: якум, ба ёрии адрес (суроға), дуюм, ба
 ёрии қимат. Элементҳои массивро низ метавонем бо ёрии ин ду роҳ ба функсия
 равон кунем. Дар забони С++ номи массив ҳамчун суроғаи аввалини массив 
 фаҳмида мешавад. Ҳангоми ба функсия равон кардани массив номи массив бе 
 истифодаи қавси фигуравӣ навишта мешавад. 
 Ҳангоми массивҳоро ба сифати аргумунт ба функсия равон кардан номи 
 массив дар функсия бо қавсҳои фигуравӣ навишта шуда, андозаи массив бошад,
 берун аз қавси фигуравӣ, баъди оператори коммо навишта мешавад. Ҳангоми 
 даъват намудани функсия дар функсияи аслӣ номи массив бе қавси фигуравӣ ва
 андозаи массив навишта мешавад. Ин навъ равонкун монанди тағйирёбандаҳои 
 оддӣ фурӯхонӣ ба миқдор (call by value) номида шуда, дар он нусхаи ҳамаи 
 элементҳо ба функсия равон карда мешаванд. Мисол: 
 #include <iostream> 
 #include <iomanip> 
 using namespace std; 
 void modifyArray(int[],int); 
 int main(){ 
 const int n=; 
 int a[n],i; 
 for (i=;i<n;i++){ 
 a[i]=rand()%; 
 cout<<setw()<<a[i]; 
 } 
 cout<<endl; 
 modifyArray(a,n); 
 for (i=;i<n;i++){ 
 cout<<setw()<<a[i]; 
 } 
 return; 
 } 
 void modifyArray(int a[],int n) 
 { 
 for (int i=;i<n;i++) 
 a[i]*=; 
 } 
 Тавре ки дар ин ҷо дида мешавад, дар пешнамунасозии функ-сия ва худи
 функсия номи массив бе истифодаи андозаи он (андозаи он берун аз мавқеи 
 муқаррариаш пас аз оператори коммо) навишта шудааст, яъне void 
 modifyArray(int[],int). Ҳангоми фурӯхонӣ бошад, танҳо ном ва андозаи массив
 бе истифодаи қавсҳои фигуравӣ ба намуди зерин навишта шудааст: 
 modifyArray(a,n); 
 Роҳи дигари равон кардани массив ба функсия. Дар функсия танҳо 
 суроғаи массив нишон дода мешаваду халос. Мисоли гузаштаро метавон ба 
 намуди зерин низ навишт. 
 #include <iostream> 
 #include <iomanip> 
 using namespace std; 
 void arrayprint (int *a,int n){ 
 int i; 
 for(i=;i<n;i++) 
 cout<<a[i]<<" "; 
 } 
 int main() 
 { 
 const int n=; 
 int a[n],i; 
 for (i=;i<n;i++) 
 a[i]=rand()%; 
 arrayprint(a,n); 
 return; 
 } 
 Дар мисоли мавриди назарамон ба функсияи arrayprint (int *a,int n) 
 суроғаи массив нишон дода шудааст, яъне *a ишорагар ба массив мебошад. Дар
 оянда ин матлабро пурратар мавриди баҳс қарор медиҳем. 
 Массивҳои динамикӣ 
 Ба намуди пешфарз ҳангоми муаррифӣ намудани массив дар хотира 
 вобаста ба андозаи он маҳал (ҷой)-е ҷудо карда мешавад. Вале дар баъзе 
 масъалаҳои андозаи массив пешакӣ маълум набуда, дар баъзеи дигарашон 
 ҳангоми иҷро намудани барнома зарурати андозаи массивро тағйир додан пеш 
 меояд, барои ин лозим меояд, ки хотираи динамикиро истифода барем. 
 Ҳангоми массивро аз навъи динамики муаррифӣ кардан дар аввал массив 
 ҳамчун як ишорагар муаррифӣ карда мешавад. Баъд аз дохил намудани андозаи
 массив барои он ҳофиза ҷудо карда мешавад. 
 Ҳангоми ба намуди статикӣ (қарордоди) муаррифӣ намудани массив 
 барои нигоҳ доштани элементҳои массив як блоке аз ҳофиза ҷудо карда 
 мешавад. Агар массив ҳамчун як ишорагар муаррифӣ гардад, он гоҳ, барои он
 чунин ҷой ҷудо (reserve) карда намешавад. Дар натиҷа барои ишорагарро 
 ҳамчун як массив истифода бурдан зарур аст, ки ҳофизае барои элементҳои 
 массив ҷудо карда шавад. Барои ҷудо намудани чунин намуди ҳофиза яке аз 
 роҳҳои зерин истифода бурда мешавад: 
 ) Бо истифода аз функсияҳои malloc, calloc, realloc ва free 
 ) Бо истифода аз операторҳои new ва delete 
 Функсияи malloc як блок ҳофизаро барои нигоҳ доштани объекти 
 нишондодашуда ҷудо (reserve) намуда, ба катакчаи якуми он блок ишорагар 
 бармегардонад. Наҳви истифодабарии ин функсия намуди зеринро дорад: 
 void *malloc(size) 
 Дар ин ҷо size -андозаи ҳофизаи ҷудоrfhlfielfро ба ҳисоби байт ифода
 мекунад. Агар ҷудо намудани ҳофиза бомуваффақият анҷом пазирад, он гоҳ ин
 тобеъ тағйирёбандаи навъи *void–ро бармегардонад. Дар ҳолати акс бошад, 
 қимати Null бармегардонад. 
 Мисол. Бигзор, мо мехоҳем массиве аз навъи бутун бо номи а, ки дорои n
 элемент мебошад, эълон кунем. Дар аввал онро ҳамчун ишорагаре ба сурати 
 зерин муаррифӣ мекунем: int *a; 
 Дар ин равиш ҳофиза ҷудо карда намешавад, пас аз дохил кардани n 
 барои ҷудо намудани ҳофиза аз функсияи malloc ба сурати зерин истифода 
 мебарем: 
 a=malloc (n*sizeof(int)); 
 Ин оператор як блок ҳофизаро барои нигоҳ доштани элементи массив 
 ҷудо мекунад. Дар ин ҷо оператори sizeof() андозаи навъи int-ро бо ҳисоби байт
 баргардонида, онро ба миқдори элементҳои массив зарб мезанад. Аз ин ҷо 
 ҳофизаи мавриди назар ҷудо (reserve) карда мешавад. Тағйирёбандаи a аз навъи
 бутун муаррифӣ карда шудааст ва тобеъи malloc бошад, ишорагари рамзӣ 
 бармегардонад. Аз сабаби он ки дар забони С/С++ рамзҳо низ ҳамчун адади 
 бутун фаҳмида мешаванд, пас, оператори дар боло истифодабурдаамон қобили 
 қабул аст. 
 Барои бо боварии комил истифода бурдани тобеъи мазкур хубтар аст, ки
 дар дохили он амали табдилдиҳии навъ (cast)-ро низ истифода барем. Аз ин ҷо
 оператори дар боло навиштаамон намуди зеринро мегирад: 
 a=(int *) malloc (n*sizeof(int)); 
 Функсияи calloc низ барои ҷудо намудани ҳофизаи динамикӣ истифода 
 бурда мешавад. Наҳви умумии он намуди зеринро дорад: 
 void * calloc (num, size) 
 Функсияи мазкур барои ба массиви num ба андозаи size ҷудо намудани 
 ҳофиза хизмат мекунад. Агар амали ҷудо намудани ҳофиза бо муваффақият 
 анҷом гирад, он гоҳ ин функсия ба мавқеи ҷудокардашудаи ҳофиза ишорагар 
 бармегардонад. Дар акси ҳол бошад, қимати Null бармегардонад. 
 Функсияи realloc бошад, андозаи ҳофизаи пештар ҷудокардашударо 
 метавонад тағйир диҳад. Наҳви умумии ин функсия намуди зеринро дорад: 
 char *realloc (void *p, size) 
 Дар ин ҷо p -ишорагар ба мавқеи ҳофизаест, ки бояд ба андозаи size 
 тағйир дода шавад. Агар ҳангоми иҷроиши функсияи мазкур суроғаи мавқеи 
 ҳофиза тағйир дода шавад, он гоҳ суроғаи нав ба сифати натиҷа баргардонида
 мешавад. Агар қимати параметри якум Null бошад, он гоҳ ин функсия монанди
 функсияи malloc кор карда, ба андозаи size ҳофизаро ҷудо мекунад. 
 Барои озод намудани ҳофизаи ҷудокардашуда аз функсияи free() 
 истифода бурда мешавад. Наҳви умумии ин функсия намуди зеринро дорад. 
 void free (void *p) 
 Дар ин ҷо p ба он мавқеи ҳофизае ишорат мекунад, ки пештар тавассути
 функсияҳои malloc, calloc ва ё realloc ҷудо карда шудааст. 
 Роҳи дигари ҷудо кардани ҳофизаи динамикӣ истифода аз оператори new 
 мебошад. Барои аз ин оператор истифода бурдан дар аввал массив ҳамчун як 
 ишорагар муаррифӣ карда шуда, сипас андозаи он бо ёрии оператори new 
 муайян карда мешавад. Мисол: 
 int n, *a; 
 …. 
 a=new int[n]; 
 Дар ин ҷо тавре ки дида мешавад, дар сатри якум ду тағйирёбандаи бутун,
 ки якеаш аз навъи ишорагар буда, номи массивро ифода мекунад, муаррифӣ 
 карда шудааст. Баъдан бо ёрии оператори new андозаи тағйирёбандаи 
 ишорагар нишон дода шудааст. Андозаи массивро ҳангоми иҷроиши барнома аз 
 берун низ дохил кардан мумкин аст. Барои озод намудани хотира бошад, аз 
 оператори delete [] истифода бурда мешавад. 
 Илова ва нест намудани элемент дар массив 
 Бигзор массиве дорои n –элемент дода шудааст. Талаб карда мешавад, ки
 элементи k-уми он нест карда шавад. Бигзор, k рақами тартибии ягон элементи
 бошад, он гоҳ элементҳои массив чунин тағйир меёбанд: элементи k+-ум 
 ҷойи элементи k-ум ва элементи k+m -ум ҷойи элементи k+m--умро ишғол 
 мекунад. Барои хубтар шинос шудан ва дарк намудани ин матлаб, ҳамаи 
 элементҳои массивро дар дохили як ҷадвал ба сурати зерин тасаввур мекунем:
 k k+ k+ k+ n- n- 
 Бо суханҳои дигар элементи k--ум сарфи назар шуда, аз элемент k-ум 
 сар карда, ҳар як элемент як мавқеъ ба тарафи чап кӯчонида мешаванд. Дар 
 натиҷа элементҳои массив n- то мешаванд. 
 Матни барнома: 
 #include <iostream> 
 using namespace std; 
 int main() 
 { 
 int i,k; 
 int n,*a; 
 cout<<"n=";cin>>n; 
 cout<<"k=";cin>>k; 
 a=new int [n]; 
 for (i=;i<n;i++){ 
 a[i]=rand()%; 
 cout<<"a["<<i<<"]="<<a[i]<<endl; 
 } 
 cout<<endl; 
 for (i=k;i<n-;i++) 
 a[i]=a[i+]; 
 n--; 
 for (i=;i<n;i++) 
 cout<<"a["<<i<<"]="<<a[i]<<endl; 
 delete []a; 
 return; 
 } 
 Барои нест кардани элементе ё элементҳо аз массив, метавон аз 
 функсияҳо низ истифода бурд. 
 Мисоли. Барномае нависед, ки нахустин элементи манфии массиви 
 додашуда нест кунад. 
 #include <iostream> 
 using namespace std; 
 const int n=; 
 int a[n]; 
 void shiftLeft(int pos, int m, int dsp, int *a) 
 { 
 for(int i=pos; i<n-dsp;i++) 
 a[i]=a[i+dsp]; 
 m-=dsp; 
 } 
 int main() 
 { 
 int i, j=; 
 int a[n]; 
 cout<<"massivi dodashuda:\n"; 
 for (i=;i<n;i++){ 
 a[i]=rand()%-; 
 cout<<a[i]<<" "; 
 } 
 cout<<"\nmassiv pas az nest kardani elementho:"<<endl; 
 while(j<n && a[j]>) 
 j++; 
 if (j<n) 
 shiftLeft(j,n,,a); 
 for (i=;i<n-;i++) 
 cout<<a[i]<<" "; 
 cout<<endl; 
 return; 
 } 
 Дар ин ҷо аргументи якуми функсия мавқеъ ё рақами тартибии 
 элементеро, ки бояд аз массив нест карда шавад, ифода намуда, аргументи 
 дуввум андозаи массивро нишон медиҳад. Аргументи саввум миқдори 
 элементҳои нестшавандаро нишон медиҳад ва аргументи охирон ишорагар ба 
 массив мебошад. Дар функсияи аслӣ ҳалқаи такрории while() барои дастрас 
 шудан ба рақами тартибии элементи мавриди назар истифода шудааст. 
 Натиҷаи барнома шакли зеринро дорад: 
 massivi dodashuda: 
 - - - 
 massiv pas az nest kardani elementho: 
 - - 
 Ба ҳамин монанд функсияе барои ба массив гузоштани элемент метавон 
 таъриф кард. 
 Мисоли. Барномае нависед, ки пас аз элементи якуми мусбати массив 
 адади -ро гузорад. 
 #include <iostream> 
 using namespace std; 
 const int n=; 
 int a[n]; 
 void shiftRight(int pos, int m, int dsp, int *a){ 
 for(int i=m; i>=pos;i--) 
 a[i+dsp]=a[i]; 
 m+=dsp; 
 } 
 int main(){ 
 int i, j=; 
 int a[n]; 
 cout<<"massivi dodashuda:\n"; 
 for (i=;i<n;i++){ 
 a[i]=rand()%-; 
 cout<<a[i]<<" "; 
 } 
 cout<<"\nmassiv pas az nest kardani elementho:"<<endl; 
 int k=; 
 while((k<n) && (a[k]>=)) 
 k++; 
 if (k<n) { j=k; 
 shiftRight(k,n,,a); 
 a[j+]=; 
 } 
 for (i=;i<=n;i++) 
 cout<<a[i]<<" "; 
 cout<<endl; 
 return; 
 } 
 Ин барнома низ монанди барномае пешина буда, фақат баръакси он амал 
 мекунад. 
 Массивҳо аз сатрҳои матнӣ 
 Мо то ҳоло ба массивҳое, ки элементҳои он аз навъи шуморишӣ (ададӣ) 
 будаанд, сарукор гирифтем. Илова бар ин, элементҳои массив метавонанд 
 дилхоҳ навъи стандартӣ бошанд. Ҳоло массивҳоеро дида мебароем, ки 
 элементҳои он сатрҳо (риштаҳо) мебошанд. 
 Дар забони С++ сатрҳо ҳамчун массивҳои рамзӣ шинохта шуда, охири ҳар
 сатр бо рамзи Null (охири сатр ) ба поён мерасад. Дар дохили барнома рамзи
 мазкур дар қолаб (форма)-и escape squance бо ‘\’ нишон дода мешавад. 
 Индексии поёнии элементҳои як массив аз навъи сатрҳо буда, индекси болоӣ
 якто кам аз миқдори рамзҳои ҳамон сатр мебошад. Масалан, сатри «Hello 
 world» як массиви рамзии дорои рамз мебошад. Дар ин навъ массивҳо ҷойи
 холӣ низ ҳамчун як элемент фаҳмида мешавад. Ба массивҳои сатрӣ низ дар 
 вақти муаррифӣ кардан метавон қимати авввала бахшид. Масалан: 
 char Arsatr[]=”Hello World”; 
 Массиви муаррифишуда дорои элемент мебошад. Инчунин массивҳои 
 сатриро метавонанд ҳар як элементашон алоҳида бошанд. Масалан: массиви 
 болоро метавонем ба сурати зерин низ таъриф кард: 
 char Arsatr[]={‘H’,’e’,’l’,’l’,’o’,’\‘,’W’,’o’,’r’,’l’,’d’}
 Тавре ки дида мешавад, дар ин ҷо ҳар як элементи массиви рамзӣ дар 
 дохили нохунаки якто-якто навишта шуда, барои ҷойи холӣ (фосила) рамзи ’\‘
 истифода шудааст ва оператори коммо барои аз ҳамдигар ҷудо намудани 
 рамзҳо ба кор рафтааст. Барои дар ин навъ массивҳо ба элементи зарурӣ дастрас
 шудан, аз номи массив ва зернависи (рақами тартиби)-и элементи мавриди 
 назар истифода бурда мешавад. 
 Монанди дигар массивҳо зернависи элементҳои массиви рамзӣ низ аз нол
 оғоз ёфта, ба n- ба охир мерасад, яъне дар массиви мазкур элементи нолум ин
 рамзи (ҳарфи ) «H» буда элементи n- (-)-ум рамзи «d» мебошад. 
 Мисол. Барномае нависед, ки ҳамаи элементҳои массиви Arsatr[]-ро ба 
 чоп диҳад. Инчунин элементи аввалин ва охиринашро низ ба чоп диҳад. Мисол:
 #include <iostream> 
 using namespace std; 
 int main(){ 
 const int n=; 
 cout<<"Massivi dodoshuda="; 
 char Arsatr[]={’H’,’e’,’l’,’l’,’o’,’\’,’W’,’o’,’r’,’l’,’d’}; 
 for (int i=;i<n;i++) 
 cout<<Arsatr[i]; 
 cout<<endl; 
 cout<<"Elementi yakum="<<Arsatr[]<<"\nElementi duyum="<< 
 Arsatr[]<<endl; 
 return; 
 } 
 Чи хеле ки мебинем, дар ин ҷо аввал доимие муаррифӣ шуда аст, пас аз он
 массив бо элементҳои аввалааш таъриф шудааст. Ҳалқаи такрорӣто замони 
 элементҳои массив ба охир расидан давр зада, дар ҳар итератсия як элементи
 массивро бо ёрии оператори хориҷкунӣ ба саҳифаи тасвир равон мекунад 
 (менависад). 
 Тавре ки гуфтем, дар оператори хориҷкунӣ ифодаи Arsatr[] ва ифодаи 
 Arsatr[n-] нишондиҳандаи элементҳои аввалин ва охирони массив буда, 
 элементҳои мазкурро ба саҳифаи тасвир пешниҳод мекунанд. Натиҷаи барнома 
 шакли зеринро дорад: 
 Massivi dodoshuda= 
 Elementi yakum=H 
 Elementi duyum=e 
 Дар вақти муаррификунӣ метавонем танҳо андозаи массивро нишон дода, 
 элементҳои онро аз клавиатура дохил кунем. Масалан, бигзор массиве бо номи
 name [] ки андозааш ба баробар аст, ба сурати зерин муаррифӣ карда шуда
 бошад: char name[]; 
 Барои элементҳои массиви мазкурро тавассути дастури дохилкунии cin аз
 клавиатура дохил намудан андозаи массив навишта намешавад. 
 Мисол. Барномае нависед, ки дар он номи як нафар донишҷӯй аввал аз 
 клавиатура дохил карда шуда, Сипас ба чоп дода шавад. 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 const int n=; 
 cout<<"Enter you name\n"; 
 char name[n]={}; 
 cin>>name; 
 for (int i=;i<n;i++) 
 cout<<name[i]; 
 cout<<endl; 
 return; 
 } 
 Ҳангоми аз клавиатури ворид кардани массиви рамзӣ объекти cin то 
 расидан ба рамзи фосила сатри додашударо мехонаду халос. Дар оянда дар ин
 бора эзоҳи пурратар медиҳем. 
 Мураттабсозӣ ва ҷустуҷӯии элементҳо дар массив 
 Мураттабсозӣ ва ҷустуҷӯи элементе дар дохили як маҷмӯъ дар аксар 
 ҷойҳо, ба хусус дар системаҳои иттилоотии ҷустуҷӯӣ, тиҷоратӣ, ёфтани луғат
 аз фарҳанг, ёфтани китоб аз китобхона ва ғайра корбурди зиёде дорад. Мақсади
 асосии мураттабсозӣ (sorting) ба тартиб аз рӯи қоидаи муайяне (аз рӯи алифбо,
 ё зиёдшавии қимат) гузоштани додаҳо (дар массив элементҳо) мебошад, ки он
 ҷустуҷӯи элементи заруриро осон мекунад. Чунончи агар додаҳо аз аз рӯи 
 қоидаи муайяне дастабандӣ нашуда бошанд, ёфтани як унсури муайяне дар 
 дохили додаҳои душвор ҳатто имконнопаз мегардад. Биёед, фарҳанг 
 (dictionary)-ро ки дар он луғатҳои зиёде мавҷуданд, пеши назар меорем. Агар
 дар фарҳанг калимаҳо аз рӯи алифбо ҷобаҷо нашуда бошанд, барои ҷустуҷӯи 
 калимаи мавриди ниёз чи қадар вақт беҳуда сарф мешавад, яъне барои ёфтани
 он калима зарур мешавад, ки ҳамаи саҳифаҳои фарҳангро аз назар гузаронем.
 Пас, барои сареътар ва осонтар дастрас шудан ба калимаи мавриди ниёз агар
 дар фарҳанг калимаҳо аз рӯи алифбо ҷобаҷо шуда бошанд, танҳо саҳифаи 
 лозимиро мебинему бас. Пас, биёед аввал алгоритмҳои мураттабсозӣ ва баъд 
 алгоритмҳои ҷустуҷӯиро дида мебароем. 
 Гурӯҳбандии равишҳои мураттабкунӣ 
 Алгоритмҳои мураттабсозии элементҳои массив ба ду гурӯҳ ҷудо карда 
 мешаванд: 
 ) Мураттабсозии дохилӣ (internal sort)-ки дар он ҳамаи додаҳо дар 
 хотираи компютер қарор дода мешаванд. 
 ) Мураттабсозии хориҷӣ( external sort), ки дар он додаҳои мавриди назар
 дар ҳофизаҳои бегона (аҷнаби) монанди навор ё саҳифаҳо қарор доранд, ки 
 барои ин гуна додаҳо истилоҳи файл (File) ба кор бурда мешавад, ки он дар
 мавзӯҳои оянда мавриди баҳс қарор мегирад. 
 Мураттабсозии дохилӣ аз рӯи алгоритм ё равишҳои зерин амали карда 
 мешавад: 
 ) bubble sort 
 ) sheel sort 
 ) tos sort 
 ) selection sort 
 ) insertion sor 
 ) quick sort 
 ) merge sort 
 ) binary tree sort 
 ) heop sort 
 ) rabix sort (bucket sort) 
 Мураттабсозии ҳубобӣ (buble sort) 
 Яке аз содатарин равишҳои мураттабсозӣ мураттабсозии ҳубо-бӣ 
 мебошад, агарчанде ки дар муқоиса нисбат ба равишҳои дигар ҷойи поёнтареро
 ишғол мекунад, вале хело сода буда, ба истифодабаранда фаҳмо мебошад. 
 Вожаи bubble мафҳуми илмӣ набуда, танҳо дар луғат ба маънои ҷушидан ва 
 ғулғула кардан омадааст. Вақте ки зарфи обро ҷӯшонидем, ҳубобчаҳои ҳаво, ки
 дар об мавҷуданд, дар сатҳи об ҳаракат мекунанд. Дар равиши мазкур элементи
 калонтарин ба ҳубобчаҳои зарфи об монанд ҳар маротиба ба самти боло ё 
 интиҳо ҳаракат мекунад. Аз ин ҷост, ки ин навъ мураттабсозиро мураттабсозии
 ҳубобӣ номидаанд. 
 Дар равиши мураттабсозии мазкур элементи якум ба элементи дуввум 
 муқоиса карда мешаванд, агар узви якум аз дуюм калонтар бошад, ҷойи онҳо 
 иваз карда мешавад. Сипас, ин амал дар мавриди элементи дуюм бар сеюм ва 
 ҳамин тариқ барои элементҳои боқимонда сурат мегирад, яъне дар охир 
 элементи n--ум бо элементи n-ум муқоиса карда мешавад, агар элементи n- –
 ум аз элементи n-ум калон бошад, ҷояшон иваз карда мешавад. Вақте ки ин 
 амал як маротиба иҷро карда шуд, элементи калонтарин дар охир қарор 
 мегирад. Акнун фарз мекунем, ки элементи n-уми массив вуҷуд надорад. Амали
 пештар иҷро кардаамонро ба (n-) элементи боқимонда якбор иҷро карда, 
 элементи калонтаринро дар ҷойи (n-)-ум қарор медиҳем. Агар ин амалро (n-)
 маротиба такрор карда, ҳар маротиба як хонаро нодида гирем, дар охир 
 элементҳои массив ба тартиби зиёдшавиашон ба намуди зерин ҷобаҷо карда 
 мешаванд: 
 a[] a[] a[] … a[n-] 
 Агар хоҳем, ки элементҳои массив бо тартиби камшавиашон 
 (отсортир овать ) ҷойг ир карда шаванд. Ҳангоми муқоисакунӣҷойи элементи 
 хурдтаринро аз мавқеи a[i-] ба a[i] баръакси равиши боло иваз мекунем. Дар
 ин сурат элементҳои массив ба сурати зерин ҷобаҷо карда мешаванд. 
 a[] a[] a[] … a[n-] 
 Мисол. Барномае нависед, ки элементҳои массиви додашударо аз рӯи 
 равиши ҳу боби б о тарт иби зиёдшавиашон ҷобаҷо гузорад. 
 #include <iostream> 
 using namespace std; 
 int main() 
 { 
 const int n=; 
 int a[n]; 
 int i,b,j; 
 cout<<" Elementhoi massiv pesh az jobajoguzori"<<endl<<endl; 
 for (i=;i<n;i++) 
 { 
 a[i]=rand()%; 
 cout<<a[i]<<" "; 
 } 
 cout<<endl; 
 for (j=;j<n;++j) 
 for (i=;i<n-j;++i) 
 if (a[i]>a[i+]) 
 { 
 b=a[i]; 
 a[i]=a[i+]; 
 a[i+]=b; 
 } 
 cout<<endl; 
 cout<<" Elementhoi massiv pas az 
 jobajoguzori"<<endl<<endl; 
 for (i=;i<n;i++) 
 cout<<a[i]<<" "; 
 cout<<endl; 
 return; 
 } 
 Дар ин ҷо аввал массиве аз навъи бутун, ки дорои n (n=) элемент 
 мебошад, муаррифӣ карда шудааст. Баъд элементҳои массив аз ададҳои 
 тасодуфи пур карда шуда, бо ёриии оператори хориҷкуни ба хориҷ карда 
 шудаанд. Сипас ду давр истифода шудааст, даври якум шароит фароҳам 
 меоварад, ки (n-)-маротиба барои ҳар як элементи массив амали муқоисакуни
 иҷро карда шавад. Дар аввал элементи якум ( бо индекси ) бо элементи дуввум
 муқоиса карда мешавад. Агар он аз элементи дуввум калон бошад, қимати он ба
 тағйирёбандаи ёрирасони b бахшида мешавад. Сипас элементи элементи a[i] ба
 элементи a[i+] иваз карда мешавад, ки дар натиҷа тағйирёбандаи b аз қимат
 холи мешавад ва элементи a[i+] бошад, қимати худро ба тағйирёбандаи b 
 мебахшад ва ҳоказо. Тавре ки дар боло гуфтем, элементҳои массив ҷобаҷо 
 карда мешаванд. Баъди иҷрои амалҳои мазкур элементҳои массив бори дигар ба
 сурати зерин хориҷ карда мешаванд. 
 Elementhoi massiv pesh az jobajoguzori 
 Elementhoi massiv pas az jobajoguzori 
 Мураттабсозӣ бо равиши интихоб (selection sort) 
 Моҳияти ин навъ мураттабсозӣ аз он иборат аст, ки дар миёни элементҳои
 массив элементи калонтарин ҷустуҷӯ карда шуда, ҷойи он ба элементи охирон
 иваз карда мешавад. Баъд аз он фарз карда мешавад, ки элементи n-ум вуҷуд
 надорад ва аз байни (n-)-элементи боқимонда калонтаринаш ҷустуҷӯ карда 
 мешавад, ҳангоми ба даст омадани он ҷояш бо элементи (n-)-ум иваз карда 
 мешавад. Амали мазкур n- маротиба такрор карда мешавад. Дар охир танҳо ду
 эле-мент якум ва дуюм боқӣ мемонанд, ки аз онҳо калонтаринашро ба хо-наи 
 дуввум ҷой дода мешавад. Ба ҳамин тариқ, элементҳои массив ҷо-баҷо карда 
 мешаванд. 
 Бартарии ин равиш назар ба равиши ҳубобӣ аз он аст, ки дар ин навъ 
 мураттабсозӣ ҷойивазкунии элементҳо камтар ба амал меояд, зеро дар ин равиш
 дар ҳар такрор фақат як маротиба ҷойивазкунӣ ба амал меояд. 
 Мисол: Барномаи усули ҷобаҷогузории интихоб. 
 #include <iostream> 
 #include <iomanip> 
 using namespace std; 
 int main(){ 
 const int n=; 
 int i,j,max,b,name; 
 int a[n]; 
 cout<<"Elementhoi massiv pesh az jobajoguzori"<<endl<<endl; 
 for (i=;i<n;i++){ 
 a[i]=rand()%; 
 cout<<a[i]<<" "; 
 } 
 cout<<endl; 
 for (j=;j<n;b=a[n-j],a[n-j]=a[name],a[name]=b,j++) 
 for (max=a[],name=,i=;i<=n-j;i++) 
 if(a[i]>max) 
 { 
 max=a[i]; 
 name=i; 
 } 
 cout<<endl; 
 cout<<" Elementhoi massiv pas az 
 jobajoguzori"<<endl<<endl; 
 for (i=;i<n;i++) 
 cout<<a[i]<<" "; 
 cout<<endl; 
 return; 
 } 
 Мураттабсозии гузориши (insertion sort) 
 Бигзор массиви а дорои n элемент бошад, яъне. Барои ба 
 тартиб гузоштани элементҳои массиви мазкур дар аввал ду элементро мегирем,
 яъне ва фарз мекунем, ки онҳо мурат-табанд, б аъ д а з о н, аъзои сеюм,
 яъне -ро интихоб карда, онро нисбат ба ду аъзои аввала дар ҷойи муносибе
 мегузо ре м, ки маҷмӯи дорои се элемент мураттаб ҳосил гардад. Ба ҳамин 
 монан д то элементи n-ум давом дода мешавад, ки дар охир ҳамаи элементҳои
 массив ҷобаҷо карда мешаванд. Барои ин матлабро пурратар дида баромадан 
 биёед массиви дорои -элементро дида мебароем. Мисол: 
 Элементҳои массиви дода шуда: - ->,,,; 
 Қадами: - ->,,,; 
 Қадами: --->,,,; 
 Қадами: -->,,,; 
 Тавре ки дида мешавад, барои мураттабсозии чор элементи массив - 
 итератсия истифода карда шудааст. Барои пурратар фаҳмо шудан, массиви 
 дорои элементро пеши назар меорем ва фарз мекунем, ки элементи он 
 мураттаб шуда, элементи шашуми аз эле-менти чорум хурд (ё баробар ) аст. Ба
 тағйирёбандаи иловагие элемен-ти шашумро бахшида, баъд онро дар ҷойи 
 чорум қарор медиҳем. Ба ҳамин монанд ҳар як элементҳои номураттаби массив
 ба элементҳои ҷойи муносиб иваз карда мешаванд. Дар ҷадвали поён ин равиш
 овар-да шудааст. 
 Мисол: Барномаи усули муратабку нии гузориш навишта шавад. 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 const int n=; 
 int i,j,max,b,name; 
 int a[n]; 
 cout<<" Elementhoi massiv pesh az jobajoguzori"<<endl<<endl; 
 for (i=;i<n;i++) { 
 a[i]=rand()%; 
 cout<<a[i]<<" "; 
 } 
 cout<<endl<<endl; 
 for (i=;i<n;a[j+]=b,i++) 
 for (b=a[i],j=i-;(j>- && b<a[j]);a[j+]=a[j],j--); 
 cout<<" Elementhoi massiv pas az jobajoguzori"<<endl<<endl; 
 for (i=;i<n;i++) 
 cout<<a[i]<<" "; 
 cout<<endl; 
 return; 
 Мураттабсозии tag (tag sort) 
 Чанде қабл мо алгоритми мураттабсозиеро ба номи мурат-табсозии 
 ҳубобӣ дида баромада будем. Акнун фарз мекунем, ки мас-сиви дорои андозаи
 бузург дода шуда бошад. Масалан, дорои млн. элемент барои ҳар як 
 элементро муқоиса намудан вақти зиёд сарф мешавад. Барои ин навъ массивҳо
 ва массивҳоеро ки элементҳои онҳо сатрҳо, рамзҳо ва сохторҳо мебошанд, 
 равиши нави мураттабсозиро ба намуди tag sort истифода мешавад. Моҳияти ин
 усул аз он иборат аст, ки як массиви нав муаррифӣ карда шуда, дар он ба 
 сифати элемент массиви аввала қарор дода мешаванд. Сипас, дар ҳар куҷое, ки
 ҳоҷати ду элементро ба ҳамдигар муқоиса намудан пеш ояд, ин амал хело сода
 анҷом мегирад, зеро ба ин усул андозаи массив хурд карда мешавад. Мантиқи
 кори равиши мазкур ҳам монанди равиши ҳубобӣ мебошад. Мисол: 
 #include <iostream> 
 using namespace std; 
 int main() 
 { 
 const int n=; 
 int i,j,k; 
 int a[n],b[n],x; 
 cout<<"Elementhoi massiv pesh az jobajoguzori"<<endl<<endl; 
 for (i=;i<n;i++){ 
 a[i]=rand()%; 
 cout<<a[i]<<" "; 
 } 
 cout<<endl<<endl; 
 for (k=;k<n;++k) 
 b[k]=k; 
 for(i=;i<n;i++) 
 for(j=;j<n-i;j++) 
 if(a[b[j]]>a[b[j+]]) 
 { 
 x=b[j]; 
 b[j]=b[j+]; 
 b[j+]=x; 
 } 
 cout<<"Elementhoi massiv pas az 
 jobajoguzori"<<endl<<endl; 
 for (i=;i<n;i++) 
 cout<<a[b[i]]<<" "; 
 cout<<endl; 
 return; 
 } 
 Мураттабсозии босуръат ё зуд (quick sort) 
 Бигзор элементҳои массив ба сурати ҷадвале бузурге дода шуда бошанд.
 Барои онҳоро мураттаб намудан равиши наве бо номи мураттабсозии 
 босуръатро дида мебароем. Моҳияти ин навъ мурат-табсозӣ аз он иборат аст, ки
 аввал як элементро аз ҷадвали додашуда интихоб намуда, элементҳои 
 боқимондае, ки аз он калонанд, дар тарафи рости он ва элементҳои 
 боқимондаро бошад, дар тарафи чапи он қарор медиҳем. Дар натиҷа ҷадвали мо
 ба ду ҷадвал тақсим карда мешавад. Амали мазкурро бо он ҷадвалҳо низ иҷро
 мекунем, ки дар натиҷа ҷадвалҳои нав ҳосил карда мешаванд. Ин амалро то 
 замоне иҷро мекунем, ки элементҳои ҷадвал ба таври зиёдшавиашон ҷо ба ҷо 
 гузошта шаванд. 
 Элементе, ки дар ибтидо мо интихоб кардем, шояд баъзе хонандагони 
 арҷманди мо дар бораи чи тавр интихоб кардани он суол кунанд. Дар аввал 
 ҷадвалро ба намуди уфуқӣ тасаввур карда, хонаи аввал ё самти чапи онро бо L
 ва хонаи охир ё самти рости онро бо К ишора мекунем, яъне 
 Ду тағйирёбандаи i ва j интихоб намуда, тағйирёбандаи i-ро ба L ва 
 тағйирёбандаи j-ро ба R баробар қарор дода, элементи миёнаро чунин интихоб
 мекунем. 
 Баъд аз он то замоне (мавқеъе), ки a [i] <x ва i<R будан, тағйир-ёбандаи i-
 [ ] 
 ро ба тарафи рост ҳаракат медиҳем. Ин ам алро барои тағйирёбандаи j низ иҷро
 мекунем, яъне то замони a[j]>x будан тағйирёбандаи j-ро ба тарафи чап ҳаракат
 медиҳем, баъд аз он, ҷойи a[i]-ро ба a[j] иваз мекунем, сипас ба тағйирёбандаи i
 як воҳид илова намуда, аз тағйирёбандаи j як воҳид кам мекунем ва то замони
 -шудан ин амал такрор карда мешавад. Элементе, ки ба сифати элементи 
 мобайнӣ интихоб намуда, будем онро дар дохили ҷадвал ҳаракат дода, дар охир
 да р ҷойи худ қарор медиҳем. Ба ҳамин тариқ, элементҳои аз он хурдбуда дар
 тарафи чапи он ва элементҳои аз он калон буда дар тарафи росташ қарор 
 мегиранд. Дар натиҷа, элементҳои массив мураттаб карда мешаванд. 
 Мисол. Барномае нависед, ки элементҳои массиви додашударо ба равиши 
 мураттабсозии босуръат (quick sort) мураттаб намуда, дар функсияи аслӣ ба
 чоп диҳад. 
 #include <iostream> 
 using namespace std; 
 void QuickSort(int a[],int avval,int ohir); 
 int main() 
 { 
 const int n=; 
 int i,j,avval=,ohir=n-,x,k,t; 
 int a[n],b[n]; 
 cout<<"Elementhoi massiv pesh az jobajoguzori"<<endl<<endl; 
 for (i=;i<n;i++) 
 { 
 a[i]=rand()%; 
 cout<<a[i]<<" "; 
 } 
 cout<<endl<<endl; 
 QuickSort(a,,n-); 
 cout<<"Elementhoi massiv pas az jobajoguzori"<<endl<<endl; 
 for (i=;i<n;i++) 
 cout<<a[i]<<" "; 
 cout<<endl; 
 return; 
 } 
 void QuickSort(int a[],int avval,int ohir) 
 { 
 int i=avval; 
 int j=ohir; 
 int t, x; 
 x=a[(avval+ohir)/]; 
 while (i<=j) 
 { 
 while(a[i]<x && i<ohir) 
 i++; 
 while( a[j]>x && j>avval) 
 j--; 
 if(i<=j) 
 { 
 t=a[i]; 
 a[i]=a[j]; 
 a[j]=t; 
 i++; 
 j--; 
 } 
 if (j>avval) 
 QuickSort(a,avval,j); 
 if(i<ohir) 
 QuickSort(a,i,ohir); 
 } 
 } 
 Ҷустуҷӯ кардан( searching) 
 Баъзан лозим меояд, ки дар дохили маҷмӯе аз элементҳо элементеро 
 ҷустуҷӯ кунем. Масалан, ҷустуҷӯи калима дар фарҳанги луғат. Барои онро ба
 даст овардан ҷойи лозимии фарҳангро ҷустуҷӯ мекунем. Барои ба таври 
 электронӣ ҷустуҷӯ кардан якчанд алгоритм ё роҳҳое мавҷуд аст, ки онҳо ба мо
 имконият медиҳанд, ки аз дохили маҷмӯъ элементи лозимиро дарёфт намоем. 
 Алгоритмҳои асосии ҷуcтуҷӯи инҳо мебошанд: 
 ) Ҷуcтуҷӯи хатти(liner search) 
 ) Ҷуcтуҷӯи равиши дӯӣ (binary search) 
 ) Тасодуфӣ 
 Ҷуcтуҷӯи хаттӣ 
 Яке аз роҳҳои содатарини ҷуcтуҷӯи элементе дар дохили массив ё ҷадвали
 номураттаби додаҳо он аст, ки элементи мавриди назарро ба элементҳои якум,
 дуюм ва ҳоказо n-ум муқоиса мекунем, агар ба ягон элементи маҷмӯъ баробар
 бошад, он гоҳ шумораи онро ба хотир гирифта, ба амали ҷуcтуҷӯӣ хотима 
 мебахшад. Ва дар ҳолати акс пайғоми муносибе чоп мегардад. 
 #include <iostream> 
 using namespace std; 
 int Hatti_search(int a[],int n,int x) 
 { 
 int i; 
 for (i=;i<n;i++) 
 if (x==a[i]) 
 return a[i]; 
 return; 
 } 
 int main() 
 { 
 const int n=; 
 int i,search_key; 
 cout<<"search_key=";cin>>search_key; 
 int a[n]; 
 cout<<"\nElemenhoi massiv\n\n"; 
 for (i=;i<n;i++){ 
 a[i]=rand()%; 
 cout<<a[i]<<" "; 
 } 
 cout<<endl<<endl; 
 if (Hatti_search(a,n,search_key)) 
 cout<<"Elementi mavridi 
 nazar="<<(Hatti_search(a,n,search_key)); 
 else 
 cout<<"Chunin element vujud nadorad!"; 
 cout<<endl; 
 return; 
 } 
 Ҷуcтуҷӯи равиши дуӣ ( binary search) 
 Яке аз равишҳои содаи дигари ҷуcтуҷӯи элементҳои массив дар дохили 
 ҷадвал равиши дуӣ мебошад. Равиши мазкур дар мавриде, ки элементҳои 
 массив мураттабанд, ба кор бурда мешавад. Дар муқоиса нисбат ба равиши 
 хаттӣ сареътар мебошад. 
 Алгоритми ин равиш чунин аст: дар аввал ибтидо ва интиҳои ҷадвалро ба
 тағйирёбандаҳои l ва m нисбат дода, элементи мавриди назарро бо элементи 
 муқоиса мекунем, агар баробар бошад, пас, он пайдо шудааст ва дар
 акси ҳ о л, агар элементи мавриди назар аз элементи m-ум калонтар бошад, 
 тағйирёбандаи h-ро ба m+ баробар қабул карда мешавад. Ва дар ҳолати 
 элементи мазкур аз элементи m-ум хурд будан, h –ро ба m- қарор медиҳем ва
 элементи мавриди назарро боз бо элементи мобайнии нав ёфтаамон муқоиса 
 мекунем. Ин амалро то замоне идома медиҳем, ки шарти дуруст бошад. 
 Баъд амали мазкур хотима меёбад ва элементи мавриди назар ба чоп дода 
 мешавад. Мисол: функсияе нависед, ки аз элементҳои мас си ви бо ягон равиш
 мураттабшуда, элементи лозимиро бо равиши бинари ҷустуҷӯ намуда 
 барорад. 
 #include <iostream> 
 using namespace std; 
 int Binary_search(int a[],int n,int x){ 
 int m,l=,h=n-; 
 while (l<=h) 
 { 
 m=(l+h)/; 
 if (x==a[m]) 
 return a[m]; 
 if (x>a[m]) 
 l=m+; 
 else 
 h=m-; 
 } 
 return; 
 } 
 int main(){ 
 const int n=; 
 int a[n]; 
 int i,b,j,search_key; 
 cout<<" Elementhoi massiv pesh az jobajoguzori"<<endl<<endl; 
 for (i=;i<n;i++) 
 { 
 a[i]=rand()%; 
 cout<<a[i]<<" "; 
 } 
 cout<<endl; 
 for (j=;j<n;++j) 
 for (i=;i<n-j;++i) 
 if (a[i]>a[i+]) 
 { 
 b=a[i]; 
 a[i]=a[i+]; 
 a[i+]=b; 
 } 
 cout<<endl; 
 cout<<"Elementhoi massiv pas az jobajoguzori"<<endl<<endl; 
 for (i=;i<n;i++) 
 cout<<a[i]<<" "; 
 int d=; 
 while(++d<) 
 { 
 cout<"\n\nsearch_key=";cin>>search_key; 
 if ( Binary_search(a,n,search_key)) 
 cout<<"\nElementi mavridi nazar="<<Binary_search(a,n,search_key ); 
 else 
 cout<<"\nChunin element vujud nadorad!\n"; 
 } 
 return; 
 } 
 Тавре ки дида мешавад, дар ин ҷо аввал элементҳои массив бо равиши 
 ҳубобӣ мураттаб карда шуда, баъд бо ёрии фурӯхонии функсияи 
 Binary_search() элементи лозимиеро аз маҷмӯа ҷустуҷӯ намуда, баъди ёфтан он
 ба чоп дода шудааст. 
 Ҷустуҷӯи равиши тасодуфӣ 
 Моҳияти равиши мазкур аз он иборат аст, ки массиви додашуда ба се 
 қисмат ҷудо карда мешавад. Элементҳои аз адади тасодуфии интихобкарда 
 калон, элементҳои рақамашон аз адади тасодуфи хурд ва элементҳои ба адади
 тасодуфи рақами тартибиашон баробар. Адади тасодуфӣ дар фосилаи аз то n,
 ки дар ин ҷо n андозаи массив мебошад, интихоб карда мешавад. Баъд вобаста
 аз миқдори элементҳо дар ҳар як қисмат барои ҷустуҷӯ як қисмат интихоб 
 карда мешавад. 
 Массивҳои бисёрченака 
 Тавре ки қаблан гуфтем, массивҳо якченака дученака ва n-ченака 
 мешаванд. Массивҳои бисёрченака ҳам монанди массивҳои якченака муаррифӣ 
 карда мешаванд, вале фарқияти онҳо дар он аст, ки бузургии (ҳар як ченак)
 ченакҳои массив дар дохили n- қавси фигу-рави навишта мешавад. Наҳви 
 муаррифӣ намудани чунин массивҳо шакли зеринро дорад: 
 data_type array_Name [size][size] [size n] 
 Дар ин ҷо data_type навъи массив, array_Name-номи массив ва size, 
 size, size n мувофиқан андоза (ч енак)-ҳои якум, дуюм ва ҳоказо n-ум 
 мебошанд. Барои ба массивҳои n-ченака шинос шудан ҳолати n= буданро дида
 мебаро ем. Бигзор ба мо ҷадвале дорои n- сатр ва m –сутун дода шуда бошад.
 Дар ин ҷо n-миқдори сатрҳо ва m-миқдори сутунҳо мебошад. Барои ҳар як 
 элементи ин ҷадвал дастёб шудан бояд, ки суроғаи ҳар як катакчаро донем. Аз
 нуқтаи назари математика массивҳои дученака ин матритсаи дорои n сатр ва m
 сутун мебошанд. Ҳангоми n= ва m= будан, матритса шакли зеринро мегирад:
 Тавре ки дида мешавад, д[а р ин ҷо ҳ ар ]як элементи матритса дорои ду
 зернавис буда, якеаш нишондиҳ андаи сатр ва дигараш нишондиҳандаи сутун 
 мебошад. Масалан, барои элементи сеюми сатри дуввумро ба тағйирёбандаи t 
 бахшидан чунин менависем: t= Дар ин ҷо ададди нишондиҳандаи сатр ва 
 бошад, нишондиҳандаи сутун мебошад. 
 Наҳви муаррифӣ намудан и массиви дученака шакли зеринро дорад: 
 data_type array_Name [n][m] 
 Фарз мекунем, ки n= ва m= мебошад, он гоҳ мастритсаи мазкур 
 ҷадвалеро мемонад, ки дорои ду сатр ва се сутун мебошад, яъне 
 Дар ҳолати умумӣ массиви дорои n-сатр ва m сутунро масссиви n бар m 
 мегӯянд. Массивҳои сеченака чорченака ва ғай-ра низ 
 ҳамин тавр муаррифӣ карда мешаванд. Корбурди ин гуна мас-сивҳо барои 
 и ст иф о д аб ар а н д а и оддӣ камтар аст, аз ин рӯ, онҳоро сарфи назар карда, фақат
 массивҳои дученакаро дида мебароему бас. 
 Ба массивҳои дученака бахшидани қимати аввала 
 Монанди массивҳои якченака ба массивҳои дученака низ ҳан-гоми 
 муаррификунӣ метавон қиматии аввала бахшид. Мисол. 
 int array[][]={,,,,,} 
 Агар ин массивро ба намуди ҷадвал тасвир кунем намуди зеринро хоҳад 
 гирифт: 
 дар ин ҷо: 
 array[][]=, array [][]=, array [][]= 
 array [][]=, array[][]=, array [][]= 
 Бояд дар ёд дошт, ки зернависи элементҳои массив ду ченака низ аз сар
 мешавад. Ба ғайр аз ин навъ муаррификунӣ, элементҳои ҳар як сатр метавонанд
 дар дохили як қавси фигуравӣ навишта шаванд: 
 int array[][]={ 
 {,,}, 
 {,,} 
 }; 
 Агар дар дохили ҳар қавси фигуравӣ элементҳои додашуда аз андозаи 
 массив кам бошанд, элементҳои боқимонда ба таври пешфарз қимати қабул 
 мекунанд. Мисол: 
 int array[][]={ 
 {}, 
 {} 
 }; 
 Дар ин ҷо: 
 array[][]=, array [][]=, array [][]= 
 array [][]=, array[][]=, array [][]= 
 Истифодаи массивҳои дученака 
 Аз нуқтаи назари математика, Тавре ки қаблан гуфтем, массивҳои 
 дученака ин матритсаҳо мебошанд. Матритса ин ҷадвали дорои n-сатр ва m- 
 сутун мебошад. Одатан рақами сатр бо i ва рақами сутун бо j ишора карда 
 мешавад. Тавре ки қаблан зикр гардид, зернавис (рақами тартиби)-и мебошад.
 Пас, аз ин ҷо ин матритса ҷадвали до-рои n- сатр ва m--сутун мебошад. 
 Мисол int matr[][] матритсае аст, ки аз сатр ва сутун иборат мебошад.
 Монанди массивҳои якченака масссивҳои дученака низ ба барнома 
 (компютер) дохил ва хориҷ карда мешавад. 
 Мисол. Барномае нависед, ки элементҳои матритсаро дохил намуда, 
 Сипас, ба сурати ҷадвал ба чоп диҳад. 
 #include <iostream> 
 using namespace std; 
 int main() 
 { 
 const int n=,m=; 
 int matr[n][m]; 
 int i,j; 
 for (i=;i<n;i++) 
 for(j=;j<m;j++) 
 cin>>matr[i][j]; 
 for (i=;i<n;i++) 
 { 
 for (j=;j<m;j++) 
 cout<<matr[i][j]<<"\t"; 
 cout<<endl; 
 } 
 return; 
 } 
 Натиҷаи барнома ба сурати зерин хоҳад буд. 
 Matrix 
 Матритсаҳои рамзӣ 
 Монанди масссивҳои якченака, элементҳои масиви дученака метавонанд 
 низ рамзҳо бошанд. Дар ин навъ массивҳо зернависи якум нишондиҳандаи сатр
 буда, зернависи дуввум дарозии сатрро нишон медиҳад. 
 Мисол. Барномае нависед, ки номи рангҳои додашударо барорад. 
 #include <iostream> 
 using namespace std; 
 int main() 
 { 
 const int n=,m=; 
 int i,j; 
 char Color[n][m]={ 
 {’R’,’E’,’D’}, 
 {’G’,’R’,’E’,’E’,’N’}, 
 {’B’,’L’,’U’,’E’}, 
 {’B’,’L’,’A’,’C’,’K’}, 
 }; 
 for (i=;i<n;i++) 
 { 
 for (j=;j<m;j++) 
 cout<<Color[i][j]; 
 cout<<endl; 
 } 
 return; 
 } 
 Натиҷаи барнома шакли зеринро дорад: 
 RED 
 GREEN 
 BLACK 
 Ғалбери Эратосфен 
 Барои муайян кардани ададҳои сода алгоритми махсусе мавҷуд аст, ки 
 онро ғалбери Эратосфен (Эратосфе н Кире нский (Ἐρατοσθένης ὁ Κυρηναῖος; 
 п.м.— п.м.) —математик, астроном, географ ва шоири Юнон) меноманд. 
 Моҳияти ин алгоритм чунин аст: 
 ) Ададҳои аз як то n-ро пайиҳам менависем; 
 ) Адади якро хат мезанем; 
 ) Адади -ро интихоб карда (дар дохили давра гирифта), ададҳои бо он
 каратиро хат мезанем; 
 ) Барои адади низ қадами серо иҷро мекунем; 
 ) Барои ададҳои боқимонда, ки каратиии онҳо хат зада нашудаанд, 
 қадами серо иҷро мекунем; 
 ) Пас аз хат задани ададҳо, танҳо ададҳои содда боқӣ мемонанд. 
 Мисоли ин алгоритм дар поён оварда шудааст. 
 #include <iostream> 
 using namespace std; 
 const int N=; 
 unsigned long long int a[N]; 
 int main(){ 
 long int i; 
 for(long int i=; i<N; i++) 
 a[i] = i; 
 a[]=; 
 for(long int s=; s<N; s++) 
 if(a[s]!=) 
 for(long int j=s*; j<N; j+=s) 
 a[j]=; 
 for(i=; i<N; i++) 
 if(a[i]!=) 
 cout<<a[i]<< " "; 
 return; 
 } 
 Натиҷаи барнома шакли зеринро дорад: 
 Ғалбери Сундарама 
 Барои ёфтани ададҳои содда якчанд алгоритмҳо вуҷуд дорад. Яке аз 
 чунин алгоритмҳои хеле машҳур ғалбери Эратосфен мебошад. Новабаста аз 
 маъмул будани алгоритми мазкур суръати муайянкунии ададҳои содда дар он 
 суст мебошад. Соли алгоритми наве бо номи ғалбери Сундарама пайдо 
 шуд, ки нисбат ба ғалбери Эратосфен тезтар иҷро карда мешавад. Хосияти 
 асосии алгоритми мазкур аз он иборат аст, ки бо дода шудани адади n ададҳои
 соддаи фосилаи то *n муайян карда мешаванд. 
 Дар ин алгоритм аз ду ҳалқаи такрорӣ истифода бурда мешавад, ки ҳалқаи
 такрории беруна то замоне, ки қимати хурд аз n будан иҷро 
 карда мешавад. Ҳалқаи такрории дохилӣ бошад, то замоне ки шарти j<=(n- 
 i)/(*i+) дорои қимати ҳақ аст, иҷро к ар д а ме ш ав ад. Барои ба моҳияти
 алгоритми мазкур шинос шудан барномаи ин алгоритмро менависем. 
 #include <iostream> 
 using namespace std; 
 const int n=; 
 int x[*n]; 
 int main() 
 { 
 int i, j; 
 cout<<"Adadhoi sodda:"<<endl<<<<" "; 
 for (i=; i<=n; i++) x[i]=; 
 i=; j=; 
 while ((*i*j+i+j)<=n) 
 { 
 while (j<=(n-i)/(*i+)) 
 { 
 x[*i*j+i+j]=; 
 j++; 
 } 
 i++; j=i; 
 } 
 for (i=; i<=n; i++) 
 if (x[i]) 
 cout<<*i+<<" "; 
 return; 
 } 
 Намунаи ҳалли масъалаҳо 
 нависед, ки миқдор ва суммаи элементҳои ҷуфти онро ҳисоб кунад. 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 const int n=; 
 int a[n]; 
 int i,k=; 
 long int S=; 
 cout<<" Masiivi dodoshuda\n"; 
 for (i=;i<n;i++) 
 cin>>a[i]; 
 for (i=;i<n;i++) 
 if(a[i]%==) 
 { 
 k++; 
 S+=a[i]; 
 } 
 cout<<"S="<<S<<"\nk="<<k<<endl; 
 return; 
 } 
 элементҳояш аз ададҳои тоқи фосилаи аз як то N иборат бошанд. 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 const int n=; 
 int a[n]={}; 
 int i,nol,kol=; 
 long int S=; 
 cout<<" Masiivi dodoshuda\n"; 
 for (i=;i<n;i++) 
 if (i%!=) 
 a[i]=i; 
 for (i=;i<n;i++) 
 if (a[i]!=) 
 cout<<a[i]<<"\t"; 
 return; 
 } 
 элементҳои он аз N ададҳои аввалаи Фибоначӣ иборат бошанд. Маълум аст, ки
 ададҳои Фибоначӣ намуди зеринро доранд. 
 #include <iostream> 
 us ing n a m e sp ace s t d; 
 int main() 
 { 
 const int n=; 
 int a[n]={}; 
 int i,nol,kol=; 
 long int S=; 
 cout<<" Adadhoi Fibonachi\n"; 
 a[]=;a[]=; 
 for (i=;i<n;i++) 
 a[i]=a[i-]+a[i-]; 
 for (i=;i<n;i++) 
 cout<<a[i]<<"\t"; 
 return; 
 } 
 Массиви якченакаи андозааш N ва ададҳои бутуни K ва L ( 
 ) дода шудааст. Суммаи ҳамаи элементҳои аз K то L –и массив ҳисоб карда 
 шаванд. 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 const int n=; 
 int a[n]={}; 
 int i,L,K; 
 long int S=; 
 cout<<"K=";cin>>K; 
 cout<<"L=";cin>>L; 
 for(i=;i<n;i++){ 
 a[i]=rand()%; 
 cout<<a[i]<<"\t"; 
 } 
 for (i=K;i<=L;i++) 
 S+=a[i]; 
 cout<<"S="<<S<<"\t"; 
 return; 
 } 
 манфӣ, баъд мусбат ва дар охир элементҳои нулии онро бароред. 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 const int n=; 
 int a[n],Z[n]; 
 int i,k=-; 
 long int S=; 
 cout<<"Massivi dodashuda\n\n"; 
 for(i=;i<n;i++) 
 { 
 a[i]=rand()%-; 
 cout<<a[i]<<"\t"; 
 } 
 cout<<endl; 
 cout<<"Massivi nav\n\n"; 
 for (i=;i<n;i++) 
 if(a[i]<) 
 { 
 ++k; 
 Z[k]=a[i]; 
 } 
 for (i=;i<n;i++) 
 if(a[i]>) 
 { 
 k++; 
 Z[k]=a[i]; 
 } 
 for (i=;i<n;i++) 
 if(a[i]==) 
 { 
 k++; 
 Z[k]=a[i]; } 
 for (i=;i<n;i++) 
 cout<<Z[i]<<"\t"; 
 return; 
 } 
 элементҳои массивро чунин иваз кунад: элементи якумро ба элементи n-ум, 
 элементи дуюмро ба элементи n--ум ва ҳоказо. 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 const int n=; 
 int i,j; 
 int A[n],b; 
 for (i=;i<n;i++) 
 { 
 A[i]=rand()%(); 
 cout<<"A["<<i<<"]="<<A[i]<<" \n "; 
 } 
 cout<<endl; 
 for (i=;i<=n/;b=A[i],A[i]=A[n--i],A[n--i]=b,i++); 
 for (i=;i<n;i++) 
 cout<<"A["<<i<<"]="<<A[i]<<" \n "; 
 return; 
 } 
 элементи калонтарини массиврро бароред. 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 const int n=,m=; 
 int a[n],b[m]; 
 int i,j,minmax; 
 for (i=;i<n;i++) 
 a[i]=rand()%; 
 for (i=;i<n;i++) 
 cout<<a[i]<<"\t"; 
 cout<<endl; 
 for(i=;i<m;i++) 
 b[i]=a[i]; 
 for(i=m+;i<n;i++) 
 { 
 minmax=; 
 for (j=;j<m;j++) 
 if (b[j]<b[minmax]) 
 minmax=j; 
 if (a[i]>b[minmax]) 
 b[minmax]=a[i]; 
 } 
 for (i=;i<m;i++) 
 cout<<b[i]<<"\t"; 
 return; 
 } 
 намуди дӯӣ гардонад. 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 int a[]={},n,i=; 
 cout<<"n=";cin>>n; 
 while(n>=) 
 { 
 a[i]=n%; 
 n/=; 
 ++i; 
 } 
 for(;i>=;--i) 
 cout<<a[i]; 
 return; 
 } 
 элементи хурдтарини массивро бо тартиби зиёдшавиаш барорад. 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 const int n=,m=; 
 int a[n],b[m],temp; 
 int i,j,minmax; 
 for(i=;i<n;i++) 
 { 
 a[i]=rand()%; 
 cout<<a[i]<<"\t"; 
 } 
 cout<<endl; 
 for(i=;i<m;i++) 
 b[i]=a[i]; 
 for (i=m;i<n;i++) 
 { 
 minmax=; 
 for(j=;j<m;j++) 
 if(b[j]>b[minmax] ) 
 minmax=j; 
 if(a[i]<b[minmax]) 
 b[minmax]=a[i]; 
 } 
 for(j=;j<m;j++) 
 for(i=;i<m-j;i++) 
 if(b[i]>b[i+]) 
 { 
 temp=b[i]; 
 b[i]=b[i+]; 
 b[i+]=temp; 
 } 
 for (i=;i<m;i++) 
 cout<<b[i]<<"\t"; 
 cout<<endl; 
 return; 
 } 
 ки элементҳои диагонгали асосии онро ба элементи диагонали баракс 
 (ёрирасон) иваз кунед. 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 const int n=,m=; 
 int a[n][m],i,j,k,temp; 
 double S; 
 for(i=;i<n;i++) 
 for(j=;j<m;j++) 
 a[i][j]=rand()%; 
 for(i=;i<n;i++) 
 { 
 for(j=;j<m;j++) 
 cout<<a[i][j]<<"\t"; 
 cout<<endl; 
 } 
 cout<<endl; 
 for(i=;i<n;i++) 
 { 
 temp=a[i][i]; 
 a[i][i]=a[i][n--i]; 
 a[i][n--i]=temp; 
 } 
 for(i=;i<n;i++) 
 { 
 for(j=;j<m;j++) 
 cout<<a[i][j]<<"\t"; 
 cout<<endl; 
 } 
 return; 
 } 
 ки элементҳои ҳар як сатри онро ба тартиби калонша-виашон барорад. 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 const int n=,m=; 
 int a[n][m],i,j,k,temp; 
 double S; 
 for(i=;i<n;i++) 
 for(j=;j<m;j++) 
 a[i][j]=rand()%; 
 for(i=;i<n;i++){ 
 for(j=;j<m;j++) 
 cout<<a[i][j]<<"\t"; 
 cout<<endl; 
 } 
 cout<<endl; 
 for(i=;i<n;i++) 
 if(j%==) 
 { 
 for(k=;k<m;k++) 
 for (j=;j<m-k;j++) 
 if(a[i][j]>a[i][j+]) 
 temp=a[i][j]; 
 a[i][j]=a[i][j+]; 
 a[i][j+]=temp; 
 } 
 else 
 for(k=;k<m;k++) 
 for (j=;j<m-k;j++) 
 if (a[i][j]<a[i][j+]) 
 { 
 temp=a[i][j]; 
 a[i][j]=a[i][j+]; 
 a[i][j+]=temp; 
 } 
 for(i=;i<n;i++) 
 { 
 for(j=;j<m;j++) 
 cout<<a[i][j]<<"\t"; 
 cout<<endl; 
 } 
 return; 
 } 
 аввалаи ҳар як сатрро ба қимати миёнаи арифметикии ҳар сатр иваз кунед. 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 const int n=,m=; 
 int a[n][n],i,j; 
 double S; 
 for(i=;i<n;i++) 
 for(j=;j<n;j++) 
 a[i][j]=rand()%; 
 for(i=;i<n;i++) 
 { 
 for(j=;j<n;j++) 
 cout<<a[i][j]<<"\t"; 
 cout<<endl; 
 } 
 cout<<endl; 
 for(i=;i<n;a[i][]=S/n,i++) 
 for(S=j=;j<n;j++) 
 S+=a[i][j]; 
 for(i=;i<n;cout<<endl,i++) 
 { 
 for(j=;j<n;j++) 
 cout<<a[i][j]<<"\t"; 
 cout<<endl; 
 } 
 return; 
 } 
 оё он воҳиди аст? 
 Қайд. Матритса воҳидӣ номида мешавад, агар дар диагонали асосии он 
 воҳидҳо ва боқимонда элементҳои он аз нолҳо иборат бошанд. 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 const int n=,m=; 
 int a[n][n],i,j,pr; 
 for(i=;i<n;i++) 
 for(j=;j<n;j++) 
 a[i][j]=rand()%; 
 for(i=;i<n;i++) 
 { 
 for(j=;j<n;j++) 
 cout<<a[i][j]<<"\t"; 
 cout<<endl; 
 } 
 cout<<endl; 
 for(pr=,i=;i<n;i++) 
 for(j=i;j<n;j++) 
 if(((i==j) && (a[i][j]!=)) ||((i!=j) && (a[i][j]!=))) 
 { 
 pr=; 
 break; 
 } 
 if (pr) 
 cout<<"Vohidi ast \t"; 
 else 
 cout<<"Vohidi nest \t"; 
 cout<<endl; 
 return; 
 } 
 элементҳои аз диагонали асосӣ поёнро ҳисоб кунед. 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 const int n=; 
 int i,j; 
 int a[n][n]; 
 for (int i=;i<n;i++) 
 for(int j=;j<n;j++) 
 cin>>a[i][j]; 
 for (int i=;i<n;i++) 
 { 
 for(int j=;j<n;j++) 
 cout<<a[i][j]<<"\t"; 
 cout<<endl; 
 } 
 for (int i=;i<n;i++) 
 { 
 for (j=;j<i;j++) 
 cout<<a[i][j]<<"\t"; 
 cout<<endl; 
 } 
 return; 
 } 
 элементҳои диагонали баракси массиро барорад. 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 const int n=; 
 int i,j; 
 int a[n][n]; 
 for (int i=;i<n;i++) 
 for(int j=;j<n;j++) 
 cin>>a[i][j]; 
 for (int i=;i<n;i++) 
 { 
 for(int j=;j<n;j++) 
 cout<<a[i][j]<<"\t"; 
 cout<<endl; 
 } 
 cout<<" \n "; 
 for (int i=;i<n;i++){ 
 for (j=n-i;j<n;j++) 
 cout<<a[i][j]<<"\t"; 
 cout<<endl; 
 } 
 return; 
 } 
 Ададҳои бутуни аз то ро дар матритсаи дученакаи квадратии 
 андозааш ба n баробар ба тав ри морпеч нависед. Намуна: ҳангоми n=. 
 Матни барнома. 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 int const n=; 
 int A[n][n]; 
 int i=,j,k,p=n/; 
 for(k=;k<=p;k++)/*давр бо рақами гардиш (витка)*/ 
 { 
 /*Муайянкунии қимати болоии қуллаи сутунҳо*/ 
 for (j=k-;j<n-k+;j++) A[k-][j]=i++; 
 /* Тарафи рости амудии сутунҳо*/ 
 for (j=k;j<n-k+;j++) A[j][n-k]=i++; 
 /* Тарафи поёнии уфуқии сутунҳо */ 
 for (j=n-k-;j>=k-;--j) A[n-k][j]=i++; 
 /*Тарафи чапи амудии сутунҳо*/ 
 for (j=n-k-;j>=k;j--) 
 A[j][k-]=i++; 
 } 
 if (n%==) 
 A[p][p]=n*n; 
 for(i=;i<n;i++) 
 for(j=;j<n;j++) 
 { 
 cout<<A[i][j]<<" "; 
 if(j==n-) 
 cout<<endl; 
 } 
 return; 
 } 
 Масъалаҳо барои кори мустақилона 
 Масъалаҳои гурӯҳи Array 
 Барномае нависед, ки суммаи қисми касрии элементҳои онро ҳисоб кунад. 
 диҳед, ки аввал элементҳои ба ду каратӣ ва баъд элементҳои ба се каратии онро
 хориҷ кунад. 
 тартиб диҳед, ки сумма ва ҳосили зарбии қисмҳои бутуни массиви додашударо
 ҳисоб кунад. 
 элементҳои минималӣ ва максималиро мехобанд, ёфта шавад. 
 элементҳои боқимондаро ҳисоб кунед. 
 ки миқдор ва суммаи элементҳои ҷуфти онро ҳисоб кунад. 
 элементҳои он аз N ададҳои аввалаи Фибоначӣ иборат бошанд. Маълум аст, ки
 ададҳои Фибоначӣ шак ли з ер ин р о доранд. 
 ( 
 дода шудааст. Суммаи ҳамаи элементҳои аз K то L –и массив ҳисоб карда 
 шаванд. 
 баъд мусбат ва дар охир элементҳои нулиионро бароред. 
 тартибиашон тоқ адади ҷамъ карда шавад, аз ҳамаи элементҳои рақами 
 тартибиашон ҷуфт бошад адади тарҳ карда шавад. 
 массив қимати элементи якум ҷамъ карда шавад, аз ҳамаи элементҳои 
 қиматашон нол адади b тарҳ карда шавад ва элементҳои мусбати он бетағир 
 гузошта шаванд (a, b, c -ададҳои ихтиёрӣ). 
 массив адади a тарҳ карда шавад, аз ҳамаи элементҳои манфии массив адади b
 тарҳ карда шавад ва ба ҳамаи элементҳои қиматашон нол адади c ҷамъ карда 
 шавад (a, b, c -ададҳои ихтиёрӣ). 
 элементҳои массивро чунин иваз кунад: элементи якумро ба элементи n-ум, 
 элементи дуюмро ба элементи n--ум ва ҳоказо. 
 элементи калонтарини массиврро бароред. 
 не. Агар не, пас элементе, ки ин қонуниятро(тартибро) вайрон мекунад хориҷ
 карда шавад. 
 ҷуфт ва мавқеи ҷойгиршавиашон низ ҷуфт аст партофта карда шаванд. 
 намуди дӯӣ гардонад. 
 элементи хурдтарини массивро бо тартиби зиёдшавиаш барорад. 
 системаи шонздаҳӣ гардонад. 
 зарб карда шаванд. 
 символҳо, ададҳои ҳақиқӣ ва ғайра) амалӣ созед. 
 Масъалаҳои гурӯҳи Matrix 
 калонтарин ва дар сутун хурдтарин мебошад, ёфта шавад. 
 намуда дар массиви якченакаи A[K] гирд оваред. 
 намуда, бо элементҳои диоганали асосӣ иваз кунед. 
 сутунро ҳисоб намуда, ба элементҳои диогонали баръакс иваз кунед. 
 рӯи зиёдшавии қиматҳояшон ҷобаҷо гузоред. 
 сатри онро ба элементи минималии ҳар як сутун иваз намоед. 
 массивро дар массиви C[X][Y] бо тартиби зиёдшавиашон гирд оваред. 
 ҳар як сутунионро мураттаб кунад. 
 элементҳои диагонгали асосии онро ба элементи диагонали баракс (ёрирасон)
 иваз кунед. 
 элементҳои ҳар як сатри онро ба тартиби калоншавиашон барорад. 
 як сатрро ба қимати миёнаи арифметикииҳар сатр иваз кунед. 
 диагонали асосӣ поёнро ҳисоб кунед. 
 он воҳиди аст? 
 якуми массив ҳисоб карда шавад. 
 сутуни чоруми массив ҳисоб карда шавад. 
 карда шавад. 
 сатри массив ёфта шавад. 
 сатри массив ёфта шавад. 
 хурдтарини массив ҷойгир аст ёфта шавад. Агар дар массив қимати хурдтарин
 якчандто мавҷуд бошад, пас ҳамоне, ки аз тарафи чап аввал омада аст ба назар
 гирифта шавад. 
 калонтарини сутуни якуми массив ҷойгир аст ёфта шавад. Агар дар сутуни якум
 қимати калонтарин якчандто мавҷуд бошад, пас ҳамоне, ки аз боло аввал аст ба
 назар хориҷ карда шавад. 
 ёфта шаванд. 
 Боби. Ишорагарҳо (Pointers) 
 Муқаддима 
 Яке аз хусусият ва имкониятҳои забони С/С++ истифода ва корбурди 
 ишорагарҳо мебошад. Ишорагар ин тағйирёбандаест, ки ба ҷойи додае суроға ё
 маҳалли онро нишон медиҳад. Ба таври дигар гӯем, ишорагар тағйирёбандае 
 мебошад, маҳал ва ё суроғаи додаи дигарро дар худ нигоҳ медорад, яъне 
 миқдори ишорагар суроғае аз ҳофиза аст. Аз ҷо метавонем ба миқдори як дода
 ба таври ғайримустақим бо ёрии суроғааш аз ҳофиза дастёб шавем. Дар 
 забонҳои куҳна ба монанди Algol, Gobol, Fortran ин навъ тағйир-ёбандаҳо
 пешбинӣ нашуда буд, аммо дар забонҳои Паскал, PL/ ин гуна тағйирёбанда 
 пешбинӣ шудааст. Забони С++/С забоне мебошад, ки нисбат ба забонҳои дигар
 аз ишорагарҳо ба таври васеътар истифода мебарад. Шояд хонандагони 
 арҷманди мо суоле кунанд, ки истифодаи тағйирёбандаҳои навъи мазкур барои
 барномасоз чи имкониятеро фароҳам меоранд? Барои ба ин суол ҷавоб гуфтан 
 матлабҳои зеринро дида мебароем: 
 ) Ҳангоми ба функсия интиқол намудани ягон дода, ба таври пешфарз 
 нусхаи дода равон карда мешавад, ва ҳар амале, ки болои дода дар функсияи
 фаръӣ иҷро мегардад, ҳеҷ таъсире ба функсияи аслӣ намегузорад ва инчунин 
 агар дода аз навъи массив ва ё сохтор буда, миқдори зиёд дошта бошад, 
 ҳангоми нусхабардорӣ намудани он вақти зиёд сарф мешавад. Пас, барои 
 содатар иҷро намудани ин амал аз тағйирёбандаҳои навъи ишорагар истифода 
 мебарем. Тағйирёбандаи навъи ишорагар заминаи фурухонӣ ба суроға (call by
 address) ва ё фурухони бо нишона (call by reference)-ро фароҳам меорад, яъне он
 имконият медиҳад, ки ба функсияи фаръӣ на миқдори дода, балки суроғаи он 
 интиқол дода шавад ва ҳар амале, ки болои додаи мазкур дар функсияи фаръӣ
 иҷро карда мешавад, таъсироти зиёде болои он дода, дар функсияи аслӣ 
 мегузорад. 
 ) Медонем, ки ҳар функсия танҳо як миқдореро бо номи худ 
 бармегардонад. Агар лозим шавад, ки функсия якчанд миқдорро бар-гардонад,
 ба роҳи муқаррарӣ иҷрои ин амал ғайриимкон аст. Ишо-рагарҳо иҷрои ин 
 амалро метавонанд ба роҳи содатар ва қулайтар иҷро кунанд, яъне ишорагарҳо
 суроғаи додаеро ба функсияи фаръӣ равон мекунанд ва миқдоре, ки функсияи 
 фаръӣ бармегардонад дар суроғаи мазкур қарор мегирад. 
 ) Ишорагар бо массивҳо робитаи зиёд доранд. Дар натиҷа роҳи дигари 
 дастёб шудан ба элементҳои массив фароҳам меорад. Инчунин ишорагар 
 имконият медиҳад, ки як маҷмӯи сатрҳо дар дохили як массив танҳо намоиш 
 дода шаванд, агарчанде, ки дарозии онҳо аз ҳамдигар фарқ кунанд низ. 
 ) Амали ҷудо намудани ҳофизаро ба таври айёни (dymastic sto-rage 
 allonameion) имконпазир мегардонанд. 
 ) Тавассути ишорагарҳо сохтмони додаҳои динамикӣ, ки пушаҳо (стек),
 сафҳо (очеред), графҳо, дарахтҳои дӯи ва ғайра сохта мешаванд. 
 Метавон оиди ишорагарҳо мисолҳои зиёде орем, то хонандаи мо ба 
 моҳияти тағйирёбандаҳои навъи мазкур пурратар шинос шавад. Масалан, мо ба
 одами наве шинос шуда, дар дафтарчаи худ ном ва суроғаи онро сабт кардем.
 Дар ин ҷо метавонем номи одамеро, ки бо он шинос шудем, як такғийрёбанда 
 номида, суроғаи онро барояш як ишорагар ҳисоб кард. 
 Бояд қайд кард, ки тавасути ишорагарҳо листҳои пайванди, графҳо, 
 сафҳо, стекҳо ва ғайра сохта мешаванд. 
 Муаррифӣ намудани тағйирёбандаҳои навъи ишорагар 
 Монанди дигар тағйирёбандаҳо пеш аз истифода тағйирёбан-даҳои навъи 
 ишорагар низ муаррифи карда мешаванд. Наҳви таърифи тағйирёбандаҳои 
 ишорагар ба сурати зерин аст: 
 data_type *Ptvariable 
 Дар ин ҷо Ptvariable-номи тағйирёбанда буда, data_type-навъи 
 тағйирёбанда аст, ки суроғаи он метавонад дар тағйирёбандаи ишорагари 
 Ptvariable қарор гирад. Рамзи ситорача («*») бошад, оператори ишорагар ба
 ҳисоб меравад, ки танҳо барои тағйирёбандаҳои ишорагар истифода мешавад. 
 Ҳар тағйирёбандае, ки дар забони С++ истифода бурда мешавад, пеш аз 
 истифода бояд муаррифӣ карда шавад ва дар вақти муаррифӣ як миқдор 
 ҳофизаро банд мекунад, ки суроғаи онро бо ёрии оператории ягонаи амперсанд
 (&) метавонем ба даст орем. Масалан, суроғаи тағйирёбандаи n, ки қаблан аз
 ягон навъ муаррифӣ шудааст, бо ёрии ифодаи зерин ба даст оварда мешавад: 
 аd=&n; 
 Дар ин ҷо маҳалли тағйирёбандаи n ба тағйирёбандаи ad бахшида 
 шудааст. Бояд қайд кард, ки оператори ишорагар на қимати тағйирёбанда, 
 балки суроғаи онро муайян мекунад. Масалан, бигзор тағйирёбандаи a аз навъи
 бутун буда, тағйирёбандаи Pa а з навъи ишорагар бошад, яъне: 
 int a; 
 int *Pa; 
 Ҳоло метавонем бо ёрии оператори бахшиш суроғаи а-ро ба 
 тағйирёбандаи *Pa бахшид, яъне: 
 *Pa=a; 
 Тавре ки қайд намуда будем, тағйирёбандаи *Pa на қимат, балки танҳо 
 суроғаи а-ро нигоҳ медорад, аз ин рӯ, онро тағйирёбандаи ишорагар (pointer
 variable ) меноманд. Алоқаи байни тағйирёбандаи a ва *Pa ба сурати зерин аст
 Тағйирёбандаҳои а ва *Ра ҳар ду дар ҳофиза хонаҳои яксонро банд 
 мекунанд. Мисол: 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 int a,b; 
 int *Pa; 
 cout<<"a=";cin>>a; 
 Pa=&a; b=*Pa; 
 cout<<"Addressi a="<<&a<<" qimati Pa="<<Pa<<endl; 
 cout<<"Qimati a="<<a<<" qimati b="<<b<<endl; 
 cout<<"Munosibati * va & bo &*Pa="<<&*Pa<<"*&Pa="<<*&Pa<<endl; 
 return; 
 } 
 Тавре ки дида мешавад, дар ин ҷо тағйирёбандаи а ва b ҳар ду як 
 миқдорро муаррифӣ мекунанд. Бинобар ин, оператори * дар мавриди *Ра 
 муҳтаво ё ҷойи тағйирёбандаи а-ро бармегардонад, ки суроғаи он дар 
 тағйирёбандаи Ра қарор дорад. Аз ин рӯ, онро тағйирёбандаи ғайримустақим 
 низ меноманд. Натиҷаи барнома ба сурати зерин аст: 
 A= 
 Addressi a= qimati Pa= 
 Qimati a= qimati b= 
 Munosibati * va & bo yakdigar &*Pa= 
 *&= 
 Ёфтан ё пайдо кардани суроғаи як тағйирёбанда 
 Тавре ки гуфта гузаштем, ҳар тағйирёбанда дар ҳофиза вобаста ба навъаш
 (types) ҷойи муайнеро ишғол мекунад, яъне дорои суроғаи муайян аст. Баъзан
 барои ба он дастрас шудан беҳтар аст ба ҷойи худи он ба суроғаи он муроҷиат
 кунем. Барои ба даст овардани суроғаи тағйирёбанда аз оператори амперсанд
 «&» истифода бурда мешавад. Масалан, фарз мекунем, ки тағйирёбандаи х аз
 навъи doube буда, дорои суроғаи бошад. Ифодаи Px=&x миқдори 
 –ро дар тағйирёбандаи Рх захира мекунад. Мисол: 
 #include <iostream> 
 using namespace std; 
 int main() 
 { 
 double x,b; 
 double *Px; 
 cout<<"x="; cin>>x; 
 Px=&x; 
 cout<<"Addressi x="<<&x<<endl; 
 cout<<"Qimati x="<<x<<endl; 
 cout<<"Qimati Px="<<Px<<endl; 
 return; 
 } 
 Натиҷаи барнома ба сурати зерин аст: 
 X=. 
 Suragai 
 x= 
 Qimati x=. 
 Qimati 
 Px= 
 Аз матлаби баҳсамон чунин хулоса мебарояд, ки оператори «*» ба ду 
 маҳфум ба кор бурда мешавад. 
 a) Барои муаррифӣ намудани тағйирёбандаҳои аз навъи ишорагар. Дар ин
 ҳолат дар тарафи чапи тағйирёбанда навишта мешавад. Ба монанди: 
 int *a, *b, *c; 
 float *x, *y; 
 char *s, *s; 
 b) Барои дастёбди ба қимати тағйирёбандае, ки дар як ишорагар қарор 
 дорад. Мисол: 
 #include <iostream> 
 using namespace std; 
 int main() 
 { 
 char *P_chr; 
 char chr=’a’,chr; 
 cout<<"Qimati chr=="<<chr<<endl; 
 cout<<"Surogai P_chr="<<&P_chr<<endl; 
 P_chr=&chr; 
 cout<<"Qimati tagiyryobandae, ki surogai on dar P_chr qaror 
 dorad="<<*P_chr<<endl; 
 chr=*P_chr; 
 cout<<"Qimati chr=="<<chr<<endl; 
 return; 
 } 
 Дар ин барнома тағйирёбандаи P-chr аз навъи char (рамзи) буда, 
 тағйирёбандаҳои chr ва chr низ аз навъи char мебошанд. Ҳангоми 
 муаррифкунӣ ба тағйирёбандаи chr ба сифати қимати аввала рамзи ‘a’ 
 бахшида шудааст. Дар оператору хуруҷии якум, яъне 
 cout<<"Qimati chr=="<<chr<<endl; 
 Миқдори тағйирёбандаи chr, ки дорои қимати аввала буд, ба чоп дода 
 шудааст. Дар оператори хуруҷии дуввум суроғаи тағйирёбандаи P-chr ба чоп 
 дода шуда, пас аз он бо ёрии оператори ҷойгузорӣ, яъне 
 P_chr=&chr; 
 Суроғаи тағйирёбандаи chr ба ба он нисбат дода шудаст. Дар оператори
 хуруҷии саввум бошад, тағйирёбандаи P-chr, ки пештар бо ёрии оператори 
 ҷойгузори, ки суроғаи chr ба он нисбат дода шуда буд, бо ёрии оператори 
 ишорагар ба чоп дода шудааст ва Тавре ки мебинем, миқдори chr, яъне ‘a’ ба
 чоп дода шудааст. Баъдан ба ёрии оператори ҷойгузори миқдори P-chr ба 
 тағйирёбандаи chr бахшида шуда, сипас бо ёрии оператори хуруҷи ба чоп 
 дода шудааст. 
 Ба ғайр аз ин, агар дар суроғаи ишорагарҳо миқдореро илова ва ё кам 
 кунем, суроғаи нав пайдо мешавад. Масалан, фарз мекунем, ки тағйирёбандаи
 ишорагари Р ба қимати баробар буда, барои навиштании навъи он байт 
 ҷудо карда шуда бошад. Ҳангоми ба Р илова кардани ягон миқдори бутуни n,
 яъне Р+n қимати Р ба Р+n* баробар мешавад. Бигзор, n= бошад, қимати 
 P= мешавад. Аз ин ҷо шояд саволе ба миён ояд, ки чаро ба илова кардани 
 воҳид қимати Р воҳид зиёд мешавад?. Тавре ки пештар дар мавзӯи навъи 
 додаҳо гуфта будем, ҳар навъи додаҳо дорои миқдори муайяне мебошанд. Аз ин
 ҷо ҳар гуна тағйирёбандаи навъи double дар ҳофиза байтро ишғол мекунад.
 Пас, миқдори иловашуда ба миқдори навъи дода зарб карда мешавад, яъне 
 =* 
 Инчунин аз як ишорагар ишорагари дигарро тарҳ кардан суроғаи нав 
 пайдо мешавад. Масалан, бигзор тағйирёбандаи ишорагари Р дорои қимати 
 буда, тағйирёбандаи ишорагари Х дорои қимати бошад. Ифодаи Р- 
 Х= мешавад, яъне (-)/= (Дар ин ҷо миқдори навъи дода 
 мебошад). 
 Ба ишорагар бахшидани қимати аввала 
 Ба монанди дигар тағйирёбандаҳои муқаррарӣ ҳангоми муаррификунии 
 тағйирёбандаҳои навъи ишорагар ба онҳо низ қимати аввали бахшида мешавад.
 Ишорагар метавонад ба сифати қимати аввала қимати Null ё суроғаи ягон 
 тағйирёбандаи қаблан муаррифшударо бахшид. Масалан: 
 int n; 
 int *Pn=&n; 
 Бояд қайд кард, ки як тағйирёбанда пеш аз он ки муаррифӣ шавад, 
 наметавонад барои тағйирёбандаи ишорагар қимати аввала бошад, аз ин ҷо 
 ифодаҳои зерин ғайри қобили қабул аст. 
 int *Px=&x 
 int x; 
 Дар забони С++ мафҳуми Null мавҷуд аст, ки онро доимии рамзики Null 
 мегӯянд. Доимии мазкур дар чандин китобхонаҳо (Header Files) мавҷуд аст, 
 бахусус дар китобхонаи <iostream>. Мисол: 
 char *x; 
 x=; 
 Ишорагари Null дар забонии С++ истифодаи васеъ дорад, хусусан дар 
 операторҳои идоракунӣ ё контролӣ (control-flow statements). Миқдори Null дар
 операторҳои мазкур ҳамчун false (ноҳақ) ва ҳар миқдори ғайринул ҳамчун true
 фаҳмида мешавад. Масалан, дар оператори даврии бо шарти пешоянд, то 
 замоне ки шарти гузошташуда ба як ишорагари Null баробар шудан идома 
 меёбад. 
 chr *P 
 while(p) 
 { 
 } 
 Бояд қайд кард, ки б арои ишорагарҳо низ метавон, амалҳои арифметикиро
 истифода кард. Ҳангоми зиёд ё кам кардани ишорагари ягон объект, ишорагари
 объекти дигар пайдо мешавад. 
 Мисоли. Ду тағйирёбандаи бутун муаррифӣ намуда, сипас, ҷойи қимати
 ин тағйирёбандаҳоро бо истифода аз ишорагарҳо иваз кунед. 
 #include <iostream> 
 using namespace std; 
 int main() { 
 int a,b; 
 cout<<"a=";cin>>a; 
 cout<<"b="; cin>>b; 
 int* p=new int; 
 *p=a; 
 a=b; 
 b=*p; 
 delete p; 
 cout<<"a="<<a<< " b="<<b; 
 return; 
 } 
 Мисоли. Як ишорагари типи бутун муаррифӣ намуда, сипас барои он 
 ҳофиза ҷудо намоед. Барои ин ишорагар аз клавиатура қимат ворид намуда, пас
 аз он қимати онро ду воҳид зиёд кунед. Натиҷаи ҳосилшударо хориҷ намоед. 
 #include <iostream> 
 using namespace std; 
 int main() { 
 int *p; 
 p=new int; 
 cin>>*p; 
 (*p)+=; 
 cout<<*p; 
 delete p; 
 return; 
 } 
 Даъвати функсия аз рӯи суроға ва баргардонидани қимат 
 Дар аксар забонҳои барноманависӣ ду роҳ барои равон кардани 
 аргументҳо ба функсия ё даъвати аргументҳо вуҷуд дорад: 
 Ҳангоми даъват намудан ба микдор - тавре ки дар мавзӯи функсияҳо 
 мушоҳида ва истифода кардем, ҳамаи миқдори дода нусхабардорӣ шуда, ба 
 функсия равона карда мешавад. Тағйир додани нусха ғайриимкон аст, зеро 
 қимати аслӣ(original) дар функсияи даъват кунанда мавҷуд аст. Ҳангоми 
 нусхабардорӣ намудан агар додаҳо сатрҳо сохторҳо ва массивҳо бошанд, вақти
 зиёд сарф мешавад. Аз ин рӯ, даъват ба нишона (address) истифода карда 
 мешавад. Даъват ба суроға имконияти мустақим дастрас шуданро ба додаҳо 
 дода, инчунин имконият медиҳад, миқдори дода тағйир дода шавад. 
 Мисол. Барномае нависед, ки та-йирёбандаеро ба миқдор ба функсия 
 равона кунад. 
 #include <iostream> 
 using namespace std; 
 void gets(int, int); 
 int main(){ 
 int x,y; 
 cout<<"x=";cin>>x; 
 cout<<"y=";cin>>y; 
 cout<<"Qimathoi x va y pesh az da‘vati function-i far‘i"<<endl; 
 cout<<"x="<<x<<"\ty="<<y<<endl; 
 gets(x,y); 
 cout<<"Qimathoi x va y pas az da‘vati function-i far‘i"<<endl; 
 cout<<"x="<<x<<"\ty="<<y<<endl; 
 return; 
 } 
 void gets(int x, int y) 
 { 
 x+=; 
 y+=; 
 cout<<"Qimathoi x va y dar function-i far‘i"<<endl; 
 cout<<"x="<<x<<"\ty="<<y<<endl; 
 } 
 Қиматҳои a ва b дар ба функсияи фаръӣ равон карда мешаванд ва сипас 
 дар он ҷо бо ёрии операторҳои хуруҷӣ ба ҳар кадоми он миқдори ба воҳид 
 баробар илова намуда, ба чоп дода мешаванд, сипас дар функсияи аслӣ 
 функсияи фаръӣ даъват карда мешавад ва бо ёрии оператори хориҷкунӣ 
 миқдори тағйирёбандаҳои мазкур ба чоп дода мешавад. Тавре ки дида мешавад,
 дар функсия аслӣ амале, ки дар функсияи фаръӣ иҷро шуда буд ҳеҷ таъсире 
 нагузошт. Натиҷаи барнома ба сурати зерин аст: 
 x= 
 y= 
 Qimathoi x va y pesh az da`vati function-i far`i 
 x= y= 
 Qimathoi x va y dar function-i far`i 
 x= y= 
 Qimathoi x va y pas az da`vati function-i far`i 
 x= y= 
 Дар фурӯхонӣ бо суроға бошад, ба сифати қимат суроғаи дода ба 
 функсияи фаръӣ равона карда мешавад ва ҳар амале, ки дар функсияи аслӣ дар
 болои он дода анҷом дода мешавад, дар функсияи аслӣ низ таъсир мегузорад.
 Ҳангоми ба таври мазкур равон намудани аргументҳо ба функсияи фаръӣ дар 
 пешнамунасозии функсияи фаръӣ пас аз навъи аргумент, оператори амперсант 
 (&) навишта мешавад. 
 Мисол. Мисоли дар боло овардашударо ба таври даъват аз рӯи нишона 
 менависем. 
 #include <iostream> 
 using namespace std; 
 void gets(int &, int &); 
 int main(){ 
 int x,y; 
 cout<<"x=";cin>>x; 
 cout<<"y=";cin>>y; 
 cout<<"Qimathoi x va y pesh az da‘vati function-i far‘i"<<endl; 
 cout<<"x="<<x<<"\ty="<<y<<endl; 
 gets(x,y); 
 cout<<"Qimathoi x va y pas az da‘vati function-i far‘i"<<endl; 
 cout<<"x="<<x<<"\ty="<<y<<endl; 
 return; 
 } 
 void gets(int &x, int &y) 
 { 
 x+=; 
 y+=; 
 cout<<"Qimathoi x va y dar function-i far‘i"<<endl; 
 cout<<"x="<<x<<"\ty="<<y<<endl; 
 } 
 Натиҷаи барнома ба сурати зерин аст: 
 x= 
 y= 
 Qimathoi x va y pesh az da`vati function-i far`i 
 x= y= 
 Qimathoi x va y dar function-i far`i 
 x= y= 
 Qimathoi x va y pas az da`vati function-i far`i 
 x= y= 
 Ишорагар бар ишорагар (Pointer to Pointer) 
 Чи хеле ки қаблан ишора гардид, ишорагар низ тағйирёбанда буда, қимати
 он адади додашуда набуда, балки суроғаи тағйирёбандаи дигар мебошад. Аз ин
 ҷо метавонем ишорагарро чунин таъриф диҳем: тағйирёбандае, ки дар худ 
 суроғаи тағйирёбандаи дигарро нигоҳ медорад, ишорагар номида мешавад. 
 Инчунин метавонем ишорагари дигарро бар ишорагар муаррифӣ кунем, ки онро 
 ишорагар бар ишорагар (pointer to pointer) ё MULTIPlE INDIRECTION 
 меноманд. Дар поён ба намуди диаграмма ду навъи ишорагар ишорагар бар 
 тағйирёбандаи оддӣ ва ишорагар бар ишорагар нишон дода шудааст. 
 Тавре ки мушоҳида мешавад, ишорагари якум дар худ суроғаи ишорагари 
 дигарро дорад, он ҳам бошад, дар навбати худ суроғаи тағйирёбандаи дигарро
 нигоҳ медорад. Ин равиш метавонад якчанд маротиба иҷро гардад. Барои 
 муаррифӣ намудани тағйирёбандаи ишорагар бар ишорагар пеш аз номи 
 тағйирёбанда ду оператори «*» гузошта мешавад. Наҳви таърифи ишорагар бар
 ишорагар ба сурати зерин аст: 
 data_type **Ptvariable 
 Дар ин ҷо навъи тағйирёбанда, Ptvariable-номи тағйирёбанда ва ва ду 
 рамзи «*» бошад маънои ишорагар бар ишорагаррро доранд. Масалан, 
 тағйирёбандаи бутуни х аз навъи ишорагар бар ишорагари чунин int **x 
 муаррифӣ карда мешавад. Мисол: 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 int n,*x,**y; 
 cout<<"n=";cin>>n; 
 x=&n; 
 y=&x; 
 (*x)++; 
 (**y)--; 
 cout<<"n="<<n<<"\n *x="<<*x<<"\n **y="<<**y<<"\n x="<<x<<endl; 
 return; 
 } 
 Тавре ки дар барнома дида мешавад, пас аз муаррификунии 
 тағйирёбандаҳо бо ёрии оператори дохилкунӣ қимати n ворид карда мешавад, 
 сипас, ба ёрии оператори ҷойгузори суроға n ҳам ба *x ва ҳам ба 
 тағйирёбандаи **y бахшида шудааст. Сипас, қиматҳои ҳам *х ва ҳам **у 
 воҳид афзоиш дода шудааст. Дар охир ба ёрии оператори хориҷкуни қиматҳои 
 *х ва **у инчунин бар тағйирёбандаҳои мазкур бори дигар ишорагар таъсис 
 дода шуда ба чоп бароварда мешаванд. Натиҷаи барнома ба сурати зерин аст:
 N= 
 N= 
 *x= 
 **y= 
 X= 
 Y= 
 Аз натиҷаи барнома бармеояд, ки ҳангоми суроғаи тағйирёбандаро 
 афзоиш додан, қимати он ҳам афзоиш дода мешавад, миқдори афзоишшуда ба 
 миқдори ҳофизае, ки компилятор барои навъи дода ҷудо мекунад, зарб карда 
 мешавад. Аз ин ҷост ки қимати n= мешавад. 
 Истифодаи ишорагарҳо барои кор кардан бо массивҳои дученака 
 Монанди массивҳои якченака метавон массивҳои дученакаро низ ба таври
 динамикӣ муаррифӣ кард. Дар ин сурат аввал массиви дученака ҳамчун як 
 ишорагари оддӣ муаррифӣ карда шуда, сипас, барои он бо андозаи MxN (Дар 
 ин ҷо M-миқдори сатрҳо ва N- миқдори сутунҳои массив мебошад.) тавассути 
 операторҳои кор бо ҳофизаи динамикӣ ҳофиза ҷудо карда мешавад. Барои ба 
 массивҳои дученака ҷудо намудани ҳофизаи динамикӣ аз яке аз роҳҳои зерин 
 истифода бурда мешавад. 
 массивҳои дученакаи динамикӣ намуди зеринро дорад: 
 int *a, N, M; 
 ….. 
 a=(int *) сalloc(M*N, sizeof(int)); 
 массивҳои дученака намуди зеринро дорад: 
 int *a, N, M; 
 ….. 
 a=(int *) malloc(M*N*sizeof(int)); 
 мазкур барои массивҳои дученака намуди зеринро дорад: 
 int *a, N, M; 
 ….. 
 a=new int[M*N]; 
 Дар ин ҷо дар ҳама операторҳо элементҳои матритса ҳамчун массиви 
 якченака захира карда мешаванд. Дар ин массиви якченака аввал элементҳои 
 сатри якум, баъд дуюм ва ҳоказо илова карда мешаванд. Барои ба элементи 
 a[i][j] муроҷиат кардан лозим аст, ки тавассути рақами сатр i ва рақами сутун j
 рақами элементи k-ро ҳисоб кард. 
 Фарз мекунем, ки элементҳои массиви дученака шуруъ карда, аз - 
 рақамгузорӣ шуда бошанд, пас k=i*M+j мешавад. Барои ба элементи a[i][j]- 
 дастрас шудан аз оператори зерин истифода бурда мешавад: 
 *(a+i*N+j); 
 Мисол. Массиви динамикии андозааш M*N дода шудааст. Барномае 
 нависед, ки элементи хурдтарини матритсаро ҳисоб кунад. 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 int *a, M, N, i, j, min; 
 cin>>M>>N; 
 a=(int *) calloc(M*N, sizeof(int)); 
 for (i=; i<M; i++) 
 for (j=; j<N; j++) 
 cin>>*(a+i*N+j); 
 min=*a; 
 for (i=; i<M; i++) 
 for (j=; j<N; j++) 
 if (min>*(a+i*N+j)) 
 min=*(a+i*N+j); 
 cout<<min<<endl; 
 return; 
 } 
 Тавре ки аз ин ҷо дида мешавад, пас аз муаррификунии ишорагар 
 (массиви дученака) андозаи он тавассути оператори дохилкунӣ ворид карда 
 шудааст. Пас аз дохил намудани андозаи массив, барои он ҳофизаи лозимӣ 
 ҷудо карда шуда, элементхои он дохил карда шудааанд. Пас аз дохил намудани
 элементҳои массиви дученака, элементи якум ба намуди пешфарз min ҳисоб 
 карда шуда, сипас дар дохили оператори такрорӣ бо дигар элементҳо муқоиса
 карда шудааст. 
 Операторҳои дигар низ монанди ин истифода карда мешаванд. 
 Истифодаи ду ишорагар барои массивҳои дученакаи динамикӣ 
 Массивҳои дученакаи динамикиро метавон низ ба сурати ду ишорагар, ки
 ишорагар ба ишорагар номида мешавад, эълон кард. Наҳви истифодаи ин амал 
 намуди зеринро дорад: 
 int **a, m, n; 
 …. 
 a=new int *[m]; 
 Дар ин ҷо массиви дорои n-элемент сохта шудааст, ки ҳар як элементи он
 суроға буда, ба суроғаи сабтшудаи int ишора мекунанд. Барои ишорагарҳои 
 боқимонда ҳалқаи такрорие аз то n- ташкил карда мешавад, ки дар ҳар кадом
 ишорагар суроғаи хотирае, ки дар он ҷо m-элементи навъи int нигоҳ дошта 
 мешавад. Мисол: 
 for (i=; i<n; i++) 
 a[i]=new int [m]; 
 Баъд аз ин массиви дорои n ишорагар муаррифӣ карда мешавад, ки дар 
 ҳар як ишорагар суроғаи массиви дорои m-элемент нигоҳ дошта мешавад. 
 Муроҷиат ба элементҳои ин навъ массивҳои дученака монанди муроҷиат ба 
 массивҳои дученакаи оддӣ мебошад. 
 Мисол. Барномае нависед, ки ҳосили зарби ду массиви дученакаро ҳисоб
 кунад. Аз нуқтаи назари математикӣ формулаи зарби ду матритса намуди 
 зеринро дорад. 
 Матни барнома: ∑ 
 #include <cstdlib> 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 int i,k,j,l, m, n, **a, **b, **c; 
 cin>>m>>n>>l; 
 a=new int *[n]; 
 for (i=; i<m; i++) 
 a[i]=new int [m]; 
 cout<<"\n Enter Matrix one \n"; 
 for (i=; i<m; i++) 
 for (j=; j<n; j++) 
 cin>>a[i][j]; 
 for (i=; i<m; cout<<endl, i++) 
 for (j=; j<n; j++) 
 cout<<a[i][j]<<"\t"; 
 cout<<"\n Enter Matrix two\n"; 
 b=new int *[l]; 
 for (i=; i<n; i++) 
 b[i]=new int [n]; 
 for (i=; i<n; i++) 
 for (j=; j<l; j++) 
 cin>>b[i][j]; 
 c=new int *[l]; 
 for (i=; i<m; i++) 
 c[i]=new int [m]; 
 for (i=; i<m; i++) 
 for (j=; j<l; j++) 
 for (c[i][j]=, k=; k<n; k++) 
 c[i][j]+=a[i][k]*b[k][j]; 
 for (i=; i<n; cout<<endl, i++) 
 for (j=; j<l; j++) 
 cout<<c[i][j]<<"\t"; 
 for (i=; i<n; i++) 
 delete [] a[i]; 
 delete [] a; 
 for (i=; i<l; i++) 
 delete [] b[i]; 
 delete [] b; 
 for (i=; i<l; i++) 
 delete [] c[i]; 
 delete [] c; 
 return; 
 } 
 Барои боз ҳам пурратар шинос шудан мисоли дигареро дида мебароем. 
 Мисол. Матритсае тартиб диҳед, ки элементҳои он аз ададҳои тасодуфи иборат
 бошанд, сипас элементҳоро хориҷ кунед. 
 #include <cstdlib> 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 int **p; 
 int m,n,i,j; 
 cout<<"n=";cin>>n; 
 cout<<"m=";cin>>m; 
 p=new int *[n]; 
 for (i=;i<n;i++) 
 { 
 p[i]=new int[m]; 
 for(j=;j<m;j++) { 
 p[i][j]=rand()%; 
 cout<<p[i][j]<<" "; 
 } 
 cout<<endl; 
 } 
 for (i=;i<n;i++) 
 delete [] p[i]; 
 delete []p; 
 return; 
 } 
 Тавре ки аз мантиқи барнома дида мешавад, ки дар ин ҷо тағйирёбандаи p
 ҳамчун ишорагар бар ишорагар тавсиф шудааст, ин нишон медиҳад, ки p 
 массиви дученака тавсиф шудааст. Баъд қи-матҳои сатр ва сутун аз клавиатура
 бо ёрии истифодабаранда ворид карда мешаванд, ифодаи p=new int *[n]; 
 нишондиҳандаи массив аз ишорагар мебошад. Баъдан дар қисмати зерин дар 
 дохили ду оператори даврӣ аз ададҳои тасодуфӣ элементҳои массив пур карда
 шуда, ба чоп дода шудаанд. 
 for (i=;i<n;i++){ 
 p[i]=new int[m]; 
 for(j=;j<m;j++){ 
 p[i][j]=rand()%; 
 cout<<p[i][j]<<" "; 
 } 
 cout<<endl; 
 } 
 Дар қисмати зерин дар дохили як давр бо ёрии оператори delete хотира
 аз массиви якченакаи динамикӣ озод карда шуда, дар охир бо ёрии фармони 
 delete []p ҷойи хотираи асосии низ аз массив озод карда шудааст. 
 for (i=;i<n;i++) 
 delete [] p[i]; 
 delete []p; 
 Массивҳо ва ишорагарҳо 
 Метавонем ҳангоми муаррификунии массивҳо онҳоро аз навъи 
 ишорагарҳо таъриф кунем, яъне элементҳои массивро аз ишорагарҳо 
 (ишорагаре, ки суроғаи тағйирёбандаи додашударо дар худ нигоҳ ме-дорад) 
 пур кунем. 
 int *ar[] 
 Масалан, барои суроғаи панҷуми масивро аз ягон тағйирёбандаи z пур 
 кунем, менависем 
 *ar[]=&z 
 Барои ба даст овардани қимати z аз ишорагари дукарата, яъне ишорагар
 бар ишорагар истифода бурда мешавад, ба монанди 
 **x[]; 
 Дар забони С++ миёни ишорагарҳо ва массивҳо робитаи наздике вуҷуд 
 дорад. Медонем, ки номи массив, суроғаи элементи массив мебошад. Бигзор 
 массиви бутунӣ b[] ва тағйирёбандаи ишорагари Pb мавҷуд бошад. Бинобар 
 ин, ду оператори зерин ба ҳам эквивалент мебо-шанд. 
 Pb=b&b[] 
 char str[],*P; 
 P=str; 
 P=&str[]P=str 
 Дар қитъаи барномаи боло дида мешавад, ки P суроғаи элементи массивро
 нишон медиҳад. Агар хоҳем, ки ба элементи чоруми массив дастрас шавем, аз
 операторҳои зерин истифода мекунем: 
 str[] ё *(str+) 
 Ҳар ду оператор элементи чоруми массивро нишон медиҳанд. Ба таври 
 умуми гӯем, операторҳои p[n] ва *(p+n) аъзои чоруми массивро нишон надода,
 элементи (n+)-ро нишон медиҳанд, зеро ки зернависи якуми массив нол 
 мебошад. Аз ин матлаби баҳсшуда бармеояд, ки элементҳои массивро ҳам аз 
 рӯи зернавис ва ҳам аз рӯи суроға дастрас кардан мумкин аст, вале дастрасшавӣ
 аз рӯи суроға нисбат ба зернавис саҳеҳтар мебошад. Ба таври умумӣ ба 
 элементҳои массив метавон бо роҳҳои гуногун дастрас шуд. 
 Мисол. Барномае нависед, ки ба элементҳои массив бо роҳҳои гуногун 
 дастрас гардиданро амалӣ гардонад. 
 #include <cstdlib> 
 using namespace std; 
 int main(){ 
 const int n=; 
 int b[]={,,,,}; 
 int *Pb=b; 
 int i; 
 cout<<"Ba namudi muqarrari dastras shudan"<<endl; 
 for (i=;i<n;i++) 
 cout<<"b["<<i<<"]="<<b[i]<<endl; 
 cout<<"Ba vositai ishoragar dastras shudan"<<endl; 
 for (i=;i<n;i++) 
 cout<<"*(b+"<<i<<")="<<*(b+i)<<endl; 
 cout<<"az rui Address dastras shudan"<<endl; 
 for (i=;i<n;i++) 
 cout<<"Pb["<<i<<"]="<<Pb[i]<<endl; 
 cout<<" Ba vositai ishoragar bar Address dastras shudan "<<endl; 
 for (i=;i<n;i++) 
 cout<<"*(Pb+"<<i<<")="<<*(Pb+i)<<endl; 
 return; 
 Миқдори тағйирёбандаҳои ишорагар наметавонанд ба таври дилхоҳ 
 тағйир ёбанд. Аз ин рӯ, истифодаи оператори як воҳид афзоиш (increment) ва як
 воҳид коҳиш (decrement) барои элементҳои массив маслиҳат дода намешавад. 
 Тавре ки дар гузашта дида будем, вобаста аз навъи дода дар хотира ҷойи 
 махсусеро ишғол мекунад. Ба-рои миқдори навъҳои стандартиро мушаххас 
 намудан аз оператори ҳофиза sizeof истифода бурда мешавад. 
 Мисол. Барномае нависед, ки миқдори ҳофизаи ҳамаи навъҳои 
 стандартиро барорад. 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 char chr; 
 short s; 
 int i; 
 long l; 
 float f; 
 double d; 
 long double ld; 
 int array[], 
 *Parray=array; 
 cout<<"Miqdori nav‘hoi standarti"<<endl; 
 cout<<" sizeof char="<<sizeof(chr)<<"\n sizeof 
 short="<<sizeof(s)<<"\n sizeof int="<<sizeof(i)<<"\n sizeof 
 long="<<sizeof(l)<<"\n sizeof double="<<sizeof(d)<<"\n sizeof long 
 double="<<sizeof(ld)<<"\n sizeof array=" <<sizeof(Parray) <<endl; 
 return; 
 } 
 Оператори sizeof имконияти қабули дилхоҳ тағйирёбанда навъи 
 стандартӣ ва худи навъи стандартиро дорад. Бояд қайд кард, ки sizeof функсия
 набуда, оператори ягона мебошад. Натиҷаи барнома ба сурати зерин аст: 
 Miqdori nav`hoi 
 standarti 
 sizeof char= 
 sizeof short= 
 sizeof int= 
 sizeof long= 
 sizeof double= 
 sizeof long double= 
 sizeof array= 
 Равон кардани массив ба функсия ба сифати аргумент 
 Барои массивро ба функсия ба сифати аргумент равон кардан, фақат суроғаи
 массив ба функсия интиқол дода мешавад, ни нусхаи тамоми элементҳои массив,
 пас аз ин ҷо барои массивҳо фурӯхонӣ ба миқдор (call byvalue) ба кор намеояд.
 Ҳангоми дар функсия ба сифати аргумент даъват кардани массив як ишорагар бар
 элементи аввалаи массив ба функсия равона карда мешавад. Номи массив бе 
 зернавис як ишорагар ба элементи якуми массив аст. Умуман, се механизм (роҳ)-и
 равон кардани массив ба сифати параметри функсия мавҷуд аст. 
 Ба монанди мисоли зерин: 
 #include <iostream> 
 using namespace std; 
 void show( int a[]){ 
 for (int i=;i<;i++) 
 cout<<a [i]<<"\t"; 
 cout<<endl; 
 } 
 int main(){ 
 int a[],i; 
 for (i=;i<;i++) 
 a[i]=rand()%; 
 show(a); 
 return; 
 } 
 Дар ин мисол функсияе ба номи show муаррифӣ шуда аст, аргументи он 
 массиви дорои -элемент мебошад. С++ онро ҳамчун як ишорагар навъи 
 бутун (integer pointer) табдил медиҳад, зеро ҳеҷ параметр наметавонад, ки
 тамоми элементҳои массивро дарёфт кунад. 
 навишта мешавад. Мисол: 
 #include <iostream> 
 using namespace std; 
 void show( int a[]){ 
 for (int i=;i<;i++) 
 cout<<a [i]<<"\t"; 
 cout<<endl; 
 } 
 int main(){ 
 int a[],i; 
 for (i=;i<;i++) 
 a[i]=rand()%; 
 show(a); 
 return; 
 } 
 Тавре ки дида мешавад, дар ин намуд андозаи массив муайян нашудааст.
 Дар ин ҷо низ a[]-як ишорагар ба элементи якуми массив мебошад. 
 сифати аргументи функсия даъват карда мешавад. Мисол: 
 #include <iostream> 
 using namespace std; 
 void show( int *a,int n) 
 { 
 for (int i=;i<n;i++) 
 cout<<a [i]<<"\t"; 
 cout<<endl; 
 } 
 int main(){ 
 int a[],i; 
 for (i=;i<;i++) 
 a[i]=rand()%; 
 show(a,); 
 return; 
 } 
 Дар ин мисол ба сифати аргументи функсия ду адади бутун истифода 
 шудааст, ки яке аз онҳо ишорагар ба массив буда, дигараш бошад, андозаи 
 массив ба ҳисоб меравад. Як чизро дар хотир бояд дошт, ки ҳангоме, ки 
 массив ба сифати аргументи функсия тавсиф мегардад, ҳамчун як ишорагар 
 фаҳмида мешавад. Ҳар амалиёте, ки болои массив дар функсияи фаръӣ иҷро 
 карда мешавад, дар функсияи аслӣ низ болои элементҳои массив низ амалӣ 
 мегардад. 
 Мисол. Функсияе нависед, ки элементҳои массиви додашударо аз рӯи 
 алгоритми мураттабсозии ҳубобӣ мураттаб созад. 
 #include <iostream> 
 using namespace std; 
 void bublesort( int *,const int); 
 int main(){ 
 const int n=; 
 int a[n],i; 
 cout<<"Elementhoi massiv pesh az jobajoguzory\n"<<endl; 
 for (i=;i<n;i++) 
 { 
 a[i]=rand()%; 
 cout<<a [i]<<"\t"; 
 } 
 cout<<endl; 
 cout<<"\nElementhoi massiv pas az jobajoguzory\n"<<endl; 
 bublesort(a,n); 
 for (i=;i<n;i++) 
 cout<<a [i]<<"\t"; 
 cout<<endl; 
 return; 
 } 
 void bublesort( int *massiv, int n) 
 { 
 int temp,i,j; 
 for (i=;i<n;i++) 
 for(j=;j<n-i;j++) 
 if (*(massiv+j)>*(massiv+j+)) 
 { 
 temp=*(massiv+j); 
 *(massiv+j)=*(massiv+j+); 
 *(massiv+j+)=temp; 
 } 
 Тавре ки дида мешавад, функсияи фаръӣ дорои ду аргумент мебошад, ки 
 якеаш ишорагар бар массив буда, дигараш нишон-диҳандаи андозаи массив 
 мебошад. 
 Ҳангоми равон кардани массиви n-ченака дар функсия ба ғайр аз андозаи
 якум, андозаи боқимондаҳо нишон дода мешаванд. Дар массивҳои якченака 
 ҳангоми равон кардани он ба функсия андозааш нишон дода намешавад 
 (равиши дуюм). Массивҳои n-ченака бошанд (сар карда аз дученака), массив 
 бар массив мебошанд. Дар ин навъ массивҳо бошад, элементи якум худаш ҳам 
 массив мебошад. Барои элементҳои баъдина бошад, бояд андоза мушаххас 
 гардад, то ин ки компилятор барои он дар ҳофиза ҷоеро банд намояд. Мисол:
 #include <iostream> 
 using namespace std; 
 void show( int a[][],int n) 
 { 
 int i,j; 
 for (i=;i<n;i++) { 
 for ( j=;j<;j++){ 
 cout<<a [i][j]<<" "; 
 } 
 cout<<endl; 
 } 
 } 
 int main() 
 { 
 int a[][]={ 
 {,,}, 
 {,,}, 
 {,-,}, 
 }; 
 show(a,); 
 return; 
 } 
 Дар ин мисол ишораг бар элементи дуввуми массив ишора кардааст. 
 Мисоли дигар. Массиви а, ки дорои n элемент мебошад, дода шудааст, 
 функсияе нависед, ки элементҳои ҷуфти массивро барорад. 
 #include <iostream> 
 using namespace std; 
 void Print(int *a,int n){ 
 for (int i=;i<n;i++) 
 if ((a[i] %) ==) 
 cout<<a[i]<<"\t"; 
 cout<<endl; 
 } 
 int main() { 
 const int n=; 
 int a[n],i; 
 for (i=;i<n;i++) 
 { 
 a[i]=rand()%; 
 cout<<a[i]<<"\t"; 
 } 
 cout<<endl<<endl; 
 Print(a,n); 
 return; 
 } 
 Аз функсия баргардонидани суроға 
 То ҳол функсияҳое, ки мо навиштем, танҳо қимати ягон навъи 
 стандартиро бармегардониданд. Илова бар ин функсия метавонанд 
 ишорагарҳоро низ баргардонад. Барои иҷрои ин амал ҳангоми пешнамунасозӣ 
 пеш аз номи функсия оператори ишорагар навишта мешавад. Ба барномаи 
 зерин диққат диҳед: 
 #include <iostream> 
 using namespace std; 
 int *ishoragar( int &a){ 
 return &a; 
 } 
 int main(){ 
 int a, *P; 
 cout<<"a=";cin>>a; 
 P=ishoragar(a); 
 cout<<"Enter a="<<a<<endl; 
 (*P)++; 
 cout<<"Result a="<<a<<endl; 
 return; 
 } 
 Тавре ки мушоҳида мешавад, дар ин ҷо функсияи ishoragar дорои як 
 аргументи суроға мебошад. Ва ҳангоми фурӯхонӣ дар функ-сияи аслӣ тавассути
 тағйирёбандаи ишорагари P суроғаи он баргардонида мешавад. Сипас, бо 
 ишорагари P амали як воҳид афзоиш иҷро гардида, қимати a ба чоп дода 
 мешавад. Натимҷа шакли зеринро дорад: 
 Enter a = 
 Result a= 
 Ба ғайр аз он чи ки дар боло зикр кардем, функсияҳо низ метавонанд ба
 сифати аргумент суроғагарҳоро баргардонанд. Барои иҷрои ин амал ҳангоми 
 пешнамунасозӣ пеш аз номи функсия оператори амперсанд навишта мешавад. 
 Барои ин ба мисоли зерин таваҷҷуҳ фармоед: 
 #include <iostream> 
 using namespace std; 
 int &nishoragar( int &a){ 
 return a; 
 } 
 int main(){ 
 int a,P; 
 cout<<"Enter a=";cin>>a; 
 P=ishoragar(a); 
 P++; 
 cout<<"Result a="<<a<<endl; 
 cout<<"Result P="<<P<<endl; 
 return; 
 } 
 Натиҷаи барнома шакои зеринро дорад: 
 Enter a = 
 Result a= 
 Enter P = 
 Пас аз оне, ки ба моҳияти ишорагарҳо шинос шудам, як микросхемаи 
 компютерро мавриди баҳс қарор медиҳем. 
 Таҷҳизоти хотираи фаврӣ 
 Ҳар барномае, ки мо менависем, ҳангоми иҷроиш дар хотираи фаврӣ ҷой 
 дода мешавад. Аз ин ҷо бо роҳи мустақим ё тавассути кэш протсессор 
 фармонҳои барномаро хонда, иҷро мекунад. Барои ҳар барномасоз лозим аст, ки
 аз тарзи кори хотираи фаврӣ хабардор бошад, то битавонад, барномаҳои 
 лозимиро ба таври сареътар нависад. 
 Хотираи фаврӣ ин платаи на онқадар калони микросхемавӣ мебошад, ки 
 бо разъёмҳои махсус ба платаи модари пайваст карда мешавад. Шакли умумии 
 таҷҳизоти хотираи фаврӣ чунин аст: 
 Баъзан хотираи фавриро хотираи динамикӣ низ мегӯянд. Сабабаш дар он 
 аст, ки нисбат ба дигар нигоҳдорандаҳо (ё интиқолдиҳандагон)-и иттилоот 
 (диски дурушт, флейшка ва ғайра) маълумотҳоро зудтар мехонад. Яке аз 
 фарқияти дигари хотираи фаврӣ аз диски дурушт дар он аст, ки хотираи фаврӣ
 ба барқ вобаста мебошад. Аз ин ҷост, ки ҳангоми хомуш гардидани барқ 
 маълумотҳои он нест карда мешаванд. 
 Пеш аз мавриди баҳс қарор додани таҷҳизоти мазкур, хотирнишон мекунем, ки
 воҳиди хурдтарини ахбор бит мебошад. Як бит ин қимати ё мебошад. Асоси
 хотираи фавриро катакчаҳои ба андозаи як бит ташкил медиҳанд, ки шакли 
 матритсаро доранд. Барои навиштани як байт маълумот дар хотираи фаврӣ 
 бит катакча лозим меояд. Намуди умумии катакчаҳои хотираи фаври шакли 
 зеринро доранд: 
 Тавре ки аз ин расм мушоҳида мешавад, катакча воҳиди минималии 
 хотира буда, ба бит баробар мебошад. Барои дар хотираи фаврӣ нигоҳ 
 доштани байт катакчаи пайиҳам лозим меояд. 
 Тавре ки медонем, як барномаи навишташуда метавонад, додаҳои навъҳои 
 гуногунро қоркард кунад. Барои нигоҳ доштани додаҳои ҳар навъ дар хотира 
 минтақае ҷудо карда шуда, сипас амали лозими болои додаҳо иҷро карда 
 мешавад. Барои намуна барномаи кучаки зеринро дида мебароем. 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 int a=; 
 cout<<"Size: "<<sizeof(a)<<endl; 
 cout<<"Value: "<<a<<endl; 
 cout<<"Address: "<< &a<<endl; 
 return; 
 } 
 Дар ин барнома тағйирёбандае аз навъи int эълон карда шуда, ба сифати
 қимати ибтидои барои он қимати бахшида шудааст. Пас аз муаррификунӣ 
 амалҳои зерин иҷро карда шудаанд: 
 ) Муайян намудани андозаи хотира; 
 ) Хориҷ намудани қимати тағйирёбанда; 
 ) Муайян намудани суроғаи тағйирёбанда. 
 Барои иҷрои ин амалҳо аз се сатри барнома, ки шакли зеринро доранд, 
 истифода карда шудааст. 
 cout<<"Size: "<<sizeof(a)<<endl; 
 cout<<"Value: "<<a<<endl; 
 cout<<"Address: "<< &a<<endl; 
 Пас аз иҷроиши барнома натиҷа ба сурати зерин пешниҳод карда 
 мешавад: 
 Size: 
 Value: 
 Address: 
 Тавре ки дида мешавад, дар сатри якум андозаи тағйирёбандаи навъи int,
 дар сатри дуввум қимати тағйирёбанда ва дар сатри сеюм суроғаи тағйирёбанда
 хориҷ карда шудааст. 
 Аз ин ҷо шояд дар зеҳни хонандагон чунин савол пайдо шавад: 
 Барои чӣ тағйирёбандаи навъи int (*) катакчаи хотираи фавриро банд 
 мекунаду, лекин дорои як суроға аст?. Ҷавоби ин суол чунин аст: Суроғаи 
 тағйирёбанда дар хотираи фаврӣ ин катакчаи нахустини хотира аст. Протсессор
 суроғаи нахустин ва андозаи навъи тағйирёбандаро дониста, медонад, ки барои
 он чӣ қадар катакча ҷудо кунад. 
 Тавре ки медонем, ҳамаи додаҳо дар хотира ба намуди дӯи нигоҳ дошта
 мешаванд, аз ин ҷо намуди дуии адади шакли ро дорад. Аз
 ин ҷо он катакчаро аз катакчаи ҷудокардашуда банд мешаваду халос. 
 Бинобар ин маслиҳат дода мешавад, ки аввал дарозии додаҳои лозимиро ба 
 назар гирифта баъд навъи он муайян карда шавад. Масалан агар пешакӣ муайян
 бошад, ки қимати тағйирёбанда аз фосилаи -... берун намебарояд,
 аз навъи short истифода кардан хубтар мебошад, зеро он дар хотира байт 
 ҷойро банд мекунад. 
 Саволҳо барои мустаҳкамкунӣ 
 кардани элементҳои массив ба функсияи фаръӣ чанд роҳ мавҷуд аст? 
 назарашро донад? 
 чӣ қадар ҳофиза лозим мешавад? 
 Масъалаҳо барои кори мустақилона 
 Масъалаҳои гурӯҳи ишорагар ва суроға 
 тағйирёбандаҳо ду ишорагар истифода бурда шавад. Тавассути ишорагар 
 қимати тағйирёбандаи а-ро ду мароти ба зиё д карда, сипас ҷойи қимати
 ва иваз карда шавад. 
 тағ йирёбандаҳо ду ишорагар истифода бурда шавад. Тавассути 
 ишорагарҳо қимати тағйирёбандаи а- ро ҳан гоми иҷроиши шарти ду 
 воҳид зиёд карда, дар ҳолати акс қимати -ро се воҳид кам кунед. 
 тағйирёбандаҳо ду ишорагар истифода ка рда шавад. Тавассути ишорагар
 қимати тағйирёбандаи а-ро се маро тиба з иёд карда, сипас тавассути 
 ишорагарҳо ҷойи қимати онҳо иваз карда шавад. 
 тағйирёбандаҳо се ишорагар истифода карда шавад. Тавассути 
 ишорагарҳо дурустии шарти с анҷид а шавад. 
 тағйирёбандаҳо се ишорага р и ст иф ода карда шавад. Ҳангоми ҷой 
 доштани шарти тавассути и ш ораг арҳо қимати онҳо ду воҳид 
 зиёд карда шавад. 
 тағйирёбандаҳо се ишорагар истифода карда шавад. Ҳангоми ҷой 
 доштани шарти тавассути и ш ораг арҳо қимати онҳо се воҳид 
 кам карда шавад. 
 тағйирёбандаҳо се ишорагар истифода карда шавад. Ҳангоми ҷой 
 доштани шарти тавассути и ш ораг арҳо қимати онҳо се воҳид 
 кам карда шавад. 
 тағйирёбандаҳо се ишорагар истифода карда шавад. Ҳангоми ҷой 
 доштани шарти тавассути ишорагарҳо қимати онҳо ду воҳид 
 зиёд карда шавад. 
 тағйирёбандаҳо се ишорагар истифода карда шавад. Ҳангоми ҷой 
 доштани шарти тавассути и ш ораг арҳо қимати онҳо ду воҳид 
 зиёд карда шавад. 
 тағйирёбандаҳо се ишорагар истифода карда шавад. Тавассути 
 ишорагарҳо қимати ро ду воҳи д, қим ати ро чор воҳид ва 
 қимати ро се воҳид зиёд намоед. 
 тағйирё ба ндаҳо се ишорагар истифода карда шавад. Тавассути 
 ишорагарҳо қимати ро панҷ воҳ и д, қ имати ро ду воҳид ва 
 қимати ро шаш воҳид зиёд намоед. 
 тағйирё ба ндаҳо се ишорагар истифода карда шавад. Тавассути 
 ишорагарҳо қимати ро ду воҳид зи ё д, қим ати ро чор воҳид кам ва 
 қимати ро ду маротиба зиёд намоед. 
 тағйирё ба ндаҳо се ишорагар истифода карда шавад. Тавассути 
 ишорагарҳо қимати ро ду воҳид ка м, қим ати ро чор воҳид зиёд ва 
 қимати ро ду маротиба кам намоед. 
 тағйирё ба ндаҳо се ишорагар истифода карда шавад. Ҳангоми ҷой 
 доштани шарти тавассути и ш ораг арҳо қимати онҳо ду воҳид 
 зиёд ва дар ҳолати акс воҳид кам карда шавад. 
 тағйирёбандаҳо се ишорагар истифода карда шавад. Ҳангоми ҷой 
 доштани шарти тавассути и ш ораг арҳо қимати онҳо ду воҳид 
 зиёд ва дар ҳолати акс воҳид кам карда шавад. 
 тағйирёбандаҳо се ишорагар истифода карда шавад. Ҳангоми ҷой 
 доштани шарти тавассути и ш орага рҳо қимати онҳо ба аломати
 баръакс гардонида шавад, дар ҳолати акс бошад, ду маротиба зиёд карда
 шавад. 
 тағйирёбандаҳо се ишорагар истифода карда шавад. Тавассути 
 ишорагарҳо санҷида шавад, ки оё он ҳо та рафҳои секунҷаро ташкил 
 медиҳанд ё не. 
 тағйирёбандаҳо се ишорагар истифода карда шавад. Тавассути 
 ишорагарҳо санҷида шавад, ки оё м уоди лаи квадрати 
 решаҳои ҳақиқӣ дорад не. 
 тағйирёбандаҳо се ишорагар истифода карда шавад. Ҳангоми ҷой 
 доштани шарти тавассути ишорагарҳо қимати онҳо ба қимати 
 миёнаи арифметикиашон иваз карда шавад, дар ҳолати акс бошад, ду 
 воҳид зиёд карда ш ава н д. 
 тағйирёбандаҳо се ишорагар истифода карда шавад. Ҳангоми ҷой 
 доштани шарти тавассути иш орага рҳо қимати онҳо ба қимати 
 миёнаи геометриашон иваз карда шавад, дар ҳолати акс бошад, ду воҳид
 зиёд карда шаван д. 
 Масъалаҳои гурӯҳи ишорагар ва ҳофизаи динамикӣ 
 ҷудо намоед. Барои ҳофизаҳои ҷудокардашуда аз калавиатура қимат 
 ворид карда, сипас қимати тағйирёбандаи якум мартиба кам карда 
 шавад. 
 ҷудо намоед. Барои ҳофизаҳои ҷудокардашуда аз калавиатура қимат 
 ворид карда, Сипас қимати тағйирёбандаи дуюм мартиба зиёд карда 
 шавад. 
 динамикӣ ҷудо намоед. Барои ҳофизаҳои ҷудокардашуда аз калавиатура 
 қимат ворид кунед. 
 динамикӣ ҷудо намоед. Барои ҳофизаҳои ҷудокардашуда мувофиқан 
 қиматҳои true () ва false () бахшед. 
 динамикӣ ҷудо намоед. Барои ҳофизаҳои ҷудокардашуда ба таври 
 тасодуфӣ қимат бахшед. 
 динамикӣ ҷудо намоед. Барои ҳофизаҳои ҷудокардашуда ба таври 
 тасодуфӣ қимат бахшида, сипас қимати ишорагари якум ду маротиба кам 
 карда шавад. 
 ҷудо намоед. Барои ҳофизаҳои ҷудокардашуда ба таври тасодуфӣ қимат 
 бахшида, сипас қимати ишорагари якум ду маротиба зиёд ва қимати ду 
 ишорагари баъдӣ воҳид кам карда шавад. 
 ҷудо намоед. Барои ҳофизаҳои ҷудокардашуда аз калавиатура қимат 
 ворид карда, Сипас ҷойи қимати онҳоро иваз кунед. 
 динамикӣ ҷудо намоед. Барои ҳофизаҳои ҷудокардашуда аз калавиатура 
 қимат ворид карда, сипас ҷойи қимати дуто ишорагари авваларо иваз 
 кунед. 
 динамикӣ ҷудо намоед. Барои ҳофизаҳои ҷудокардашуда мувофиқан 
 қиматҳои true () ва false () бахшеда, сипас ҷойи қимати онҳо иваз карда
 шавад. 
 ҷудо намоед. Сипас барои ҳофизаҳои ҷудокардашуда аз калавиатура 
 қимат ворид намоед. 
 ҷудо намоед. Барои ҳофизаи ҷудокардашуда аз калавиатура қимат ворид 
 карда, сипас онро мартиба зиёд кунед. 
 динамикӣ ҷудо намоед. Барои ҳофизаҳои ҷудокардашуда аз калавиатура 
 қимат ворид кунед. Сипас ҷойи қимати ду ишорагари охиронро иваз 
 намоед. 
 динамикӣ ҷудо намоед. барои ҳофизаҳои ҷудокардашуда ба таври 
 тасодуфӣ қимат бахшед. Қимати миёнаи арифметикии онҳоро ҳисоб 
 кунед. 
 динамикӣ ҷудо намоед. Барои ҳофизаҳои ҷудокардашуда ба таври 
 тасодуфӣ қимат бахшед. 
 динамикӣ ҷудо намоед. Барои ҳофизаҳои ҷудокардашуда ба таври 
 тасодуфӣ қимат бахшед. Ҳан го м и иҷроиши шарти қимати онҳо 
 ду маротиба кам карда шавад. 
 динамикӣ ҷудо намоед. Барои ҳофизаҳои ҷудокардашуда ба таври 
 тасодуфӣ қимат бахшед. Ҳ а н г о м и иҷроиши шарти қимати 
 ишорагари якум ду маротиба кам ва қимати ду ишорагари баъдӣ воҳид 
 зиёд карда шавад. 
 динамикӣ ҷудо намоед. Барои ҳофизаҳои ҷудокардашуда аз калавиатура 
 қимат ворид карда, ҳангом и ҷ ой доштани шарти ҷойи қимати 
 онҳоро иваз кунед. 
 динамикӣ ҷудо намоед. Барои ҳофизаҳои ҷудокардашуда ба таври 
 тасодуфӣ қимат бахшед. Ҳ а н г о м и иҷроиши шарти қимати 
 ишорагари якум ду маротиба кам ва қимати ду ишорагари баъдӣ воҳид 
 зиёд карда шавад. 
 динамикӣ ҷудо намоед. Барои ҳофизаҳои ҷудокардашуда ба таври 
 тасодуфӣ қимат бахшед. Ҳ а н г о м и иҷроиши шарти қимати 
 ишорагари якум ду маротиба зиёд ва қимати ду ишорагари баъдӣ се 
 маротиба кам карда шавад. 
 Масъалаҳои гурӯҳи массивӣ динамикӣ 
 шудани массиви рақами тартиби ва ҳосили зарби элементҳои аз 
 хурди онро ҳисоб кунед. 
 шудани массиви рақами тартиби ва ҳосили ҷамъи элементҳои аз 
 хурди онро ҳисоб кунед. 
 шудани массиви ва b(m) муайян кунед, ки элементи нахустини 
 массиви дар массиви чанд маротиба во мехӯрад. 
 шудани м ассиви ва b(m) муайян кунед, ки элементи дуюми массиви 
 дар массиви чанд маротиба во мехурад. 
 ш удани массив и ва b(m) муайян кунед, ки элементи охирони 
 массиви дар массиви чанд маротиба во мехурад. 
 шудани м ассиви в а b(m) муайян кунед, ки элементҳои мусбати 
 кадоме аз ин масивҳо бештар аст? 
 шудани массиви ва b(m) муайян кунед, ки элементҳои манфии 
 кадоме аз ин масивҳо бештар аст?. 
 шудани массиви элементҳои мусбати он ба квадрат бардошта 
 шаванд. 
 шудани массиви элементҳои манфии он ду воҳид кам карда шаванд. 
 шудани массиви ва b(m) муайян кунед, ки элементҳои мусбати 
 кадоме аз ин масивҳо камтар аст?. 
 шудани массиви ва b(m) элементҳои мусбати массиви панҷ 
 воҳид зиёд ва элементҳои манфии массиви ду воҳид кам кунед. 
 шудани массиви элементҳои мусбати о н ро б а иваз кунед. 
 шудани массиви ҳамаи элементҳоеро, ки аз элементи охирон 
 хурданд ду воҳид зиёд карда, элементҳои боқимондаро воҳид кам кунед.
 шудани массиви ҳамаи элементҳоеро, ки аз адади додашудаи 
 хурданд ду воҳид зиёд карда, элементҳои боқимондаро маротиба кам 
 кунед. 
 шудани массиви ҳамаи элементҳоеро, ки аз адади додашудаи 
 калонанд се воҳид зиёд карда, элементҳои боқимондаро маротиба кам 
 кунед. 
 шудани массиви ҳамаи элементҳоеро, ки шарти 
 ро қонеъ мекунонанд, се воҳид зиёд карда, элементҳои 
 боқимондаро воҳи д к ам кунед. 
 шудани массиви сумммаи ҳамаи элементҳоеро, ки шарти 
 ро қонеъ мекунонанд ҳисоб кунед. 
 ш у д а ни м ас си в и ҳамаи элементҳоеро, ки аз элементи дуюм калонанд
 воҳид кам кунед. 
 шудани массиви ҳамаи элементҳоеро, ки аз решаи квадратии адади 
 додашудаи хурданд се воҳид зиёд карда, элементҳои боқимондаро ду 
 маротиба кам кун е д. 
 шудани массиви ҳамаи элементҳоеро, ки аз адади додашудаи 
 калонанд ба квадрат бардошта, элементҳои боқимондаро ду маротиба 
 зиёд кунед. 
 Масъалаҳои гурӯҳи ишорагарҳо ва мураттабсозӣ 
 шудани массиви ҳамаи элементҳои мусбати онро ба зарб карда, дар 
 масиви нигоҳ доред (бахшед). Сипас, тавасути методи 
 мураттабсозии о нҳоро мураттаб созед. 
 шудани массиви ҳамаи элементҳои манфии онро ба зарб карда, дар 
 масиви нигоҳ доред (бахшед). Сипас, тавасути методи 
 мураттабсозии ҳу б о б ӣ онҳоро мураттаб созед. 
 шудани массиви ҳамаи элементҳои мусбати онро ба зарб карда, дар 
 масиви нигоҳ доред (бахшед). Сипас, тавасути методи 
 мураттабсозии ин т и х обӣ онҳоро мураттаб созед. 
 шудани массиви ҳамаи элементҳои мусбати онро ба тақсим карда, 
 дар масиви нигоҳ доред (бахшед). Сипас, тавасути методи 
 мураттабсозии зу д ( q uick) онҳоро мураттаб созед. 
 шудани массиви ҳамаи элементҳои манфии онро ба тақсим карда, 
 дар масиви нигоҳ доред (бахшед). Сипас, тавасути методи 
 мураттабсозии tag о н ҳоро мураттаб созед. 
 шудани массиви ҳамаи элементҳои мусбати онро дар масиви 
 нигоҳ доред (бахшед). Сипас, тавасути методи мураттабсозии 
 гузориши онҳоро мураттаб созед. 
 шудани массиви ҳамаи элементҳои мусбати онро дар масиви 
 нигоҳ доред (бахшед). Сипас, тавасути методи мураттабсозии 
 гузориши онҳоро м у р аттаб созед. 
 шудани массиви ҳамаи элементҳои манфии онро дар масиви 
 нигоҳ доред (бахшед). Сипас, тавасути методи зуд онҳоро 
 мураттаб созед. 
 шудани массиви ҳамаи элементҳои манфии онро дар масиви 
 нигоҳ доред (бахшед). Сипас, тавасути методи мураттабсозии зуд
 онҳоро бо тартиби к а мшавӣ мураттаб намоед. 
 шудани массиви ҳамаи элементҳои манфии онро ба квадрат 
 бардошта, дар масиви нигоҳ доред (бахшед). Сипас, 
 тавасути методи м у р а ттабсозии интихоб онҳоро бо тартиби камшавӣ 
 мураттаб намоед. 
 шудани массиви решаи квадратии ҳамаи элементҳои мусбати онро 
 дар масиви нигоҳ доред (бахшед). Сипас бо истифода аз 
 методи мураттабс о з и и зуд онҳоро бо тартиби камшавӣ мураттаб кунед.
 шудани массиви ҳамаи элементҳои манфии ду воҳид кам карда, дар 
 масиви нигоҳ доред (бахшед). Сипас, тавасути методи 
 мураттабсозии ҳу б о б ӣ онҳоро мураттаб созед. 
 шудани массиви квадрати ҳамаи элементҳои мусбати онро ба зарб 
 карда, дар масиви нигоҳ доред (бахшед). Сипас, тавасути 
 методи мураттабс о з и и интихобӣ онҳоро мураттаб созед. 
 шудани массиви ҳамаи элементҳои ҷуфти онро, дар масиви 
 нигоҳ доред (бахшед). Сипас, тавасути методи мураттабсозии 
 quick) онҳоро мур ат та б созед. 
 шудани массиви ҳамаи элементҳои ҷуфти манфии онро ба зарб 
 карда, дар масиви нигоҳ доред (бахшед). Сипас, тавасути 
 методи мураттабс о з и и tag онҳоро мураттаб созед. 
 шудани массиви ҳамаи элементҳои тоқи онро дар масиви 
 нигоҳ доред (бахшед). Сипас, тавасути методи мураттабсозии 
 гузориши онҳоро м у ра ттаб созед. 
 шудани массиви ҳамаи элементҳои шарти 
 ро қаноаткунонандаи онро дар масиви нигоҳ доред 
 (бахшед). Сипас, тавасути методи мураттабсозии гузориши онҳоро 
 м ур аттаб созед. 
 шудани массиви ҳамаи элементҳои шарти 
 қаноаткунонандаи онро дар масиви нигоҳ доред (бахшед). 
 Сипас, тавасути мето д и з уд онҳоро мураттаб созед. 
 шудани массиви ҳамаи элементҳои манфии онро ба аломати баръакс 
 иваз карда, дар масиви нигоҳ доред (бахшед). Сипас, 
 тавасути методи з у д онҳоро бо тартиби камшавӣ мураттаб намоед. 
 шудани массиви ҳамаи элементҳои соддаи онро дар масиви 
 нигоҳ доред (бахшед). Сипас, тавасути методи интихоб онҳоро 
 бо тартиби камша вӣ м ураттаб намоед. 
 Боби. Кор бо сатрҳо ва рамзҳо 
 Муқаддима 
 Ҳар гуна матн дар компютер ба намуди ададӣ нигоҳ дошта мешавад. 
 Мувофиқи стандарти кодгузории ASCII (American standard code for Information
 Interchange) ҳар рамз дорои коди махсусе мебошад. Дар забони с++ додаҳои 
 навъи char низ ҳамчун адади бутун фаҳмида шуда, фосилаи қиматҳояшон аз 
 то мебошад. Наҳви муаррификунии додаҳои навъи мазкур намуди зеринро 
 доранд: 
 char *str=”Salom!” 
 Барои сатри мазкур, дар забонии С++ ҳафт байт ҳофиза ҷудо карда 
 мешавад. Ҳар як рамз як байт фаҳмида шуда, нишонаи ба охир-расии сатр низ
 ҳамчун як байт фаҳмида мешавад. 
 Дар компютер як байт аз бит иборат мебошад, дар навбати худ ҳар бит
 метавонад аз ду қимати системаи ҳисоби дуи ё -ро қабул кунад. Аз ин рӯ,
 сатри мо намуди зеринро мегирад. 
 Ҳарф S a L O m! 
 ASCII-коди ҳарф 
 Битҳои код 
 Ба тағйирёбандаҳои рамзӣ бахшидани қимати аввала 
 Тағйирёбандаҳои рамзӣ низ монанди тағйирёбандаҳои дигар муаррифӣ 
 карда мешаванд ва ҳангоми муаррификунии чунин тағйирёбандаҳо метавон ба 
 онҳо қимати аввала бахшид. 
 Дар забони С++ сатрҳо ҳамчун массивҳои рамзӣ шинохта шуда, охири он 
 ба рамзи Null (охири сатр ) ба поён мерасад. Дар дохили барнома рамзи мазкур
 дар қолаб (форма)-и escape squance бо ‘\’ нишон дода мешавад. Зернависи 
 поёнии элементҳои массиви навъи сатрҳо буда, зернависи болоӣ бошад, якто
 кам аз миқдори рамзҳои ҳамон сатр ба ҳисоб меравад. Масалан, сатри «Hello
 world» як массиви рамзии дорои рамз мебошад. Дар ин навъ массивҳо ҷойи
 холӣ низ ҳамчун як элемент фаҳмида мешавад. Ба массивҳои сатрӣ дар вақти 
 муаррифӣ намудан, метавон қимати аввала бахшид. Ба дастури зерин диққат 
 диҳед: 
 char Arsatr[]=”Hello World”; 
 Массиви муаррифишуда дорои элемент мебошад. Инчунин массивҳои 
 сатрӣ метавонанд ҳар як элементашон алоҳида бошад. Масалан, массиви 
 Arsatr-ро метавон ба сурати зерин низ эълон кард: 
 char Arsatr[]={‘H’,’e’,’l’,’l’,’o’,’\‘,’W’,’o’,’r’,’l’,’d’}
 Тавре ки дида мешавад, дар ин ҷо ҳар як элементи массиви рамзӣ дар 
 дохили нохунаки якто-якто (апостроф) навишта шуда, барои ҷойи холӣ 
 (фосила) рамзи ’\‘ истифода шудааст ва оператори коммо бошад, барои аз 
 ҳамдигар ҷудо намудани рамзҳо ба кор рафтааст. Барои дар ин навъ массивҳо
 ба элементи зарури дастрас шудан аз зернависи (рақами тартиби)-и рамзҳо 
 истифода бурда мешавад. 
 Монанди дигар массивҳо, зернависи элементҳои массиви рамзӣ низ аз нол
 оғоз ёфта, ба n- ба охир мерасад, яъне дар массиви мазкур элементи нолум ин
 рамзи (ҳарфи ) «H» буда, элементи n- ()-ум рамзи «d» мебошад. 
 Мисол. Барномае нависед, ки ҳамаи элементҳои массиви Arsatr[]-ро ба 
 чоп диҳад. Инчунин элементи аввалин ва охиринашро низ алоҳида ба чоп 
 диҳад. 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 const int n=; 
 cout<<"Massivi dodoshuda="; 
 char Arsatr[]={’H’,’e’,’l’,’l’,’o’,’\’,’W’,’o’,’r’,’l’,’d’}; 
 for (int i=;i<n;i++) 
 cout<<Arsatr[i]; 
 return; 
 } 
 Чи хеле ки мебинем, дар ин ҷо авввал доимие муаррифӣ шуда аст, пас аз
 он массив бо элементҳои аввалааш таъриф шудааст. Оператори даврӣ то замони
 ба охир расидани элементҳои массив такрор шуда, дар ҳар итератсия (давр ё
 қадам) як элементро ба саҳифаи тасвир хориҷ мекунад. 
 Ҳангоми сатрҳоро ба намуди муқаррарӣ эълон кардан, метавон қимати 
 онҳоро аз клавиатура ворид кард. Мисол: 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 char chr[]; 
 cout<<"Enter you name, please "<<endl; 
 cin>>chr; 
 cout<<"You name is:"<<chr<<endl; 
 return; 
 } 
 Натиҷаи барнома шакли зеринро дорад: 
 Enter you name, please 
 Ali 
 You name is: Ali 
 Чунончи аз мисол бармеояд, ҳангоми ворид кардани сатр оператори 
 дохилкунии cin то мавқеи фосила рамзҳоро қабул кардаасту халос. Рамзҳои пас
 аз ҷои холӣ омада хонда нашуданд. Барои дастрас шудани тамоми сатр аз 
 функсияи gets истифода бурда мешавад. Аз ин ҷо барномаи боло намуди 
 зеринро мегирад. 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 char chr[]; 
 cout<<"Enter you name, please "<<endl; 
 gets(chr); 
 cout<<"You name is:"<<chr<<endl; 
 return; 
 } 
 Тавре ки дида мешавад, дар ин ҷо функсияи getsба миқдори андозаи 
 массив символҳои дохилкардашударо мехонад. 
 Дар забони С++ тағйирёбандаҳои навъи char ҳамчун адади бутун 
 фаҳмида мешавад. Аз рӯи кодгузории ASCII ҳар як рамз дорои қи-мати ададӣ 
 аст. Аз ин хотир, метавон элементҳои массивро рамз ба рамз дохил кард. 
 Мисол: 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 char chr[]; 
 int n=; 
 char s=’a’; 
 for (int i=;i<n;i++) 
 chr[i]=s+i; 
 chr[n]=’\’; 
 cout<<chr<<endl; 
 return; 
 } 
 Натиҷаи барнома ба сурати зерин аст. 
 abcdefhi….z 
 Функсияҳои кор бо рамзҳо 
 Ҳамаи маълумот ба компютер ҳамчун рамзҳо дохил карда мешаванд. Рамз 
 ягон ҳарф ишора ва ё рақам мебошад. Сатр бошад, аз пайдарпайии рамзҳо 
 таркиб ёфтааст. Дар забонии С++ барои кор кардан ба рамзҳо якчанд функсияҳо
 мавҷуданд, ки ҳангоми пайваст намудани китобхонаи <ctype.h> барои 
 истифодабаранда дастрас мегарданд. Дар ҷадвали зерин рӯйхати якчандто аз ин
 функсияҳо оварда шудааст. 
 № Номи функсия Маъно ва мафҳум 
 int isdigit (int c) Дорои қимати true аст, агар аргументи он яке аз 
 рақамҳои аз то бошад, дар акси ҳол дорои қимати 
 false мегардад. 
 int isalpha(int c) Дорои қимати true аст, агар аргументи он ҳарф бошад,
 дар акси ҳол дорои қимати false мегардад. 
 int isalnum(int c) Дорои қимати ҳақ аст, агар аргументи он ҳарф ва ё 
 рақам бошад. 
 int isхdigit (int c) Дорои қимати true аст, агар аргументи он адади 
 системаи шонздаҳӣ бошад, дар акси ҳол дорои қимати 
 false мегардад. 
 int islower(int c) Дорои қимати true аст, агар аргументи он ҳарфи хурд
 бошад, дар акси ҳол дорои қимати false мегардад. 
 Функсия танҳо барои ҳарфҳои лотинӣкор мекунад. 
 int isupper (int c) баръакси функсияи islower(int c) амал мекунад. 
 int tolower (int c) Агар аргументи ин функсия ҳарфи калон бошад, онро 
 ба ҳарфи кучак табдил медиҳад. 
 int toupper (int c) Баръакси функсияи tolower (int c) мебошад. 
 int isspace(int c) ба қимати true баробар аст, агар аргументи он яке аз
 рамзҳои ҷудокунанда бошанд ба монанди: гузаштан ба 
 сатри нав(‘\n’), гузаштан ба саҳифаи нав (‘\f’ ), 
 гузаштани сархати уфуқӣ (‘\t’), гузаштани сархати 
 амудӣ(‘\v’), (carriage return) (‘\r’) 
 дар акси ҳол бошад, дорои қимати false мешавад. 
 int ispunct(int c) ба қимати ҳ а қ д о р о а с т, а г ар аргументи он рамзи
 пунктуатсия бошад. Рамзҳои пун-туаксия: фосила, 
 рақам, ҳарф ва ғайра мебо-шанд. 
 int isprint(int c) Ба қимати ҳақ доро аст, агар аргументи он символи 
 чопшаванда бошад. 
 isgraph(int c) Ба қимати ҳақ доро аст, агар аргументи он сим-воли 
 чопи бошад, ба ғайр аз фосила. 
 Қайд. Бозгашти навард (carriage return)- символи идоракунӣё 
 механизмест, ки барои мавқеи курсорро ба аввали сатр овардан хизмат 
 мекунад. 
 Мисол. Истифодаи функсияҳои isdigit(), isalpha(),isalnum() ва isхdigit().
 Барномае нависед, ки бо дохил кардани рамз муайян кунад, ки он рақам, ҳарф,
 ва ё рақами системаи ҳисоби шонздаҳӣ мебошад. 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 char chr; 
 int i=; 
 while(++i<) 
 { 
 cout<<"chr=";cin>>chr; 
 cout<<"Simvoli "<<chr<<(isdigit(chr)? " raqam hast": " 
 raqam nest")<<endl; 
 cout<<"Simvoli "<<chr<<(isalpha(chr)? " harf hast": " harf 
 nest")<<endl; 
 cout<<"Simvoli "<<chr<<(isxdigit(chr)? " raqami sistemai 
 hisobi shonzdahi ast": " raqami sistemai hisobi shonzdahi 
 nest")<<endl; 
 cout<<"Simvoli "<<chr<<(isalnum(chr)? " harf yo raqam 
 hast": " harf yo raqam nest")<<endl; 
 } 
 return; 
 } 
 Мисол. Истифодаи функсияҳои islower() ва isupper(). Барномае нависед,
 ки бо дохил кардани ҳарф муайян кунад, ки он хурд аст ё калон. 
 #include <iostream> 
 #include <ctype.h> 
 using namespace std; 
 int main(){ 
 char chr; 
 int i=; 
 while(++i<) 
 { 
 cout<<"chr=";cin>>chr; 
 cout<<"Simvoli "<<chr<<(islower(chr)? " harfi hurd ast": " 
 harfi hurd nest")<<endl; 
 cout<<"Simvoli "<<chr<<(isupper(chr)?" harfi kalon ast": " 
 harfi kalon nest")<<endl; 
 } 
 return; 
 } 
 Функсияи get ва getline 
 Функсияи get барои дохилкунии як рамз истифода шуда, метавонад 
 ҳангоми дохилкунӣ дорои аргумент ва ё беаргумент бошад. яъне, он метавонад,
 қимати воридшударо ба аргументи худ ва ё ба ягон тағйирёбандаи дигар 
 бахшад. Мисол: 
 #include <iostream> 
 #include <ctype.h> 
 using namespace std; 
 int main(){ 
 char chr; 
 chr=cin.get(); 
 cout.put(chr); 
 return; 
 } 
 Тавре ки дар ин мисол дида мешавад, функсияи мазкур якҷоя бо 
 оператори дохилкунии cin истифода шуда, қимати воридшударо ба 
 тағйирёбандаи chr бахшидааст. Илова бар ин, онро ба сурати зерин низ метавон
 истифода кард. 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 char chr; 
 cin.get(chr); 
 cout.put(chr); 
 cout.put(chr); 
 return; 
 } 
 Аз ин мисол аён мегардад, ки функсияи get() тағйирёбандаи лозимиро 
 ҳамчун аргумент қабул намуда, қимати онро вориди барнома намудааст. 
 Ҳангоми дохил намудан якчанд рамз функсияи get() танҳо рамзи нахустинро 
 мехонаду халос. Масалан, ҳангоми ворид кардани якчанд рамз натиҷа намуди 
 зеринро мегирад. 
 Input: Computer 
 Output: C 
 Равиши дуюми истифодабарии ин функсия ба аргументи рамзӣ то расидан 
 ба нишонаи интиҳои матн пайиҳам рамзҳоро мебахшад. Ин равишро баъдтар 
 ҳангоми истифодабарии операторҳои идоракунӣ дида мебароем. 
 Равиши сеюми истифодаи ин функсия дорои се параметр мебошад. 
 Массиви рамзӣ (ягон сатр), адади максималии микдори рамзҳои массив ва 
 рамзи идоракунанда хусусан (‘\n’). Ин равиши истифодабарии рамзҳоро то 
 замоне ки аз микдори максималии дода-шуда як воҳид хурданд мехонад, яъне 
 (max-)-рамзро мехонад. Баъдан барои ба охиррасии сатрҳои дохилшуда дар 
 массиви рамзӣ ба сифати буфери барнома рамзи нулӣ истифода бурда мешавад.
 Мисол: 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 const int Size=; 
 char Satr[Size]; 
 cin.get(Satr,Size); 
 cout<<Satr<<" \n "; 
 return; 
 } 
 Натиҷаи барнома ба намуди зерин аст: 
 Computer 
 Comp 
 Функсияи getline () бошад, монанди равиши сеюми функсияи get() буда,
 чи қадаре ки микдори максималӣ бошад, ҳамон қадар рамзро хонда, рамзи 
 махдудкунандаро аз ҷараён нест мекунад, яъне онро ба рамзи массив сабт 
 намекунад. Мисол: 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 const int Size=; 
 char Satr[Size]; 
 cin.getline(Satr,Size); 
 cout<<Satr<<" \n "; 
 return; 
 } 
 Функсияи мазкур, бештар ҳангоми ягон файли маълумотро хондан, 
 истифода бурда мешавад, ки дар оянда дар мавзӯи файлҳо муфассал ин 
 матолибро мавриди баҳс қарор медиҳем. 
 Функсияҳои табдилдиҳии сатрҳо 
 Бисёр додаҳо дар аввал ба намуди матнӣ дода мешаванд, масалан, бигзор
 якчанд адад дар дохили як матн дода шуда бошанд, барои онҳоро истифода 
 бурдан, ба мо лозим меояд, ки навъи онҳоро аз сатрӣ ба ададӣ гардонем. Барои
 иҷро ин амал, С++ ба мо имконият медиҳад, то аз функсияҳое, ки дар 
 китобхонаи <stdlib> мавҷуданд, истифода барем. Дар ҷадвали поён якчандто аз
 ин функсияҳо оварда шудааст. Барои бо ин функсияҳо кор кардан, бояд 
 китобхонаи <stdlib> пайваст карда шавад. 
 № Наҳви функсия Маъно ва мафҳум 
 double atof (const char *nPtr) Сатри nPt-ро ба адади навъи double 
 табдил медиҳад. 
 double atoi (const char *nPtr) Сатри nPt-ро ба адади навъи int 
 табдил медиҳад. 
 double strtod (const char *nPtr) Сатри nPt-ро ба адади навъи long int
 табдил медиҳад. 
 long strtol (const char *nPtr,char Сатри nPt-ро ба адади навъи long 
 *endPtr, int base) табдил медиҳад. 
 unsigned long stsrtoul (const char Сатри nPt-ро ба адади навъи 
 *nPtr,char *endPtr, int base unsigned long табдил медиҳад. 
 Истифодаи функсияҳои табдилдиҳии сатрҳо 
 ) Функсияи atof(), atoi() ва atol() барои додаҳои ададии дар дохили
 нохунак навишта ва ё дар файл ҷойгирбударо мувофиқан ба намудҳои ҳақиқӣ 
 ва бутуни дароз (long) табдил додан хизмат мекунанд. Мисол: 
 #include <iostream> 
 #include <stdlib.h> 
 using namespace std; 
 int main(){ 
 double Db; 
 int In; 
 long Lg; 
 char *d,*I,*L; 
 d="."; 
 I=""; 
 L=""; 
 Db=(atof(d)+)/; 
 In=*atoi(I)-; 
 Lg=-atol(L); 
 cout<<"Db="<<Db<<"\nIn="<<In<<"\nLg="<<Lg<<endl; 
 return; 
 } 
 Тавре ки дида мешавад, дар аввал тағйирёбандаҳои d, I ва L аз навъи
 char муаррифӣ гардидаанд ва баъд ба онҳо қимате ихтисос дода шудааст. 
 Сипас, дар ифодаҳои муҳосиботӣ бо истифодаи аз функсияҳои atof(), atoi() ва
 atol() навъи онҳо ба намуди ададӣ гардонида шудаааст. Баъдан бо ёрии 
 оператори хориҷкуни қимати ифодаҳои муҳосиботӣ ба чоп дода шудааст. 
 ) Функсияи strtod() - функсия дорои ду аргумент, яке аз навъи char ва
 дигаре аз навъи ишорагар буда, қимати ададиро аз дохили сатр ҷудо мекунад
 (бармегардонад). Тағйирёбандаи ишорагар бошад, қисми боқимондаи сатрро 
 бармегардонад, ин дар ҳолатест, ки агар адад дар аввали сатр бошад. Мисол:
 #include <iostream> 
 sing namespace std; 
 int main(){ 
 double d; 
 const char *chr=". adadi haqiqi ast"; 
 char *chr; 
 d=strtod(chr,&chr); 
 cout<<"chr="<<chr<<"\nd="<<d<<"\nchr="<<chr<<endl; 
 return; 
 } 
 ) Функсияи strtol() аз пайдапайии рамзҳо адади навъи long-ро бар 
 мегардонад. Функсияи мазкур дорои се параметр аст, ки якеаш сатри додашуда,
 дигараш ишорагар ба сатр ва аргументи сеюм бошад, адади бутуни фосилаи 
 то мебошад. Аксаран ба ҷойи аргументи сеюм адади нолро истифода 
 мекунанд. Тағйирёбандаи ишорагар ҳамон қисматеро, ки пас аз гирифтани 
 адади long боқӣ гузошта шудааст, дар худ нигоҳ медорад. Мисол: 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 long d; 
 const char *chr="-abc"; 
 char *chr; 
 d=strtol(chr,&chr,); 
 cout<<"chr="<<chr<<"\nd="<<d<<"\nchr="<<chr<<endl; 
 return; 
 } 
 ) Функсияи strtoul()-монанди функсияи strtol() аз пайдарпайии символҳо
 адади дарози беаломат (unsigned )-ро бармегардонад. Функсияи мазкур низ 
 дорои се параметр мебошад, ки параметри якум, сатре ки бояд онро ба адад 
 табдил диҳем, парамети дуввум тағйирёбандаи ишорагари сатрӣ, ки бақияи 
 сатри додашударо бармегардонад ва параметри саввум адади бутуни аз то 
 мебошад. Мисол: 
 #include <iostream> 
 #include <string> 
 using namespace std; 
 int main(){ 
 long d; 
 const char *chr="abc"; 
 char *chr; 
 d=strtoul(chr,&chr,); 
 cout<<"chr="<<chr<<"\nd="<<d<<"\nchr="<<chr<<endl; 
 return; 
 } 
 Функсияҳои ҷустуҷӯи аз китобхонаи кор бо сатрҳо 
 Ҳангоми навиштани барномаҳои калонтар, дар онҳо кор кардан ба сатрҳо
 ва рамзҳо лозим аст. Баъзан лозим мешавад, як сатрро аз дохили сатри дигар
 ҷустуҷӯ кунем. Барои иҷрои ин амалҳо С++ ба мо имконият медиҳад, ки аз 
 функсияҳои тайёр, ки дар китобхонаҳои <string.h> ҷойгиранд, истифода 
 намоем. Дар ҷадвали зерин якчандто аз он функсияҳо оварда шудаанд. 
 № Наҳви функсия Маъно ва мафҳум 
 char *strchr(const Маҳалли аввалини рамзи с-ро дар сатри S ҷустуҷӯ 
 char *S,int n) мекунад, агар пайдо шуд, як ишорагар ба с 
 баргардонида мешавад ва дар акси ҳол як ишорагари 
 Null баргардонида мешавад. 
 char *strrchr(const Маҳалли охирини рамзи с-ро дар сатри S ҷустуҷӯ 
 char *S,int с) мекунад, агар пайдо шуд, як ишорагар ба с 
 баргардонида мешавад ва дар акси ҳол як ишорагари 
 Null баргардонида мешавад. 
 size_t strspn (const Қисми аввалаи сатри S, ки танҳо аз рамзҳои сатри S
 char *S,const *chsr иборат аст муайян мекунад. 
 S) 
 char *strpbrk(const Маҳалли вуқуъи аввалини симво-ли сатри S-ро дар 
 char *S,const *chsr сатри S ҷустуҷӯ мекунад, агар пайдо шуд, як 
 S) ишорагар ба ин рамз дар S баргардонида мешавад. 
 Дар ҳолати акс қимати ‘\’ бармегардонад. 
 size_t strcspn(const Қисми аввалаи сатри S, ки дар он рамзҳои сатри S
 char *S,const *chsr намехобанд, муайян мекунад. 
 S) 
 char *strstrr(const Маҳалли аввалини ҷойгиршавии сатри S-ро дар сатри
 char *S,const *chsr S муайян мекунад, агар пайдо шавад, як ишорагар 
 S) дар дохили S баргардонида мешавад ва дар ҳолати 
 акс як ишорагари Null баргардонида мешавад. 
 Тавре ки аз ин ҷадвал дида мешавад, функсияҳои strcspn() ва strspn()
 дорои навъ (type)-и size_t мебошанд. Ин навъи додашуда дар ҳолати стандарти
 ҳамчун навъи бутун буда, амали sizeof-ро муайян мекунад, яъне он ба навъҳои
 unsigned int ё unsigned long муродиф мебошад. 
 Мисол. Истифодаи функсияи strchr(). 
 #include <iostream> 
 #include <string> 
 using namespace std; 
 int main(){ 
 const char *S="matematica"; 
 char c=’e’; 
 cout<<strchr(S,c)<<endl; 
 return; 
 } 
 Натиҷаи барнома чунин аст: ematica 
 Истифодаи функсияи strcspn()-ин функсия сатри якум ва дуюмро бо ҳам 
 муқоиса мекунад ва миқдори рамзҳоеро, ки дар сатри якум ҳастанду дар дуюм
 нестанд, бармегардонад. 
 #include <iostream> 
 #include <string> 
 using namespace std; 
 int main(){ 
 const char *S="Qimati Pi=."; 
 char *S=""; 
 cout<<strcspn(S,S)<<endl; 
 return; 
 } 
 Натиҷаи барнома чунин аст: 
 Мисол. Истифодаи функсияи strpbrk()-ин функсия ду сатрро муқоиса 
 мекунад. Агар ягон рамзи сатри дуюм дар сатри якум мавҷуд бошад, ишорагар
 онро бармегардонад, вагарна қимати null бармегардонад. 
 #include <iostream> 
 #include <string> 
 using namespace std; 
 int main(){ 
 const char *S="Qimati Pi=. meboshad"; 
 char *S="Adadi doimi ast."; 
 cout<<strpbrk(S,S)<<endl; 
 return; 
 } 
 Ин барнома ҳар ду сатрҳоро муқоиса карда, шурӯъ аз он рамзе, ки бо он
 сатри якум ба охир расидааст, сатри дуввумро бармегардонад. 
 Функсияҳои кор бо ҳофиза аз китобхонаи коркарди сатрҳо 
 Китобхонаи коркарди сатрҳо дорои функсияҳои зиёде ҳаст, ки барои 
 нусхабардорӣ, муқоисакунӣ ва ҷустуҷӯи қисмате аз хотира истифода мешаванд.
 Функсияҳои коркарди сатрҳо ба сифати ба охиррасӣ ё анҷомёбӣ қимати ‘\’ ё
 Null –ро қабул мекунанд, зеро ин функсия амали массиви рамзиро иҷро 
 мекунад. 
 № Наҳви Маъно ва мафҳум 
 функсия 
 void *memcpy(void *S, const void *S, size_t n) 
 n-рамзи нишондодашударо аз объекти S нусха-бардорӣ карда, 
 ба S мегузаронад. 
 void *memmove(void *S, const void *S, size_t n) 
 n-рамзи объектеро, ки дар сатри S нишон додааст, 
 нусхабардорӣ карда, ба сатри S мегузаронад. 
 int *memcmp(const void *S, const void *S, size_t n) 
 n-рамзи нишондодашудаи объекти S-ро ба S муқоиса 
 мекунад. Агар онҳо бо ҳам баробар бошанд, қимати, ҳангоми 
 S аз S хурд будан, қимати манфӣ ва дар акси ҳол, қимати 
 мусбат бармегардонад. 
 void *memchr(const void *S, int c, size_t n) 
 Рамзи аввалаи дохилкардашударо муайян намуда, ба unsigned 
 char табдил медиҳад ва мавқеи аввалаи аргументи с-ро дар 
 объекти S ҷустуҷӯ мекунад, агар пайдо шуд, ишорагар онро 
 бармегардонад. Дар акси ҳол қимати Null бармегардонад. 
 void *memcet(void *S, int c, size_t n) 
 Барои буферро ба рамзи дар парамери с нишон-додашуда пур 
 кардан истифода мешавад. Дар ин ҷо *S ишорагар ба буфер 
 буда, n- миқдори рамзҳое, ки бояд ба буфер пур карда шаванд,
 мебошад. 
 ) Истифодаи функсияи memcpy(). 
 #include <iostream> 
 #include <string> 
 using namespace std; 
 int main(){ 
 char S[]; 
 char S[]="Copy the string"; 
 memcpy(S,S,); 
 cout<<S<<endl; 
 return; 
 } 
 Ин барнома рамзи сатри S-ро ба сатри S нусхабардорӣ мекунад. 
 Натиҷаи барнома чунин аст: Copy the s 
 ) Истифодаи функсияи memmove(). 
 #include <iostream> 
 #include <string> 
 using namespace std; 
 int main(){ 
 char S[]; 
 char S[]="Copy the string"; 
 memmove(S,S,); 
 cout<<S<<endl; 
 return; 
 } 
 Натиҷаи ин барнома низ монанди мисоли аст. 
 ) Истифодаи функсияи memcmp(). 
 #include <iostream> 
 #include <string> 
 using namespace std; 
 int main(){ 
 char S[]="Students"; 
 char S[]="books"; 
 memcpy(S,S,); 
 cout<<S<<endl; 
 return; 
 } 
 Ин барнома рамзи сатри S – ро ба сатри S нусхабардорӣ мекунад. Пас
 аз нусхабардорӣ чор рамзи аввалаи сатри S нест мешаванд. Натиҷаи барнома
 чунин намуд дорад: bookents 
 ) Истифодаи функсияи memchr(). 
 #include <iostream> 
 #include <string> 
 using namespace std; 
 int main(){ 
 char S[]="It is string"; char S=’r’; 
 cout<<static_cast<char *>(memchr(S,S,)); 
 return; 
 } 
 Ин барномаи саркарда аз рамзи S- рамзҳои сатри S-ро ба чоп медиҳад.
 Дар ин ҷо static_cast - оператори табдилдиҳӣ буда, натиҷаи функсияи memchr()-
 ро ба намуди рамзӣ табдил медиҳад. Дар сурати сарфи назар кардани он ASCII
 коди рамзҳо ба чоп бароварда мешаванд. Натиҷаи барнома чунин аст: restring
 ) Истифодаи функсияи memset() 
 #include <iostream> 
 #include <string> 
 using namespace std; 
 int main(){ 
 char S[]="AAAAAAAAAA"; 
 char S=’s’; 
 cout<<static_cast<char *>(memset(S,S,))<<endl; 
 return; 
 } 
 Ин барнома ба ҷои рамзи аввалаи сатри S то рамзи дар параметри S
 нишондодашударо мегузорад. Натиҷаи барнома чунин аст: sssssAAAAA 
 Функсияҳои кор бо сатрҳо ва рамзҳо 
 Барои кор кардан ба сатрҳои матнӣ (риштаҳо) дар забони С++ онҳоро 
 ҳамчун массивҳои рамзӣ муаррифӣ менамоянд. Ҷои холигӣ низ ҳамчун як рамз 
 фаҳмида мешавад. Дар ҳар забони барноманависӣ барои кор кардан ба сатрҳо 
 функсияҳои стандартӣ мавҷуданд. Дар забони С++ низ функсияҳои зиёде 
 мавҷуданд, ки дар ҷадвали зерин муҳимтарин аз онҳо гирд оварда шудаанд. 
 № Функсия сарлавҳа Маъно ва мафҳум 
 strcpy(s,s) <string.h> Сатри s-ро ба сатри s нусхабардорӣ 
 мекунад. 
 strcat (s,s) <string.h> Сатри s-ро аз қафои сатри s пайваст 
 мекунад. 
 strcmp (s,s) <string.h> Сатри s-ро ба сатри s муқоиса мекунад, 
 агар онҳо баробар бо-шанд, қимати 
 бармегардонад. 
 strpbrc(const char <string.h> Сатрҳои S ва S ро ба ҳам му-қоиса 
 S,const char S) мекунад. Агар ягон рамзи S дар S 
 мавҷуд бошад, ишорагар онро 
 бармегардонад 
 strset(char_c, <string.h> Барои ба ҷойи сатри додашуда ба миқдори 
 int_ch) рамзҳояш чоп намудани адад хизмат 
 мекунад. 
 strchr(s,ch) <string.h> Рамзи охирини воридшударо ба рамзҳои 
 сатр муқоиса мекунад, агар пайдо шуд, 
 ишорагар онро бармегардонад. 
 strstr(s,s) <string.h> Аз рамзҳои сатри S сар карда сатри S-ро 
 ба чоп медиҳад. 
 strupr(*_s) <string.h> Рамзҳои сатри *_s ба registerи болоӣ табдил
 медиҳад 
 strlen(*s) <string.h> Дарозии сатри s-ро муайян мекунад. 
 strrev(*S) <string.h> Сатри S-ро баракс мегардонад. (Масалан 
 *S=roh; strrev(S)=hor) 
 strlwr(*S) <string.h> Баръакси функсияи strupr() амал мекунад. 
 tolower(ch) <type.h> Рамзи додашударо аз ҳарфи хурд ба ҳарфи 
 калон табдил медиҳад. 
 toupper(ch) <type.h> Рамзи додашударо аз ҳарфи калон ба ҳарфи 
 хурд табдил медиҳад. 
 Функсияҳои кор бо сатрҳо ва рамзҳо дар китобхонаҳои <string.h>, 
 <stdlib.h>, ва <type.h> мавҷуданд. Функсия дар ҳамон ҳолат ба кор медарояд, ки
 агар китобхонаи вобастаи ба он пайваст карда шудааст. 
 Мисол. Барномае нависед, ки дар он функсияҳои ҷадвали мазкур 
 истифода шавад. 
 #include <iostream> 
 #include <string> 
 using namespace std; 
 int main(){ 
 char chr[],*b="Hello ",*c="World"; 
 cout<<"Istifodai az function-i 
 strcpy\n"; 
 strcpy(chr,b); 
 cout<<chr<<endl; 
 cout<<"Istifodai function-i strcat\n"; 
 strcat(b,c); 
 cout<<b<<endl; 
 cout<<"Istifodai function-i strcmp\n"; 
 cout<<strcmp(b,c)<<endl; 
 return; 
 } 
 Дар ин мисол функсияи strcpy қимати тағйирёбандаи рамзии b-ро ба 
 тағйирёбандаи рамзии chr нусхабардорӣ мекунад. Функсияи strcat бошад, 
 қимати тағйирёбандаи рамзии c-ро дар қафои тағйирёбандаи рамзии b пайваст
 мекунад ва охирон функсияи strcmp дар оператори хориҷкунӣ қимати сатри b 
 ва с-ро муқоиса мекунад. Аз сабаби он ки сатрҳои мазкур баробар нестанд, 
 функсия қимати манфӣ бармегардонад. Натиҷаи барнома шакли зеринро дорад: 
 Istifodai function-i 
 strcpy 
 Hello 
 Istifodai function-i strcat 
 Hello World 
 Istifodai function-i 
 strcmp 
 - 
 Истифодаи функсияи strcpy() ва strcat () 
 Тавре ки гуфта будем, функсияи strcpy() сатри s-ро ба сатри s 
 нусхабардорӣ мекунад. Функсияи strcat () бошад, сатри s-ро аз қафои сатри s
 пайваст мекунад. Ин ҳарду функсияро дар мисоли зерин дида мебароем. 
 #include <iostream> 
 #include <string> 
 using namespace std; 
 int main(){ 
 char str[]; 
 char namefirstName[]; 
 char sur[]; 
 char kor[]; 
 cout<<"Nomatonro vorid namuda tugmachai Enter-ro zer kuned\n"; 
 cin.getline(namefirstName,); 
 cout<<"Addressatonro vorid namuda tugmachai Enter-ro zer 
 kuned\n"; 
 cin.getline(sur,); 
 cout<<"Joi koratonro vorid namuda tugmachai Enter-ro zer 
 kuned\n"; 
 cin.getline(kor,); 
 strcpy(str,"\n Nom LastName: " ); 
 strcat (str,namefirstName); 
 strcat (str," \nAddress: " ); 
 strcat (str,sur); 
 strcat (str," \nzoyi kor: "); 
 strcat (str,kor); 
 cout<<str<<endl; 
 return; 
 } 
 Истифодаи функсияи strset(char_c, int_ch) 
 Функсияи strset(char_c, int_ch) бошад, барои ба ҷойи сатри до-дашуда ба
 миқдори рамзҳояш чоп намудани адад хизмат мекунад, ҳоло иҷроиши ин 
 функсияро бо як мисоли кӯчак дида мебароем. 
 #include <iostream> 
 #include <string> 
 using namespace std; 
 int main(){ 
 char string[] = ""; 
 char symbol = ’l’; 
 printf("Pesh az strset(): %s\n", string); 
 strset(string, symbol); 
 printf("Pas az strset(): %s\n", string); 
 return; 
 } 
 Натиҷаи барнома намуди зеринро дорад: 
 Pesh az strset(): 
 Pas az strset(): 
 Массивҳои дученака аз навъи рамзӣ 
 Массивҳои якченака аслан барои як сатри рамзӣ истифода бурда 
 мешаванд. Барои якчанд сатрро муаррифӣ ва истифода кардан аз массивҳои 
 дученакаи навъи рамзӣ истифода намудан лозим меояд. Дар ин ҳолат зернависи
 якуми массив миқдори сатрҳо ва зернависи дуввум бошад, дарозии сатрҳоро 
 муайян мекунад. Мисол: 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 char s[][]={"Toirov","Dodarov","Aliev","Saidov","Valiev"}; 
 for (int i=;i<;i++) 
 cout<<s[i]<<endl; 
 return; 
 } 
 Дар ин ҷо массиви дученака муаррифӣ гардидааст, ки зернависи якуми он
 миқдори сатрҳо ва зернависи дувввуми он бошад, дарозии ҳар як сатрро нишон
 медиҳад, яъне дар мисоли мо дарозии ҳар як сатр то рамз шуда метавонад.
 Натиҷаи барнома ба сурати зерин аст: 
 Toirov 
 Dodarov 
 Aliev 
 Saidov 
 Valiev 
 Равон кардани сатрҳо ба функсия ба сифати аргумент 
 Тавре ки медонем, сатрҳо дар забони С++ ҳамчун массивҳои рамзӣ 
 фаҳмида мешаванд ва барои ба функсия ҳамчун аргумент равон кардани онҳо 
 дар функсия ишорагаре ба номи сатри додашуда истифода бурда мешавад. 
 Инчунин онҳо метавонанд монанди массивҳо ба функсия фиристода шаванд. 
 Мисол. Функсияе нависед, ки амали функсияи strLen-ро иҷро кунад. 
 #include <iostream> 
 #include <string> 
 using namespace std; 
 int Len(char *str){ 
 for (int s=;*str;s++,str++) 
 return s; 
 } 
 int main(){ 
 char str[]="This is string"; 
 cout<<"Darozii satr bo istifoda az tobei farii 
 Len="<<Len(str)<<endl; 
 cout<<"Darozii satr bo istifoda az strlen="<<strlen(str)<<endl; 
 return; 
 } 
 Дар ин ҷо функсияе ба номи Len муаррифӣ гардидааст, ки аргументи он 
 як ишорагар бар сатре мебошад, сипас, дар дохили функсия тағйирёбандаи 
 бутуни s муаррифӣ шудааст. Дар дохили ҳалқа то замони ба охири ҳалқа 
 расидан миқдори рамзҳо ҳисоб карда шуда, бо ёрии оператори return 
 баргардонида мешаванд. Дар функсияи аслӣ бошад, як маротиба функсияи 
 фаръии навиштаамон дар оператори хориҷкунӣ даъват карда шудааст. 
 Функсияи даъватшуда дарозии сатри додашударо ҳисоб намуда, қимати онро ба
 чоп медиҳад. Барои санҷиши дурусти функсия, як маротиба функсияи 
 стандартии strLen низ истифода карда шудааст. Натиҷаи барнома ба сурати 
 зерин аст: 
 Darozii satr bo istifoda az tobei farii Len= 
 Darozii satr bo istifoda az tobei standardii strlen= 
 Тавре ки аз натиҷаи барнома дида мешавад, қимати функсияи 
 навиштаамон ба қимати функсияи стандартӣ якхела аст. 
 Синфи нави кор бо сатрҳо дар забони С++ 
 Дар фарзияҳои (версияҳои) нави забони С++ навъи тағйирёбандаҳои 
 сатрӣ, ки корбурдашон хеле сода аст, амал мекунад. Азбаски навъи мазкур 
 васеъшудаи навъҳои пешина мебошад, бинобар ин, дар китобхонаҳои стандартӣ
 нигоҳ дошта мешавад. Агар ба забони техники гӯем, навъи нав, ки string ном
 дорад, class мебошад. Class-ин навъи додаҳо буда, дар барнома ё дар 
 китобхонаи махсус нигоҳ дошта мешавад. 
 Навъи char, ки қаблан истифода кардем, он ҷузъиёт ва методҳои класси
 string-ро надошта танҳо ишорагаре ба массивҳои навъи рамзӣ буд. Сабаби 
 камтар аз тағйирёбандаҳои класси string истифода кардан дар он аст, ки: 
 мекунанд. 
 вале тағйирёбандаҳои класси string ин хусусиятро надошта, ҳофизаи зиёдро 
 банд мекунанд. 
 Бар замми ин, набояд аз истифодабарии тағйирёбандаҳои навъи 
 string руй гардонид, зеро онҳо дорои методҳои зиёде ҳастанд, ки дар 
 тағйирёбандаҳои навъи char ин хусусият вуҷуд надошт. 
 Барои истифодабарии класси string бояд пеш аз ҳама, китобхо-наи 
 #include <string> насб карда шавад, ки класси string –ро пуштибонӣ мекунад.
 Китобхонаи мазкур аз китобхонае, ки функсияҳои навъи char-ро пуштибонӣ 
 мекард, фарқ мекунад. Истифодабаранда метавонад, дар як вақт ҳарду 
 китобхонаро пайваст кунад, вале барои кор кардан ба додаҳои навъи string 
 пайваст намудани китобхонаи #include <string.h> лозим намебошад. 
 Сохтани сатр 
 Сатрҳо метавонанд бо якчанд услуб ё роҳ сохта шаванд. Масалан, ҳамчун
 сатри холӣ, бо қимати аввала, бо дарозии муайян, иборат аз як қимати муайян,
 аз қимати сатри дигар ва ғайра. Мисол: 
 string sEmpty; //сатри ҳолӣ 
 string str(“In satr ast”); 
 string s=”satri dodashuda”; 
 string s(str); // сохтани сатр дар асоси сатри дигар; 
 string sFill(, ‘A’); // сатр иборат аз даҳто ҳарфи А; 
 string str(str,, ); // сатр иборат аз чорто рамзи сатри str, сар карда аз
 мавқеи панҷум. 
 Кор бо тағйирёбандаҳои навъи string 
 Класси string дорои як қатор имкониятҳо, методҳо ва хосиятҳое мебошад,
 ки онҳо дар тағйирёбандаҳои навъи char хос набуданд. Масалан, барои 
 нусхабардорӣ намудани сатр, муқоисакунии ду сатр ва якҷоякунии ду сатр 
 лозим нест, ки ягон функсияе даъват карда шавад. Масалан, бигзор шумо дорои
 ду сатр бошед. 
 string firstName (“Saidov”); 
 string name (“Bobo”); 
 Ин тағйирёбандаҳо метавонанд ба ягон сатри дигар қимати худро 
 бахшанд ва қимати он сатрро дар худ гирд оваранд. Масалан, ба сатри firstName
 метавон ба сурати зерин қимати нав бахшид: 
 firstName=”Saidov”; 
 Барои муқоиса кардани сатрҳо метавон аз оператори муқоисакунии (==) 
 истифода бурд. Ҳангоми муқоисакунӣ натиҷаи шарт ба қимати true баробар 
 мешавад, агар сатрҳо якхела бошанд, дар ҳолати акс қимати шарт ба false 
 баробар мегардад. (барои иҷрои ин амал рӯи тағйирёбандаҳои навъи char 
 функсияи strcmp() даъват карда мешуд.) 
 if (name ==firstName) 
 cout<<””name and firstName have the some name); 
 Барои нусхабардорӣ намудани як сатр ба сатри дигар аз оператори 
 бахшиш ба сурати зерин истифода бурда мешавад. 
 string country=firstName; 
 Барои якҷоя кардани ду сатр низ аз оператори «+» ба сурати зерин 
 истифода бурда мешавад. 
 string str= firstName+name; 
 Ин ифодаро метавонем низ ба сурати зерин навишт. 
 string str=firstName+” “ + name; 
 Дар ёд дошта бошед, ки истифодаи класси string табиати барномасозӣ ва
 кор кардан ба додаҳои сатриро тағйир надода, танҳо имконияти истифодабарии
 додаҳои навъи сатриро васеътар месозад. 
 Дохилкунӣ ва хориҷкуни додаҳои навъи string 
 Монанди дигар тағйирёбандаҳои навъҳои стандартии истифода- 
 бурдаамон, метавонем қимати тағйирёбандаҳои сатриро аз ворид кунем ва ё 
 натиҷаи тағйирёбандаҳои сатриро дар сафҳаи тасвир нависем. Объекти cin ва
 cout метавонанд барои дохилкунӣва хориҷкунии додаҳои навъи string истифода
 бурда шаванд, вале ба сабаби он ки объекти cin то мавқеи фосила сатри 
 додашударо хонда, қисми боқимондаро сарфи назар мекунанд, аз ин сабаб 
 истифодаи он барои хондани сатрҳо маслиҳат дода намешавад. Барои бенуқсон
 ворид намудани қимати тағйирёбандаҳои навъи мазкур аз функсияи getline() 
 истифода мебаранд, ки наҳви умумии он шакли getline(cin,str)-ро дорад: 
 Дар версияҳои пешина функсияи мазкур, ки барои тағйирёбандаҳои навъи
 char пешбинӣ шуда буд, қимати максималии миқдори сатрҳо низ ҳангоми 
 ворид кардани сатр нишон дода мешуд, вале дар ин намуд бошад, метавон 
 дилхоҳ сатрро ворид кард. 
 Мисол. Сохтан ва дохилкуниву хориҷкунии сатр бо истифода аз 
 тағйирёбандаҳои навъи string. 
 #include <iostream> 
 #include <string> 
 using namespace std; 
 int main(){ 
 string satr,name, firstName,Address,tel; 
 cout<<"Enter you firstName and press Enter\n"; 
 getline(cin,firstName); 
 cout<<"Enter you name and press Enter\n"; 
 getline(cin,name); 
 cout<<" Enter you Address and press Enter \n"; 
 getline(cin,Address); 
 cout<<"Enter you tel and press Enter\n"; 
 getline(cin,tel); 
 satr="\nfirstName: "+firstName + "\nname: " +name+"\nAddress: " 
 + Address + "\ntel: " + tel + "\n"; 
 cout<<satr; 
 return; 
 } 
 Барои ҳалли мисоли мазкур аввал китобхонаи #include <string> ба 
 барнома пайваст карда шудаст. Баъд аз ин, дар равиши барнома панҷ 
 тағйирёбанда аз навъи string муаррифӣ шудаанд, ки мувофиқан чунин ном 
 доранд: 
 string satr, name, firstName, Address, tel; 
 Баъд аз ин барои ворид кардани сатрҳои лозимӣ функсияи getline() ба 
 сурати зерин даъват карда шудааст. 
 cout<<«Enter you firstName and press Enter\n»; 
 getline(cin,firstName); 
 cout<<«Enter you name and press Enter\n»; 
 getline(cin,name); 
 cout<<«Enter you Address and press Enter\n»; 
 getline(cin,Address); 
 cout<<«Enter you tel and press Enter\n»; 
 getline(cin,tel); 
 Тавре ки дар ин ҷо дида мешавад, дар функсияи getline миқдори 
 максималии рамзҳо нишон дода нашудааст. Аз ин пас, сатри satr, ки аз қимати
 сатрҳои name, firstName ва Address,tel таркиб ёфтаааст, дар охир бо ёрии 
 объекти cout хориҷ карда шудаст. Натиҷаи барнома ба сурати зерин аст: 
 Enter you firstName and press Enter 
 Saidov 
 Enter you name and press Enter 
 Saidmurod 
 Enter you Address and press Enter 
 Dushanbe 
 Enter you tel and press Enter 
 --- 
 firstName: Saidov 
 name: Saidmurod 
 Address: Dushanbe 
 tel: --- 
 Дастрасӣ ба символҳои тағйирёбандаҳои навъи string 
 Барои ба ҳар як рамзи сатр дастрас шудан, тағйирёбандаҳои сатриро ба
 намуди зернависдор навишта истифода мекунем. Ис-тифодаи наҳви мазкур 
 монанди тағйирёбандаҳои навъи char мебошад, яъне 
 Сатр[зернавис]; 
 Масалан, барномаи дар поён овардашуда ҳар як рамзи сатри додашударо 
 ҷудо карда, чоп мекунад. 
 #include <iostream> 
 #include <string> 
 using namespace std; 
 int main(){ 
 string firstName="Saidov"; 
 for(int i=;i<firstName.size();i++) 
 cout<<firstName[i]<<endl; 
 return; 
 } 
 Монанди тағйирёбандаҳои навъи char зернависи тағйир-ёбандаҳои навъи 
 string низ аз нол оғоз мегардад. Шарти даврзании ҳалқа аз дарозии сатр 
 вобастагӣ дорад. Барои дарозии тағйирёбандаҳои навъи char-ро дарёфт кардан
 аз функсияи lenght(), истифода бурда мешуд, барои дарозии тағйирёбандаҳои
 навъи string-ро дарёфт кардан аз методҳои класси string, ки наҳви он сурати
 зеринро дорад, 
 сатр.size(); 
 истифода бурда мешавад. Масалан, матни барномаи зерин ҳарфҳои сатри 
 додашударо ба registerӣ болоӣ табдил медиҳад. 
 #include <iostream> 
 #include <string> 
 #include <ctype.h> 
 using namespace std; 
 int main(){ 
 string comp="Ilmhoi Computeri"; 
 for(int i=;i<comp.size();i++) 
 comp[i]=toupper(comp[i]); 
 cout<<comp<<endl; 
 return; 
 } 
 Амалиёт ба сатрҳо 
 Дар болои тағйирёбанда ё объектҳои навъи string операторҳои зерин 
 метавонанд амал кунанд: 
 № Оператор Маъно ва мафҳум 
 = Бахшиш 
 + Якҷоякунӣ 
 == Баробаркунӣ 
 += Якҷоякунӣ ва бахшидан!= Нобаробар 
 < Хурд 
 <= Хурд ва баробар 
 > Калон 
 >= Калон ва баробар 
 [] Зернавис 
 >> Дохилкунӣ 
 << Хориҷкунӣ 
 Мисол: 
 #include <iostream> 
 #include <string> 
 using namespace std; 
 int main(){ 
 string str("In satr ast "); 
 string s="satri dodashuda"; 
 string s=str+s; // якҷоя намудани ду сатр 
 cout<<s<<endl; 
 return; 
 } 
 Функсия-аъзоҳои кор бо сатрҳо 
 Монанди дигар контейнерҳо дар библиотекаи string барои коркарди 
 сатрҳо функсияҳои зиёде мавҷуданд, ки муҳимтарини онҳо дар ҷадвали зерин 
 гирд оварда шудаанд. 
 № Номи функсия-аъзо Маъно ва мафҳум 
 size() Андозаи ҷории сатрро муайян мекунад. 
 length() Дарозии сатрро муайян мекунад 
 max_size() Микдори максималии рамз- ҳои сатрро 
 бармегардонад. 
 resize() Андозаи сатрро тағйир медиҳад, яъне барои сатр 
 андозаи нав барқарор мекунад. 
 reserve() n-рамзи сатрро бурида ме-гирад. 
 empty() Қимати ҳақ бармегардонад, агар сатр холӣ 
 бошад 
 erase() num рамзи сатри додашударо сар карда аз 
 мавқеи start нест мекунад. 
 append() Як сатрро дар охири сатри дигар пайваст 
 мекунад 
 find() Мавқеи аввалини вуқӯъи зер-сатрро дар сатр 
 муайян меку-над. (бармегардонад) 
 replace() Барои рамзҳои сатри ҷориро бо рамзҳои зерсатр 
 иваз намудани хизмат мекунад. 
 copy(char *s, unsigned int Аз мавқеъи m-ум сар карда, n-рамзи сатри 
 n, unsigned int m) ҷориро ба масиви рамзи s нусхабардорӣ 
 мекунад. 
 find_first_of() Мавқеи аввалини рамз ё зерсатрро дар сатр 
 ҷустуҷӯ ме-кунад. 
 find_first_not_of() Мавқеи аввалаи рамзи сатри ҷориро, ки ба рамзи 
 зерсатр мувофиқат намекунад, муайян мекунад. 
 find_last_of() Мавқеи охирини рамз ё зерсатрро дар сатр 
 ҷустуҷӯ ме-кунад. 
 find_last_not_of() Мавқеи охирони рамзи сатри ҷориро, ки ба 
 рамзи зерсатр мувофиқат намекунад, муайян 
 мекунад. 
 assign (const char *str, Барои як сатрро ба сатри дигар бахшидан 
 size_type num) истифода бурда ме-шавад. 
 at(unsigned int n) Функсия аъзо буда, ба рамзи n-уми сатри ҷорӣ 
 ишорагар бармегардонад. 
 substr(pos,n); Аз мавқеи pos-ум сар карда n-рамзи сатри 
 ҷориро бурида мегирад. 
 c_str Ба массиви символие, ки ба символи нол ба охир 
 расида, қимати ҷории объекти String мебошад 
 ишорагар бармегар-донад. 
 swap Қимати сатри ҷориро бо сатри додашуда иваз 
 мекунад. 
 rbegin Итератори баракс ба символи охири сатр 
 бармегардонад 
 push_bask Ба охири сатр символи нав илова намуда, 
 андозаи сатрро як воҳид зиёд мекунад. 
 pop_bask Символи охирони сатрро нест намуда, андозаи 
 сатрро як воҳид кам мекунад. 
 clear Маълумотҳои саттро нест мекунад. 
 insert() Пеш аз символи нишондодашуда, символҳои 
 нави лова мекунад. 
 Функсияи assign() 
 Функсияи мазкур барои як сатрро ба сатри дигар бахшидан, истифода 
 бурда шуда, дорои ду қолаб мебошад. Дар поён наҳвии умумии ин қолабҳо 
 оварда шудаанд. 
 Қолаби якум num рамзи сатри strob –ро сар карда аз мавқеи start ба сатри
 даъватшаванда мебахшад. Ҳангоми истифодабарии қолаби дуввум, num рамзи 
 сатри str-ро бо охиррасии сатр ба сатри даъватшаванда мебахшад. Дар ҳар ду
 қолаб ишорагар баргардонида мешавад. Барои як сатрро пурра ба сатри дигар
 бахшидан, аз оператори “=” истифода бурда мешавад. Функсияи assign() бошад,
 ҳамчун ҳолати хусусии оператори “=” истифода бурда мешавад, яъне он барои
 як қисмати як сатрро ба сатри дигар бахшидан хизмат мекунад. Мисол: 
 #include <iostream> 
 #include <string> 
 using namespace std; 
 int main() 
 { 
 string str("In satri kutoh ast."); 
 string str; 
 str.assign(str,, ); 
 cout<<str<<"\n"; 
 return; 
 } 
 Дар ин мисол str =satri мегардад. 
 Мисоли дигар. Ин мисол ҳар маротиба рамзи зиёдтар рамзи сатри 
 ҷориро ба сатри s нусхабардорӣ мекунад. 
 #include <iostream> 
 #include <string> 
 #include <ctype.h> 
 using namespace std; 
 int main() 
 { 
 string s, str = "*************************"; 
 int pos = str.length(); 
 while ( pos ){ 
 s.assign ( str.begin(),str.end() - pos+); 
 cout << s << endl; 
 pos -=; } 
 cout << endl; 
 return; 
 } 
 Натиҷаи барнома намуди зеринро дорад: 
 * 
 ****** 
 *********** 
 **************** 
 Функсияи append() 
 Функсияи мазкур барои як сатрро дар охири сатри дигар пайваст намудан,
 хизмат мекунад. Қолаби умумии он намуди зеринро дорад: 
 Қолаби якум num рамзи сатри strob –ро сар карда, аз мавқеи start ба қафои
 сатри даъватшаванда илова мекунад. Ҳангоми исти-фодабарии қолаби дуввум, 
 num рамзи сатри str-ро бо охиррасии нол ба қафои сатри даъватшаванда илова
 мекунад. Дар ҳар ду қолаб ишорагар баргардонида мешавад. 
 Мисоли. Истифодаи функсияи append. 
 #include <iostream> 
 #include <string> 
 using namespace std; 
 int main(){ 
 string str("In satr "); 
 string str("kutoh ast."); 
 str.append(str,, ); 
 cout<<str; 
 return; 
 } 
 Мисоли. Барномаи зерин ҳар маротиба, як рамзи тағйирёбандаи рамзии
 ch-ро ба сатри str нусхабардорӣ мекунад. 
 #include <iostream> 
 #include <string> 
 using namespace std; 
 int main(){ 
 string str; 
 for ( char ch = ’a’; ch <= ’z’; ch++ ) 
 str.append(,ch); 
 cout << "str is: " << str << endl; 
 cout << endl; 
 return; 
 } 
 Натиҷаи барнома чунин аст: str is: abcdefghijklmnopqrstuvwxyz 
 Функсияҳои insert(), erase() ва replace() 
 Функсияи erase() барои аз сатри додашуда, нест намудани num рамзро сар
 карда, аз мавқеи start истифода бурда мешавад. Қолаби умумии он намуди 
 зеринро дорад: 
 string &erase(size_type start=, size_type num=npos); 
 Функсияи insert() ва replace() барои иваз намудани рамзҳои сатрро ба
 рамзҳои дигар хизмат мекунанд. Қолаби умумии функсияҳои мазкур намуди 
 зеринро дорад: 
 Функсияи insert: 
 size_type num); 
 Наҳви функсияи replace: 
 size_type replaceStart, size_typereplaceNum); 
 Қолаби якуми функсияи insert () num рамзи сатри strob-ро ба сатри 
 даъватшаванда иваз мекунад. Қолаби дуввум бошад, num- рамзи сатри strob-ро
 аз мавқеи insStart ба мавқеи start-и сатри даъватшаванда мегузорад. Мисол:
 #include <iostream> 
 #include <string> 
 using namespace std; 
 int main(){ 
 string str = "C++ language"; 
 string s = "is best "; 
 int pos =; 
 str.insert(pos,s); 
 cout << "str is: " << str << endl; 
 return; 
 } 
 Натиҷаи барнома чунин аст: C++ is best language 
 Қолаби якуми функсияи replace () барои num рамзи сатри strob–ро ба 
 мавқеи start-и сатри даъватшаванда гузоштан истифода бурда мешавад. Қолаби
 дуввум бошад, orgNum рамзро дар сатри даъватшаванда аз мавқеи start иваз 
 мекунад. Мисол: 
 #include <iostream> 
 #include <string> 
 using namespace std; 
 int main(){ 
 string str("In satr "); 
 string str("kutoh ast."); 
 cout<<"str="<<str<<endl; 
 cout<<"str="<<str<<endl; 
 str.insert(,str); 
 cout<<"\nSatri str pas az guzoshtani symvol=\n"<<str<<endl; 
 str.erase(,str.length()); 
 cout<<"\nSatri str pas az guzoshtani symvol=\n"<<str<<endl; 
 str.replace(,,str); 
 cout<<"\nSatri str pas az guzoshtani symvol=\n"<<str<<endl; 
 return; 
 Натиҷаи барнома намуди зеринро дорад: 
 str=In satr. 
 str=kutoh ast. 
 satri str pas az guzoshtani symvol= 
 kutoh ast.In satr 
 satri str pas az guzoshtani symvol= 
 In satr 
 satri str pas az guzoshtani symvol= 
 In satr kutoh ast. 
 Мисоли дигар. Ин барнома аз мавқеи -ум сар карда, рамзи сатри str-
 ро нест мекунад. 
 #include <iostream> 
 #include <string> 
 using namespace std; 
 int main() 
 { 
 string str; 
 for ( char ch = ’a’; ch <= ’z’; ch++ ) 
 str.append(,ch); 
 cout << "str is: " << str << endl; 
 str.erase(,); 
 cout << "Erased range from str: " << str << endl; 
 cout << endl; 
 return; 
 } 
 Натиҷаи барнома намуди зеринро дорад: 
 str is: abcdefghijklmnopqrstuvwxyz 
 Erased range from str: abcdtuvwxyz 
 Функсияи at() 
 Функсияи at дар мавқеи нишондодашуда, ишорагар ба символ 
 бармегардонад. Наҳви умумии функсияи мазкур намуди зеринро дорад: 
 char& at (size_t pos); 
 const char& at (size_t pos) const; 
 Барномаи зерин, пас аз ҳар рамзи сатри додашуда, аломати хитоб «!» 
 мегузорад. 
 #include <iostream> 
 #include <string> 
 using namespace std; 
 int main(){ 
 string s = "Hello World"; 
 for ( int pos =; pos < s.length(); ++pos ) 
 cout << s.at(pos) << "!"; 
 cout << endl; 
 return; 
 } 
 Натиҷаи барнома чунин аст: H!e!l!l!o!!W!o!r!l!d! 
 Мисоли функсияи find_last_of() 
 Барои мавқеи охирони рамз ё зерсатрро дар дохили сатр ҷус-туҷӯ кардан,
 истифода бурда мешавад. Қолаби умумии он шакли зеринро дорад: 
 size_t find_last_of (const string& str, size_t pos = npos) const;
 size_t find_last_of (const char* s, size_t pos = npos) const; 
 size_t find_last_of (const char* s, size_t pos, size_t n) const;
 size_t find_last_of (char c, size_t pos = npos) const; 
 дар ин ҷо: 
 str сатри символҳо барои ҷустӯҷӯ; 
 pos мавқеи охирон символ дар сатр барои ҷустӯҷӯ; 
 s ишорагари масиви символӣ; 
 n миқдори қиматҳои символ барои ҷустӯҷӯ; 
 c характери индувидуалӣ барои ҷустӯҷӯ; 
 size_t is навъи бутуни беаломат. 
 Мисол: 
 #include <iostream> 
 #include <string> 
 using namespace std; 
 int main(){ 
 string str("C++ is best language"); 
 string s = "g"; 
 cout << "str is:" << str << endl; 
 cout << "s is: " << s << endl; 
 int n = str.find_last_of(s); 
 cout << "last_of ’" << s << "’ faund"<< " at position " << n+ << 
 endl; 
 n = str.find_last_of(’ ’); 
 cout << "last_of ’ ’ faund"<< " at position " << n+ << endl; 
 n = str.find_last_of(" la"); 
 cout << "last_of \" la\" faund"<< " at position " << n+ << endl; 
 return; 
 } 
 Натиҷаи барнома намуди зеринро дорад: 
 str is: C++ is best language 
 s is: g 
 last_of 'g' faund at position 
 last_of ' ' faund at position 
 last_of « la» faund at position 
 Истифодаи функсияи find() ва copy() 
 Функсияи find() мавқеъ ё индекси аввалаи вуқӯъи зерсатрро дар дохили
 сатр муайян мекунад. Қолаби умумии он шакли зеринро дорад: 
 size_t find (const string& str, size_t pos = ) const; 
 size_t find (const char* s, size_t pos = ) const; 
 size_t find (const char* s, size_t pos, size_t n) const; 
 size_t find (char c, size_t pos = ) const; 
 Функсияи copy() бошад, аз мавқеъи m-ум сар карда, n-рамзи сатри ҷориро
 ба масиви рамзии s нусхабардорӣ мекунад. Қолаби умумии функсияи мазкур 
 намуди зеринро дорад: 
 size_t copy (char* s, size_t n, size_t pos = ) const; 
 Мисол: 
 #include <iostream> 
 #include <string> 
 using namespace std; 
 int main(){ 
 string str = "First Name: Ali"; 
 char fname[]; 
 cout << "str is: " << str << endl; 
 int n = str.find(’:’); 
 str.copy(fname, n+, ); 
 fname[n+] =; 
 cout << "fname is: " << fname << endl; 
 return; 
 } 
 Натиҷаи барнома чунин аст: fname is: First Name: 
 Функсияҳои empty() ва erase(char *s) 
 Функсияи erase(char *s) –барои аз сатри додашуда, рамзи дар парметри s-
 нишондодашуро нест кардан, истифода бурда мешавад. Қолаби умумии 
 функсияи мазкур намуди зеринро дорад: 
 string& erase (size_t pos =, size_t len = npos); 
 iterator erase (iterator p); 
 iterator erase (iterator first, iterator last); 
 дар ин ҷо: 
 pos мавқеи символи аввала барои нест кардан; 
 len миқдори символҳое, ки бояд нест карда шаванд; 
 p итератор ба символе, ки бояд нест карда шавад; 
 first, last итератор ба фосилаи [first,last) символҳое, ки бояд нест 
 карда шаванд. 
 size_t навъи бутуни беаломат. 
 Функсияи empty() бошад, функсияи мантиқӣ буда, ҳангоми расидан ба 
 охири сатр қимати true бармегардонад. Қолаби умумии он намуди зеринро 
 дорад: bool empty() const; 
 Мисол: 
 #include <iostream> 
 #include <string> 
 using namespace std; 
 int main(){ 
 string str = "ABCDEFGH"; 
 while (! str.empty() ){ 
 cout << str << endl; 
 str.erase(str.end()-); 
 } 
 cout << endl; 
 return; 
 } 
 Ин барнома ҳар маротиба аз тарафи рост як рамзи сатри str-ро то расидан
 ба охири сатр, нест мекунад. Натиҷаи барнома намуди зеринро дорад: 
 ABCDEFGH 
 ABCDEFG 
 ABCDEF 
 ABCDE 
 ABCD 
 ABC 
 AB 
 A 
 Функсияи substr(pos,n) 
 Барои дар сатри ҷорӣ, сар карда, аз мавқеи pos-ум, ҷудо намуда 
 гирифтани n-рамз, истифода бурда мешавад. Қолаби умумии функсияи мазкур 
 намуди зеринро дорад: 
 string substr (size_t pos =, size_t len = npos) const; 
 Мисол: 
 #include <iostream> 
 #include <string> 
 using namespace std; 
 int main(){ 
 string str = "We go step by step to the target"; 
 cout << "str is: " << str << endl; 
 int n = str.find("step"); 
 string s = str.substr(n); 
 cout << "s is: " << s << endl; 
 cout << endl; 
 return; 
 } 
 Дар ин мисол, аввал тавассути функияи find() мавқеи нахустини зерсатри
 step муаяйян карда мешавад. Баъд аз ин мавқеъ сар карда, то охири сатр 
 рамзҳои сатри ҷориро ба S нусхабардорӣ мекунад. Натиҷаи барнома чунин аст:
 s is: step by step to the target 
 Агар функсияи мазкурро ба намуди s = str.substr(,)-даъват кунем, он
 гоҳ натиҷа чунин мешавад: s is: step by step 
 Функсияи push_back 
 Функсияи push_back барои дар охири сатр илова намудани символ 
 истифода бурда мешавад. Пас аз илова намудани символ андозаи сатр як воҳид
 зиёд мешавад. Қолаби умумии функсияи мазкур намуди зеринро дорад: 
 void push_back (char c); 
 Барномаи зерин додаҳои як файли матниро хонда, дар сатри S захира 
 мекунад. 
 #include <iostream> 
 #include <fstream> 
 using namespace std; 
 int main() 
 { 
 string S; 
 ifstream file ("test.txt",std::ios::in); 
 if (file) 
 { 
 while (!file.eof()) S.push_back(file.get()); 
 } 
 cout << S<< ’\n’; 
 return; 
 } 
 Функсияи swap 
 Функсияи swap барои сатри ҷориро бо сатри дар параметри str 
 нишондодашуда иваз намудан хизмат мекунад. Қолаби умумии функсияи 
 мазкур намуди зеринро дорад: 
 void swap (string& str) 
 Мисол. Иваз намудани муҳтавои ду сатр. 
 #include <iostream> 
 #include <string> 
 using namespace std; 
 int main(){ 
 string s="first", s="second"; 
 cout<<"s after swap="<<s<<endl; 
 cout<<"s after swap="<<s<<endl; 
 s.swap(s); 
 cout<<"s befor swap="<<s<<endl; 
 cout<<"s befor swap="<<s<<endl; 
 cin.get(); 
 return; 
 } 
 Натиҷаи барнома шакли зеринро дорад: 
 s after 
 swap==first 
 s after swap 
 =second 
 s befor 
 swap=second 
 s befor swap 
 =first 
 Функсияи c_str 
 Функсияи c_str ба массиви символие, ки ба символи нол ба охир расида,
 қимати ҷории объекти String мебошад, ишорагар бармегар-донад. Қолаби 
 умумии функсияи мазкур намуди зеринро дорад: 
 const char* c_str() const; 
 Мисол. Ба калимаҳо ҷудо намудани сатри додашуда. 
 #include <fstream> 
 #include <cstring> 
 #include <iostream> 
 #include <string> 
 using namespace std; 
 int main(){ 
 ifstream ifs; 
 int ind, i, iter=; 
 string str; 
 char s[]; 
 ifs.open("test.txt"); 
 while (!ifs.eof() ) 
 ifs.getline(s, ); 
 str=s; 
 char * cstr = new char [str.length()+]; 
 strcpy (cstr, str.c_str()); 
 char * p = strtok (cstr," "); 
 while (p!=) { 
 cout << p << ’\n’; 
 p = strtok(NULL," "); 
 } 
 delete[] cstr; 
 return; 
 } 
 Дар ин ҷо аз унксияи strtok() истифода шудааст, ки он қисмати сатри 
 додашударо то мавқеи нишондодашуда бармегардонад. 
 Функсияи rbegin 
 Функсияи rbegin() итератори баракс ба символи охири сатр бармегардонад.
 Қолаби умумии функсияи мазкур намуди зеринро дорад: 
 reverse_iterator rbegin(); 
 const_reverse_iterator rbegin() const; 
 Мисол. Баракс чоп намудани символҳои сатр. 
 #include <iostream> 
 #include <string> 
 using namespace std; 
 int main(){ 
 string str ("Please help me"); 
 for (string::reverse_iterator rit=str.rbegin(); rit!=str.rend(); 
 ++rit) 
 cout << *rit; 
 return; 
 } 
 Натиҷаи барнома чунин аст: em pleh esaelP 
 Функсияи clear 
 Функсияи clear() барои сатри додашударо аз маълумот холӣ намудан 
 истифода бурда мешавад. Қолаби умумии ин функсия намуди зеринро дорад: 
 void clear() 
 Мисол. 
 #include <iostream> 
 #include <string> 
 using namespace std; 
 int main(){ 
 char c; 
 string str; 
 cout << "Marhamt yak satr matn dokhil karda, baroi ba anjomrasi 
 nuqta(.)-ro zer kuned:\n"; 
 do { 
 c = cin.get(); 
 str.push_back(c); 
 if (c==’\n’) 
 { 
 cout<<str; 
 str.clear(); 
 } 
 } while (c!=’.’); 
 return; 
 } 
 Функсияи pop_back 
 Функсияи pop_back cимволи охирони сатрро нест намуда, андозаи сатрро
 як воҳид кам мекунад. Қолаби умумии ин функсия намуди зеринро дорад: 
 void pop_back() 
 Мисол. 
 #include <iostream> 
 #include <string> 
 using namespace std; 
 int main(){ 
 char c; 
 string str ("Hello world!"); 
 str.pop_back(); 
 cout << str << ’\n’; 
 return; 
 } 
 Саволҳо барои мустаҳкамкунӣ 
 шаванд? 
 мебаранд? 
 char зиёдтарро доранд? 
 намекунанд? 
 мешаванд? 
 алоҳидаги барорем? 
 қоиса карда мешаванд? 
 Намунаи ҳалли масъалаҳо 
 ҳисоб кунад. 
 #include <iostream> 
 #include <string.h> 
 using namespace std; 
 int main(){ 
 int ln,m=,i; 
 char *b="adab oinaest bahri muaddab"; 
 ln=strlen(b); 
 char c=’a’; 
 for (i=;i<ln;i++) 
 if (b[i]==c) 
 m++; 
 cout<<"dar satri dodashuda "<<m<<" to harfi "<<c<<" mavjud 
 ast."<<endl; 
 return; 
 } 
 «А» табдил диҳад. 
 #include <iostream> 
 #include <string.h> 
 using namespace std; 
 int main(){ 
 int ln,m=,i,k=; 
 char a[],*b="adab oinaest bahri muaddab"; 
 ln=strlen(b); 
 char c=’a’; 
 for (i=;i<ln;i++,k++) 
 if (b[i]==c){ 
 m++; 
 a[k]=’A’;} 
 else { 
 a[k]=b[i]; 
 } 
 cout<<"satri asli="<<b<<endl; 
 cout<<"satri tagiyrdodashuda="<<a<<endl; 
 return; 
 } 
 Барномае нависед, ки онро ба даҳӣ гардонад. 
 #include <iostream> 
 #include <string.h> 
 using namespace std; 
 int main(){ 
 char bin[]; 
 long int dec=; 
 int i,v=; 
 cout<<"bin=";cin>>bin; 
 for (i=strlen(bin)-;i>=;i--) { 
 if (bin[i]==’’) 
 dec+=v; 
 v*=; 
 } 
 cout<<"dec="<<dec; 
 return; 
 } 
 мебошад. Барномае нависед, ки сатри додашударо ба системаи даҳӣ гардонад.
 #include <iostream> 
 #include <string.h> 
 using namespace std; 
 int main(){ 
 char st[]; 
 unsigned int dec=; 
 int i,v=,er=; 
 cout<<"st=";cin>>st; 
 strupr(st); 
 for (i=strlen(st)-;i>=;i--){ 
 if (st[i]>=’’ && st[i]<=’’) 
 dec+=v*(st[i]-); 
 else 
 if (st[i]>=’A’ && st[i]<=’F’) 
 dec+=v*(st[i]-); 
 else { 
 er=; 
 break; 
 } 
 v*=; 
 } 
 if(!er) { 
 cout<<st<<endl; 
 cout<<"dec="<<dec; 
 } 
 else { 
 cout<<"st="<<endl; 
 cout<<"error"<<endl; 
 cout<<"dec="<<dec; 
 } 
 return; 
 } 
 даҳӣ ба шонздаҳӣ табдил диҳад. 
 #include <iostream> 
 #include <string.h> 
 using namespace std; 
 int main(){ 
 int dec,r,i=; 
 char st[]; 
 cout<<"dec=";cin>>dec; 
 st[]=’\’; 
 do{ 
 r=dec %; 
 dec=dec/; 
 if(r<) 
 st[i--]=r+; 
 else 
 st[i--]=r+; 
 } 
 while (dec>); 
 ++i; 
 int j=; 
 while (st[i]) 
 st[j++]=st[i++]; 
 st[j]=’\’; 
 cout<<"st="<<st<<endl; 
 return; 
 } 
 истифода аз алгоритми мураттабсозии «ҳубобӣ» онҳоро аз рӯи алифбо мураттаб
 намуда, хориҷ кунад. 
 #include <iostream> 
 #include <string.h> 
 using namespace std; 
 int main(){ 
 char *temp; 
 int i,j; 
 const int n=; 
 char *array[]= 
 {"Saidov","Mulloev","Saidov","Aliev","Valiev","Toirov","Abdulloev"}; 
 for (i=;i<n;i++) 
 for (j=;j<n;j++) 
 if (strcmp(array[i],array[j])<){ 
 temp=array[i]; 
 array[i]=array[j]; 
 array[j]=temp; 
 } 
 for (i=;i<n;i++) 
 cout<<array[i]<<" \n "; 
 return;} 
 #include <iostream> 
 #include <string.h> 
 #include <stdio.h> 
 using namespace std; 
 int main(){ 
 int n[],s=; 
 float p[]; 
 char *mes[] ={"\","\","du\","se\","chor\","panj\"}; 
 int i; 
 cout<<"korkardi natilai imtihon\n"; 
 cout<<"Qimathoro dohil kuned\n"; 
 for(i=;i>=;i--){ 
 printf("%s->",mes[i]); 
 scanf("%i",&n[i]); 
 s+=n[i]; 
 } 
 for(i=;i<;i++) 
 p[i]=(float)n[i]/s*; 
 printf("%s %s %s%\n", "baho","miqdor","foiz"); 
 for(i=;i>=;i--) 
 printf("%s %i %.f%\n", mes[i],n[i],p[i]); 
 return; 
 } 
 тартибии элемент он элементро аз сатр хат занед. 
 #include <iostream> 
 #include <string.h> 
 using namespace std; 
 int main(){ 
 int i,m; 
 cout<<"m=";cin>>m; 
 char *a="In matn ast."; 
 for(i=m;i<strlen(a);a[i]=a[i+],i++); 
 cout<<a<<" "<<" "; 
 return; 
 } 
 миқдори m рамзро ба сатри S нусхабардорӣ кунад. 
 #include <iostream> 
 #include <string.h> 
 using namespace std; 
 void Str(char S[],char S[],int n, int m); 
 { 
 int i,j; 
 for (i=n,j=;j<m;S[j++]=S[i++]); 
 S[j]=’\’; 
 } 
 int main(){ 
 char S[]="matematika",S[]; 
 Str(S,S,,); 
 cout<<S<<endl; 
 return; 
 } 
 Масъалаҳо барои кори мустақилона 
 нашудааст. 
 ҷумларо ба ҳиҷҷоҳо тақсим кунед. 
 садонокҳо ва ҳамсадоҳо бошанд. 
 калимаи охирон ва аввалаи онро иваз кунад. 
 чанд фисади ҳарфҳои боқимондаро ташкил медиҳанд. 
 арифметикии ASCI-коди рамзҳои онро ҳисоб кунад. 
 не. 
 массив name ва tel хонда захира кунад. Сипас, бо ворид кардани номи ягон
 шахс рақами телефони вайро ёфта хориҷ кунад. 
 рамзгузорӣ кунад. Моҳияти ин усул чунин аст: Матн ва як адади бутуни 
 фосилаи дода мешавад. Ҳар як ҳарфи алифбо вобаста бо қимати 
 n ба тарафи рост кӯчонида мешавад. Масалан, ҳангоми n= будан ҳарфи A ба
 D, ҳарфи D ба E, ҳ ар ф и E ба F ва ҳоказо кӯчонида мешавад. Пас аз иҷрои ин
 амал, ба ҷои ҳарфи A ҳарфи D, ба ҷои D ҳарфи E, ба ҷои ҳарфи E ҳарфи F ва
 ғайра навишта мешавад. 
 кунад. 
 кунад. 
 «А»табдил диҳад. 
 «часпондан» калимаи роман тартиб дода шавад. 
 чап хондани калима s пайдо мешавад хориҷ карда шавад. 
 Барномае нависед, ки онро ба системаи даҳӣ гардонад. 
 Барномае нависед, ки сатри дода шударо ба системаи даҳӣ гардонад. 
 шонздаҳӣ табдил диҳад. 
 калима, калимаро аз сатр хат занед. 
 ба миқдори m рамзро ба сатри S нусхабардорӣ кунад. 
 шашум, нӯҳум ва ғ. буда ба ҳарфи “а ” иваз карда шаванд. 
 дар мавқеи тоқ-ро чоп кунед. Ва агар тоқ бошад, ҳарфҳои дар мавқеи ҷуфт
 чоп карда шаванд. 
 шаванд: якум, дувоздаҳум, дуюм, ёздаҳум,…, панҷум, ҳаштум, шашум, 
 ҳафтум. 
 якумро ташкил додаанд дар ҷумлаи дуюм дида мешаванд. 
 шавад. 
 Боби. Сохторҳо (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-ро низ истифода набарем, яъне 
 rec d={,.,.} нависем. 
 Методҳо. Муаррифӣ намудани методҳо 
 Метод ин функсияе мебошад, ки дар дохили сохтор муаррифӣ гардида, 
 метавонад амали муносиберо анҷом диҳад. Тамоми сигнатурҳои метод айнан ба
 функсия монанд буда, фарқияташ дар он аст, ки метод тавассути 
 тағйирёбандаҳои навъи сохтор даъват карда мешавад. Барои даъвати функсия 
 бошад, амали алоҳидае вуҷуд надорад, яъне метод қисми сохтор буда, барои 
 даъвати он бояд объект сохта шавад. Аз ин рӯ, методҳоро инчунин функсия -
 аъзо низ меноманд.. Натиҷаи бадастомадаи метод аз намуди даъвати он 
 вобастагӣ дорад. Наҳви умумии муаррифсозии метод шакли зеринро дорад: 
 Тип номи_метод(Рӯйхати аргументҳо ) 
 { 
 Тани метод 
 } 
 Барои пурратар шинос шудан ба ин матлаб мисолеро дида мебароем. 
 Мисол. Сохторе дорои ду майдони ададӣ дода шудааст. Барномае нависед, ки 
 суммаи майдонҳои онро ҳисоб кунад. 
 #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 "<<"firstName\t"<<"\tname\t"<<"Age\t"<<"maosh\n"; 
 for (int i=;i<;i++) 
 cout<<i+<<" "<<d[i].firstName<<"\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 minute; 
 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) (middLe 
 name) 
 Тавре ки аз ин ҷадвал дида мешавад, додаҳои як донишҷӯ сохторест, ки
 дорои чор майдон 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>>donishJu[i].name.l_name; 
 cout<<"f_name="; cin>>donishJu[i].name.f_name; 
 cout<<"m_name="; cin>>donishJu[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="<<donishJu[i].name.l_name<<endl; 
 cout<< "name="<<donishJu[i].name.f_name<<endl; 
 cout<< "LastName="<<donishJu[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","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; 
 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; 
 char ch; 
 }; 
 /* Муайян намудани сохтор ба сохтори пешина монанд, вале бо дигар ном. 
 */ 
 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> 
 #include <stdio.h> 
 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,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= мебошад. 
 Агар мо бо ягонтои ин додаҳо қимате ихтисос диҳем, он гоҳ аз он сар 
 карда, рақамгузорӣ карда мешаванд. 
 #include <iostream> 
 #include <stdio.h> 
 using namespace std; 
 int main(){ 
 enum color{red,blue, 
 black=,green,magenta,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 соҳиби дақиқаи бепул дар телефонаш мегардад. Гурӯҳе иборат аз 
 нафар донишҷӯ имтиҳон супориданд. Барномае нависед муайян кунад, ки чанд 
 нафар донишҷӯ ба мукофот сазовор мегарданд. Ному насаби онҳоро бо баҳоҳои
 фанҳояшон ба намуди ҷадвал бароред. 
 шарт ё фоизи зиёдшавӣ. Барномае нависед, ки амалиёти зеринро муайян кунад
 ва ба саҳифаи тасвир барорад: 
  Андози солонаи муштариён дар охири сол; 
  Муштариёне, ки пасандози баробар доранд; 
 зодрӯз дода шудаанд. Барномае нависед, то муайян кунад, ки оё дар гурӯҳ ягон
 нафар донишҷӯ дар рӯзи додашуда зодрӯз дорад ё не. Агар дошта бошад, 
 маълумотҳои онро бароред ва дар ҳолати акс пайғоми муносибе чоп кунад. 
 барориш ва кишвари истеҳсолшуда дода шудаанд. Барномае нависед, ки маркаи
 аз ҳама гаронтаринро бо маълумотҳояш барорад. 
 нависед, ки бо дохил кардани таърихи рӯз рӯзи баъдинаро барорад. (рӯз, моҳ ва
 сол алоҳида алоҳида дода мешаванд.) 
 шудааст: марка, рақам, соли барориш ва миқдори роҳи тайнамудаи мошин ва 
 ному насаби ронанда. Барномае нависед, ки автомобилҳое, ки роҳи баробар тай
 карданд, мураттаб карда барорад. 
 даъватшаванда ба сурати: ному насаб, дарозии қад ва вазн дода шудааст. 
 Мувофиқи фармони вазири мудофиа ҷавононеро, вазнашон аз кг кам, 
 баландии қадашон аз см кӯтоҳ набуда, синну солашон дар фосилаи - 
 ҷойгир аст, ба хизмат даъват карда мешаванд. 
 Барномае нависед, ки рӯйхати даъватшавандагонеро, ки ба талаботи 
 хизмати ҳарбӣ ҷавобгӯянд, мураттаб намуда, ба сурати ҳисобот барорад. 
 мебошад: Вақти ҳаракат (соати ҳаракат) ва масири ҳаракат. 
 Барномае нависед, ки: 
  Бо дохил кардани масири ҳаракат соати ҳаракатро муайян кунад; 
  Бо дохил кардани соат масири ҳаракатро муайян кунад. 
 Боби. Файлҳо 
 Муқаддима 
 То ҳол мо барномаҳое, ки навиштем ва истифода кардем, ҳамаи додаҳоро
 аз клавиатура дохил карда шуда, дар тағйирёбандаҳо, массивҳо ва сохторҳо 
 захира мекардем. Додаҳое, ки ҳаҷми зиёд доштанд, дар массивҳо ба хусус аз
 навъи сохторҳо захир мешуданд. Масалан, иттилооте комиле, ки вобаста ба 
 нафар донишҷӯ аст, дар массиве аз навъи сохтор ба дарозии захира 
 карда мешуд. Ин амал хело хуб аст, аммо вақте ки барномаро иҷро карданӣ 
 шавем, ба мо лозим мешавад, ки додаҳои ҳамаи донишҷӯёнро ба барнома аз 
 саҳифаи вурудӣ дохил кунем. Додаҳои воридкардашуда дар массиве аз навъи 
 сохтор захира мешуданд ва пардозиши лозимӣ болои онҳо гузаронида мешуд. 
 Массив дар ин сурат дар RAM захира мегардад, бо поён расидани кори 
 барнома додаҳо низ аз RAM нест мегарданд. Дафъаи дигар вақте ки барномаро
 иҷро карданӣ шавем, боз зарурати аз сари нав дохил намудани додаҳо пеш 
 меояд. Ин корро шояд барои нафар карда тавонем, вале агар теъдоди 
 донишҷӯён ба нафар баробар бошад, иҷрои амали мазкур хеле сангин ва 
 дилгиркунанда гардида, вақти зиёде сарф мешавад. 
 Агар додаҳои воридкардашударо дар диск захира намоем, ҳар маротиба аз
 сари нав дохил кардани онҳо душворӣ пеш намеорад. Додаҳо дар диск ба 
 намуди файл захира карда мешаванд, яъне ҳамон тавре, ки барои нигоҳ 
 доштани додаҳо дар ҳофизаи RAM аз массивҳо истифода мешуд, барои нигоҳ 
 доштани додаҳо дар диск аз файлҳо истифода карда мешавад. Ҳар файл дорои 
 ном аст, ва истифода-баранда метавонад файлро бо он ном дастёбӣ кунад. 
 Барои номгу-зории файлҳо аз қонуни номгузории идентификаторҳо истифода 
 бурда мешавад. Номи файл дорои ду қисмат мебошад, ки бо нуқта аз ҳамдигар
 ҷудо карда мешаванд. Қисмати аввалро номи файл ва қисмати дуввум, яъне 
 қисмати баъди нуқтаро пасванди файл меноманд. Пасванди файл дорои се ҳарф
 ё чор ҳарф буда, дар кадом барнома навиштани онро нишон медиҳад. Мисол 
 Ali.txt, Vali.bat, said.docs ва ғайра. 
 Барои захира кардани додаҳо дар диск барнома бояд файлро кушода 
 иттилооти аз саҳифаи калидӣ хондашударо дар он захира кунад. Файле, ки 
 барнома барои нигоҳ доштани иттилооти воридкарашуда мекушояд, файли 
 хуруҷӣ номида мешавад. 
 Додаҳое, ки бо воситаи барнома дар файл захира мешаванд, метавонанд 
 ба воситаи барномаи дигар ё ҳамон барнома аз файл хонда шуда, мавриди 
 истифода қарор гиранд. Файле вурудӣ номида мешавад, агар танҳо барои 
 хондани иттилоот кушода шавад.. Файлеро, ки дар он ҳам амали хондан ва ҳам
 навиштани додаҳо сурат мегирад файли вурудӣ-хуруҷӣ ном дорад. 
 Дар забони С++ барои амали дохилкунӣ ва хориҷкуниро ба файлҳо анҷом 
 додан метавон аз усули С ва ё усули С++ истифода кард. Дар забони С/С++ 
 нисбат ба забонҳои дигар функсияҳои зиёде вуҷуд доранд, ки амалиёти I/O-ро
 иҷро мекунанд. Баръакси дигар забонҳо, забони С/С++ байни дастёбӣ ба 
 намуди мустақим ва тартибӣ фарқ намегузорад. Аслан дар забони С/С++ ду 
 намуди файлҳои додаҳо мавҷуд аст: 
 ) Файли додаҳои ба ҷараён вобаста (stream oriented) 
 ) Файли додаҳои ба система вобаста (system oriented). 
 Кор бо файлҳои додаҳои ба ҷараён вобаста назар ба файлҳои додаҳои ба
 система вобаста осонтар аст, аз ин рӯ, навъи стандартӣ ё ҷараёнгарро дар ин боб
 мавриди баҳс қарор медиҳем. 
 Файлҳои додаҳои ҷараёнгар низ ба ду гурӯҳ ҷудо мешаванд: 
 Гурӯҳи аввал танҳо аз рамзҳо таркиб ёфтаанд, яъне рамз метавонаад 
 намуди гуногуни додаҳо бошад, ба монанди ададҳо ва сатрҳо. Барои навиштани
 додаҳо ва ё хондани додаҳо дар ин навъ файлҳо аз функсияҳои монанди printf()
 ва scanf() истифода бурда мешавад. Файли додаҳои ин навъ, файли додаҳои 
 қолабдор номида мешавад. 
 Гурӯҳи дигари файлҳои ҷараёнгар файлҳои додаҳои беқолаб номида 
 шуда, додаҳои ин навъ файлҳо сохторҳо ва массивҳо мебо-шанд. Барои 
 пардозиши ин гуна файлҳо боз функсияҳои дигаре низ вуҷуд доранд. Ин 
 функсияҳо имконият медиҳанд, ки додаҳо як-як ё якбора навишта ва хонда 
 шаванд. 
 Тавре ки гуфтем, кор бо файлҳои системавӣ назар ба файлҳои ҷараёнгар
 душвортар мебошад, чунки файлҳои системавӣ вобаста ба системаи омилӣ 
 мебошанд ва инчунин барои пардозиши онҳо функ-сияҳои махсус лозим аст. 
 Додаҳо аслан бо яке аз чор усули дар поён овардашуда метавонанд дар 
 файлҳо захира шаванд ва ё аз он хонда шаванд. 
 Ҳар маротиба як рамз хонда ё навишта мешавад, яъне додаҳо як рамз 
 навишта ё хонда мешаванд. Ба монанди он ки дар гузашта мушоҳида кардем, ки
 як рамз бо ёрии функсияҳои getchar(), putchar хонда ё навишта мешуд. Ин 
 функсияҳо аслан дар услуби С ҳастанд, барои С++ бошад, функсияи get() ва 
 getline() ин амалро иҷро мекунанд. 
 Дар ин равиш додаҳо ба намуди маҷмӯи рамзҳо яъне як сатр хонда ё 
 навишта мешаванд. Барои иҷрои ин амалҳо функсияи gets() (барои хондани як
 сатр) ва функсияи puts() ( барои навиштани як сатр) истифода бурда мешавад.
 Додаҳо ҳангоми навиштан бо як формати махсусе навишта шуда, 
 дар вақти хондан бо он формат хонда мешаванд. 
 Барои иҷрои ин амал аз функсияҳои scanf() ва printf(), ки шумо бо онҳо
 шинос ҳастед, истифода бурда мешаванд. 
 Дар ин навъ додаҳо ба намуди як блок ё сохтор дар файлҳо навишта ё 
 хонда мешаванд. Блок гуфта, маҷмӯи ифодаҳо (ё операторҳои) бо ҳамдигар аз
 ҷиҳати мантиқӣ алоқамандро меноманд, ки дар дохили қавсҳои системави 
 «{…}» навишта мешаванд. 
 Ҳангоми навиштан ё хондани додаҳо дар файлҳо системаи омили 
 метавонад, таъсир расонад. Функсияҳои I/O –и стандартӣ ANSI дар забони 
 С/С++ метавонад файлҳоро ба ду намуд: матнӣ ва бинарӣ дастёбӣ намоянд. 
 Файлҳо ва ҷараёнҳо (Files and streams) 
 Пеш аз он ки мо дар бораи системаи I/O сухан гӯем, бояд фарқи байни 
 ҷараён ва файлро бидонем. Забони С /С++ барои барномасоз як василаеро ба 
 вуҷуд меорад, ки нисбат ба дастгоҳ ҷудо аст, яъне як ҷудоии байни барномасоз
 ва дастгоҳ. Ин ҷудоисози ҷараён номида мешавад. Дастгоҳ аслан бингарем, 
 ҳамон як файл аст ва ҷараён воситаест байни он ва барнома ба монанди пул 
 (мост) алоқа барқарор мекунад. 
 Ҷараёнҳо 
 Яке аз хусусиятҳои забони С/С++ дар он аст, ки байни дастгоҳҳо фарқ 
 намегузорад, яъне барои С/С++ фарқ надорад, ки файл дар диски мантиқӣ ё 
 ягон барандагони иттилооти дигар дода шудааст. Ҳама вақт амали I/O ба 
 воситаи як ҷараён, ки ба файлҳо вобаста аст, амалӣ мегардад. Агар як ҷараёнро
 аз рӯи байтҳо ба назар гирем, намуди зеринро дорад. 
 Тавре ки дар мавзӯи сатрҳо гуфта будем, ҳар сатр ба як рамзи NULL ба
 анҷом мерасад. Дар ин ҷ о м ета вон гуфт, ки ҳ ар файл б о як рамзи EOF ба анҷом
 мерасад. Калимаи EOF низ шакли мухтасари End Of File буда, доими 
 китобхонаи stdio.h ба ҳисоб меравад. Вақте ки як файл барои навиштан ё 
 хондан кушода мешавад, дар ин ҳолат як ҷараён низ эҷод мегардад. Ба таври
 дигар гӯем, забонии С/С++ додаҳои як файлро ба монанди як массиви рамзии 
 якченака дастёбӣ мекунад. Навиштани додаҳо дар як файл ин навиштани 
 додаҳои як ҷараён ва хондани додаҳои як файл хондани як ҷараён мебошад. 
 Пас, барои хондан ва навиштани файл бояд, ки ҷараёне эҷод гардад. Як ҷараён
 ҳангоми муаррификунии як тағйирёбандаи ишорагаре аз навъи сохтори файл ба
 вуҷуд меояд. Як барнома метавонад дорои як ё якчанд ҷараён бошад. 
 Ҷараёнҳои стандартӣ (standard streams) 
 Ҳамаи он амалиёти дохилкунӣ ва хориҷкуние, ки то ҳоло мавриди 
 баррасӣ ва баҳс қарор дода будем, аз ду стандарт иборат буданд, яъне барои
 дохилкунӣ стандарти stdin (standard input) ва барои хориҷкунӣ аз стандарти
 stdout (standard output). Ба сифати ҷараёнҳои дохилкунӣ ва хориҷкунӣ дар 
 забони С++ се ҷараён истифода бурда мешаванд. 
 Ин ҷараёнҳо ба тарминали мо ишора мекунанд ва мувофиқан барои 
 иҷрои амали хабар додан дар ҳолати хатогӣ, хориҷкунӣ ва дохилкунӣ истифода
 бурда мешаванд. Аз рӯи наҳви захираи додаҳо дар забони С/С++ ду стандарт 
 вуҷуд дорад: 
  стандартӣ матнӣ (textstream) 
  бинарӣ (binarystream), 
 яъне дар забони С/С++ додаҳо ба ду намуд: бинарӣ ва дар қолаби ASCII захира
 мешаванд. 
 Ҷараёни матнӣ (text stream) 
 Як ҷараёни матнӣ ё додаҳои матнӣ додаҳое, ҳастанд, ки аз сатрҳо таркиб
 ёфтаанд ва ҳар сатр бо як рамзи охири хат ё хати нав ба поён мерасад. Вақте ки
 ин сатрҳо ба ҳофиза хонда мешаванд, функсияи замони иҷро (runtime functions)
 рамзи хати навро дар охири сатрҳо илова мекунад. Ин амалиёт мумкин дар 
 системаҳои омили гуногун иҷро шавад. Масалан, дар IBM-ҳои ибтидоӣ ҳар 
 рамзи хати нав ҳамчун як индекс аз ишорагарҳо фаҳмида мешуд. Аз ин рӯ, 
 файлҳои матнӣ дар муҳитҳои гуногун созгор мебошанд ва ҳангоми кор кардан 
 бо онҳо бояд дар назар дошт, ки файлҳои матние, ки болои як система иҷро 
 мешаванд, мумкин аст, ки дар системаи дигар иҷро нашаванд. 
 Ҷараёнҳои бинарӣ ё дӯӣ 
 Як ҷараёни бинарӣ ҷараёнест, ки бо додаҳои аз дастгоҳи берунӣ ба даст
 омада муносибати як ба як дорад, яъне додаҳо дар ин навъ файлҳо ба намуди
 пайдарпайии байтҳо захира мешаванд. Ба таври дигар гӯем, дар қолаби бинарӣ
 компилятор ҳеҷ гуна тафсире рӯи байти додаҳо анҷом намедиҳад, балки 
 дақиқан байтҳоро ба ҳамон намуде, ки зоҳир мешаванд, мехонад ва менависад.
 Файлҳои бинарӣ аслан дар мавриди додаҳои ғайриматнӣ (nontextual data), ки
 дар ин сохтор хат вуҷуд надорад, яъне муҳтавои файл нигоҳ дошта мешавад, 
 истифода бурда мешаванд. 
 Фарқияти асосӣ байни додаҳои матнӣ ва бинорӣ ё дӯӣ 
 Додаҳои матнӣ ва бинорӣ аз рӯи хосиятҳои зерин аз ҳамдигар фарқ 
 мекунанд. 
 Тавре ки баён шуд, наҳви захира шудани рамзи охири хат ё хати нав 
 (“\n”) дар ду намуди файлҳо аз ҳамдигар фарқ мекунад, яъне дар файлҳои навъи
 матнӣ вуҷуд дораду дар файлҳои бинорӣ не. 
 Фарқияти дигари ин ду навъ файлҳо дар муайянкунии охири файл ҳаст, 
 дар ҳар ду намуд файлҳо барои муайянкунии охири файл функсияи EOF 
 истифода бурда мешавад. Дар файлҳои матнӣ вақте ки идоракунӣ (хондан ё 
 навиштан) ба ин мавқеъ расид, онро мефаҳмонад, ки файл ба охир расидааст,
 вале дар файлҳои намуди бинори EOF низ як рамзе аз ҷузъи файл фаҳмида 
 мешавад. Яъне аз ин ҷо хулоса мебарояд, ки интиҳои файл дар ду намуд файлҳо
 якхела нест. 
 Фарқияти асосии дигаре байни ин ду намуд файлҳо дар наҳвии захира 
 шудани ададҳо мебошад. Дар намуди матнӣ ададҳо ба намуди сатре аз рамзҳо 
 дар файл захира карда мешаванд. Дар намуди бинорӣ бошад, ҳамон тавре, ки 
 дар хотира ҳастанд, дар файл захира карда мешаванд. Масалан, адади бутуни
 кӯтоҳ ( short int)-и, ки дарозиаш ду байт аст ва адади ҳақиқӣ (float)-и,, ки дарозиаш байт аст, ба сурати зерин дар ҳофиза ҷой мегиранд:, 
 Аз ин намоиш дар файҳои матнӣ адади бутуни кӯтоҳ, ки аз се рамз иборат
 аст, дар хотира се байтро ишғол мекунад ва адади дуюм, ки дорои рамз аст,
 дар ҳофиза байтро ишғол мекунад. Тавре ки дар мавзӯи сатрҳо медонем, ҳар
 як рамз як байт ҳисоб карда мешавад. Ин ададҳоро агар дар файлҳои бинори 
 захира кунем, барои адади, ки аз навъи бутуни кӯтоҳ аст, байт ва барои
 адади ҳақиқии, ҳамаги байт аз ҳофиза банд карда мешаваду халос. 
 Кор бо файлҳои матнӣ 
 Дар забони С++ барои кор кардан бо файлҳои матнӣ ду ҷараён истифода 
 бурда мешавад. Ҷараёни ifstream-барои кор кардан бо файл дар реҷаи хониш ва
 ҷараёни ofstream - барои кор кардан бо файл дар реҷаи навиштан. Агар хоҳем,
 ки ҳам дар реҷаи хониш ва ҳам дар реҷаи навиштан бо файл кор кунем, он гоҳ
 лозим меояд, ки аз ҷараёни fstream истифода барем. Барои ба ин ҷараёнҳо 
 дастрас шудан лозим аст, ки библиотекаи <fstream.h> пайваст карда шавад. 
 Додаҳо аслан дар файли матнӣ аз рӯи алгоритми зерин навишта 
 мешаванд: 
 Сохтани як файли матнӣ ва навиштани додаҳо дар он 
 Барои навиштани додаҳо дар як файли матнӣ аввал тағйирёбандае аз 
 навъи ofstream ба сурати зерин муаррифӣ карда мешавад: 
 ofstream ofs; 
 Дар ин ҷо ofs номи ҷараён мебошад. Барои номгузории ҷараёнҳо низ аз 
 қонуни номгузории идентификаторҳо истифода мебарем. 
 Барои навиштани додаҳо дар файл бояд, ки аввал файл кушода шавад. Ин
 амал бо ёриии функсияи open() ба сурати зерин иҷро карда мешавад: 
 ofs.open(“D:\\File_name”, mode) 
 Дар ин ҷо ofs тағйирёбандае аз навъи ҷараёни ofstream, open() функсияе,
 ки бояд файлро боз кунад ва ё файли нав эҷод кунад, Filename –номи файл 
 (барои номгузорӣ ба файлҳо низ аз қонуни номгузории идентификаторҳо 
 истифода мебарем.) ва mode бошад, реҷаи кушодани файлро ифода мекунад, 
 яъне он мушаххас мекунад, ки файл бо чи мақсад кушода шудааст. 
 Реҷаҳое, ки бояд бо ёрии яке аз онҳо файли матнӣ кушода шавад,
 дар ҷадвали зерин оварда шудаанд: 
 № Навъи файл Маъно ё амали иҷро мешудагӣ 
 ios::in Кушодани файл дар реҷаи хониш 
 ios::out Танҳо барои навиштан кушодани файли нав. Агар файли нав 
 бо ягон файли мавҷудбуда ҳамном бошад, файли кӯҳна нест 
 мешавад. 
 ios::app Файли мавҷудбударо (файли дуӣ) барои дар охираш илова 
 намудани додаҳо мекушояд. Агар бо номи нишондодашуда 
 файл мавҷуд набо-шад, ба таври автоматӣ эҷод мегардад. 
 ios::trunk Тоза кардани файл. 
 ios::nocreate Амали кушодани файлро иҷро намекунад, агар файл мавҷуд 
 набошад. 
 ios::noreplace Файли мавҷудбуда кушода намешавад. 
 Ҷадвали. 
 Агар ҳангоми кушодани файл mode нишон дода нашуда бошад, 
 компилятор ба таври худкора (автоматӣ) барои ҷараёни ifstream mode-и ios::in
 ва барои ҷараёни ofstream mode-и ios::out-ро истифода мебарад. Барои 
 кушодани як файл як чанд роҳ мавҷуд аст, ки бо ёрии яке аз онҳо метавон 
 файли лозимиро кушод. Бигзор файле ба номи sample.txt дар диски D мавҷуд 
 бошад, пас, барои кушодани он яке аз равиш (роҳ)-ҳои зерин истифода бурда
 мешаванд: 
 ) ofstream ofs; 
 ofs.open(“D:\\sample.txt”, ios::out); 
 ) ofstream ofs; 
 ofs.open(“D:\\sample.txt”); 
 ) ofstream ofs (“D:\\sample.txt”, ios::out); 
 Ҳангоме, ки амали кушодани файл ба таври табии анҷом мепазирад, 
 тағйирёбандаи ofs дорои қимати true мегардад. Дар акси ҳол он ба қимати false
 баробар мешавад. 
 Пас аз он ки файл бо муваффақият дар реҷаи навиштан кушода шуд, бояд
 додаҳои лозимӣ дар он навишта шаванд. Навишти додаҳо дар файли матнӣ 
 монанди навиштани додаҳо дар саҳифаи тасвир буда, фарқият дар он аст, 
 додаҳо дар саҳифаи тасвир бо ёрии объекти cout анҷом мегирифтанд, вале дар
 ин ҷо бошад, бо ёрии ҳамон тағйирёбандае, ки аз навъи ҷараёни ofstream эълон
 гардидааст. Масалан, барои навиштани як сатр дар файл, оператори зерин 
 истифода бурда мешавад. 
 ofs<<”In Sample File ast!”; 
 Амали навиштан адад бошад, намуди зеринро дорад: 
 ofsу<<; 
 Пас аз навиштани додаҳо дар файл бояд, ки файл баста шавад. Агар файл
 баста нашавад, пас аз итмомрасии кори барнома он ба таври худкора (автоматӣ)
 баста мешавад, вале дар ин сурат додаҳои дар ҷараён буда ба файл навишта 
 намешаванд. Пас, барои нигоҳ доштани иттилооте, ки дар як ҷараён ҳастанд, ба
 мо лозим аст, ки бо ёрии функсияи close() файлро маҳкам кунем, ин функсия ба
 сурати зерин истифода бурда мешавад: 
 ofs.close(); 
 Акнун, ки ба навиштани додаҳо дар файл шинос шудем, мисолеро дида 
 мебароем. 
 Мисол. Барномае нависед, ки ҷадвали зарби ададҳои аз то -ро дар 
 файли хориҷ кунад. 
 #include <iostream> 
 #include <fstream> 
 using namespace std; 
 int main(){ 
 ofstream ofs; 
 ofs.open("simple.txt"); 
 int i, j; 
 for(i=;i<=;i++) 
 for(j=;j<=;j++){ 
 ofs<<i*j<<"\t "; 
 cout<<endl; 
 } 
 return; 
 } 
 Хондани додаҳо аз як файли матнӣ 
 Барои хондани додаҳо аз як файли матнӣ, дар аввал тағйирёбан-дае аз
 навъи ifstream ба сурати зерин эълон карда мешавад: 
 ifstream ifs; 
 Барои хондани додаҳо аз файл бояд, ки аввал файл кушода шавад. Бо ёрии
 оператори функсияи open() файли лозимиро мекушояд: 
 ifs.open(“D:\\File_name”, mode) 
 Дар ин ҷо ifs тағйирёбандае аз навъи ҷараёни ifstream, open() зерфунксияе,
 ки бояд файлро боз кунад, Filename –номи файл (номи файл метавонад аз 
 пайдарпайии ҳарфҳо, рақамҳо ва ё рамзи хати поён иборат бошад) ва mode 
 бошад, реҷаи кушодани файлро муайян мекунад, яъне он мушаххас мекунад, ки
 файл ба чи хотир кушода шудааст. Ҳамаи он реҷаҳое, ки файл бо яке аз онҳо
 кушода мешавад, дар ҷадвали оварда шудаанд. 
 Пас аз он ки файл бомуваффақият дар реҷаи навиштан кушода шуд, бояд 
 додаҳои лозимӣаз он хонда шаванд. Хондани додаҳо аз файли матнӣ низ 
 монанди хондани додаҳо аз саҳифаи калидӣ буда, фарқият дар он аст, додаҳо аз
 саҳифаи калидӣ тавассути объекти cin анҷом мегирифтанд, вале дар ин ҷо бо
 ёрии ҳамон тағйирёбандае, ки аз навъи ҷараёни ifstream эълон гардида буд,
 хонда мешавад. Масалан, барои хондани як адади бутун аз файл оператори 
 зерин истифода бурда мешавад. 
 ifs<<a; 
 Агар дар файли мавриди назар ду адад навишта шуда бошад ва дар байи 
 онҳо аломати фосила мавҷуд бошад, оператори ifs<<a рамзи фосиларо ҳамчун 
 охири файл мефаҳмад. Аз ин ҷо саволе ба миён меояд, ки чӣ бояд кард, то 
 ҳамаи додаҳои файлро ба даст овард? Барои ҳамаи додаҳои файлро ба даст 
 овардан бояд, ки он пас аз ҳар хониш санҷида шавад, ки оё интиҳои файл аст ё
 не. Барои муайянкунии интиҳои файл функсияи eof() ба сурати ifs.eof() 
 истифода бурда мешавад. Ҳангоме ки идоракунӣ(control) ба охири файл 
 мерасад, тағйирёбандаи ifs дорои қимати true мегардад. Барои ҳамаи додаҳои
 дар файл мавҷуд бударо хондан ин функсия дар дохили ҳалқаи такрории while ё
 do… while истифода карда мешавад. 
 Мисол. Дар як файли матнӣ элементҳои массиви навъи бутун навишта 
 шудаанд. Ҳамаи элементҳоро дар саҳифаи тасвир ба чоп диҳед. 
 #include <iostream> 
 #include <fstream> 
 using namespace std; 
 int main() 
 { 
 ifstream ifs; 
 int k=,a; 
 ifs.open("simple.txt"); 
 if (ifs){ 
 while (!ifs.eof() ) 
 { 
 ifs>>a; 
 cout<<a<<" "; 
 k++; 
 } 
 ifs.close(); 
 cout<<endl; 
 cout<<"k="<<k<<endl; 
 } 
 else 
 cout<<"File not found\n"; 
 return; 
 } 
 Ҳангоми хондани додаҳо аз файл, метавонем, ки додаҳои навро низ дар 
 файл ҳамроҳ кунем. Барои иҷрои ин амал аз ҳар ду ҷараён ҳам ofstream ва ҳам
 ifstream истифода мебарем. Дар аввал тавассути тағйирёбандаи ҷараёни ifstream
 додаҳоро хонда, баъд бо ёрии тағйирёбандаи ҷараёни ofstream додаҳои навро
 дар файл менависем. 
 Мисол. Элементҳои массив дар файли матнии simple.txt мавҷуд 
 мебошанд. Барномае нависед, ки ин додаҳоро дар саҳифаи тасвир пешниҳод 
 намуда, сипас, ҳар як элементро як воҳид афзуда, дар охири файл илова кунад.
 #include <iostream> 
 #include <fstream> 
 using namespace std; 
 int main(){ 
 ifstream ifs; 
 ofstream ofs; 
 int k=,i; 
 int *a, b; 
 a=new int[]; 
 ifs.open("simple.txt",ios::in); 
 if (ifs) 
 { 
 while (!ifs.eof() ) 
 { 
 ifs>>a[k]; 
 cout<<a[k]<<" "; 
 k++; 
 } 
 cout<<endl; 
 cout<<"k="<<k<<endl; 
 for (i=;i<=k;i++) 
 a[i]=a[i]+; 
 ifs.close(); 
 ofs.open("simple.txt",ios::app); 
 ofs<<"\t"; 
 for (i=;i<=k;i++) 
 ofs<<a[i]<<" "; 
 ofs.close(); 
 } 
 else 
 cout<<"File not found\n"; 
 return; 
 } 
 Ҳангоми як маротиба иҷро гаштани барнома ҳамаи додаҳои файл дар 
 саҳифаи тасвир пайдо мешаванд ва дар файл низ додаҳои нав навишта 
 мешаванд. Вале ба ғайр аз додаҳои дар файл мавҷудбуда, дар охири додаҳо дар
 саҳифаи тасвир як ададе ба андозаи навъии int низ чоп мешавад. Ин метавонад,
 ҳангоми якчанд маротиба иҷро намудани барнома ба кори барнома халал ворид
 кунад. Ба хотири он ки ин адад дар саҳифаи тасвир чоп нагардад, ба мо лозим
 аст, ки оператори охири барномаро ба сурати зерин тағйир диҳем. 
 for (i=;i<=k;i++) 
 if (i<k-) 
 ofs<<a[i]<<" "; 
 else 
 ofs<<a[i]; 
 Пас аз тағйирдиҳӣ барномаи мо намуди зеринро мегирад. 
 #include <iostream> 
 #include <fstream> 
 using namespace std; 
 int main(){ 
 ifstream ifs; 
 ofstream ofs; 
 int k=,i; 
 int *a, b; 
 a=new int[]; 
 ifs.open("simple.txt",ios::in); 
 if (ifs) 
 { 
 while (!ifs.eof() ){ 
 ifs>>a[k]; 
 cout<<a[k]<<" "; 
 k++; 
 } 
 cout<<endl; 
 cout<<"k="<<k<<endl; 
 for (i=;i<=k;i++) 
 a[i]=a[i]+; 
 ifs.close(); 
 ofs.open("simple.txt",ios::app); 
 ofs<<"\t"; 
 for (i=;i<k;i++) 
 if (i<k-) 
 ofs<<a[i]<<" "; 
 else 
 ofs<<a[i]; 
 ofs.close(); 
 } 
 else 
 cout<<"File not found\n"; 
 return; 
 } 
 Кор бо файлҳои бинорӣ ё дуӣ 
 Тавре ки қаблан қайд карда будем, додаҳо дар файлҳои матнӣ ба сурати
 рамзҳо захира карда мешаванд. Дар файлҳои бинорӣ бошад, додаҳо ба сурати 
 пайдарпайи байтҳо навишта ва ё аз он хонда мешаванд. Барои кор кардан бо 
 файлҳои бинорӣ функсияҳои зиёде истифода бурда мешаванд. Амали сохтан ва 
 навиштани додаҳо дар як файли бинорӣ аз рӯи алгоритми зерин иҷро карда 
 мешавад. 
 ин ҷо FILE сохтори файл аст. 
 маҳкам карда мешавад. 
 Барои хондани додаҳо аз як файли бинорӣ бошад, аз алгоритми зерин 
 истифода бурда мешавад: 
 ин ҷо FILE сохтори файл аст. 
 хонда мешаванд. 
 маҳкам карда мешавад. 
 Функсияҳои зиёде барои кор кардан бо файлҳои бинорӣ мавҷуданд, ки 
 баъдтар дар ин бора эзоҳ хоҳем дод. 
 Системаи I/O-и буфердор (buffering I/O system) 
 Ба ғайр аз функсияҳое, ки мавриди истифода қарор додем, дар забони С++
 функсияҳои дигаре барои кор бо файлҳо мавҷуданд, ки онҳоро системаи I/O- и
 буфердор мегӯянд. Системаи I/O-и забони С++ дар китобхонаи <stdio.h> 
 муаррифӣ карда шудаааст. Барои бо он дастрас шудан бояд китобхонаи мазкур
 пайваст карда шавад. Функсияҳои муҳимтарини системаи I/O- и буфердор дар 
 ҷадвали зерин оварда шудаанд. 
 № Номи функсия Амали иҷро шаванда (operation) 
 (function name) 
 fopen() Як stream-ро мекушояд. 
 fclose() Як stream-ро маҳкам мекунад. 
 puts() Як рамзро ба як stream менависад. 
 gets() Як рамзро аз як stream мехонад. 
 fseek() Байти нишондодашуда (мушаххасшуда)-ро дар stream 
 ҷустуҷӯ мекунад. 
 fprintf() Ба функсияи pritnf() монанд амалро иҷро мекунад. 
 fscanf() Амали ба функсияи scanf() монандро иҷро мекунад. 
 feof() Агар ба интиҳои файл расила бошад, қимати true-ро 
 бармегардонад. 
 ferror() Дар вақти ба амал омадани хотогӣ қимати true-ро 
 бармегардонад. 
 rewind() Аз мавқеи охири файл ба аввали файл бармегардад. 
 remove() Як файлро нест мекунад. 
 freopen() Як файлро кушода,операторҳои дохилкунӣ ва 
 хориҷкуниро ба он вобаста мегардонад 
 Бояд қайд кард, ки функсияҳои системаи I/O- и буфердор то пур шудани
 буфер маълумотҳоро дар он нигоҳ медоранд. Пас аз пур шудани буфер 
 амалиёти лозимиро болои додаҳои захирашуда анҷом медиҳанд. 
 Ишорагари файл (File pointer) 
 Унсури асосие, ки системаҳои I/O –и буфердорро бо ҳамдигар 
 мепайвандад, ишорагари файл аст. Ишорагари файл тағйирёбандаест, ки ҳолати
 файл(status File), мавқеи ҷориии файл ё номи файлро ифода мекунад (нишон 
 медиҳад). Ишорагари мазкур дар библиотекаи <stdio.h> муаррифӣ карда 
 шудааст. Наҳви умумии истифодаи ин ишорагар ба сурати зайл аст: FILE 
 *ptvar; 
 Кушодан ва пӯшидани як файли бинорӣ 
 Вақте ки бо файлҳои додаҳои ҷараёнгар кор мекунем, бояд пеш аз ҳама,
 як миқдореро аз ҳофиза ҷудо кунем, то ин ки додаҳо дар вақти мубодила дар он
 ба таври муваққатӣ нигоҳ дошта шаванд. Ин амал дар сурате иҷро мегардад, ки
 агар ишорагар ба файл муаррифӣ гардида бошад. Наҳви муаррифии ишорагари 
 файл шакли зеринро доард: FILE *ptvar 
 Дар ин ҷо FILE як навъ сохтор (structure)-и махсусест, ки барои дар буфер
 нигоҳ доштан минтақае аз пешбинӣ шудааст. Тағйирё-бандаи ишорагари *ptvar
 бошад, ба ибтидои он мавқеъ ишора мекунад. 
 Барои ин ки як файл эҷод ё пардозиш карда шавад, зарур аст, ки он 
 кушода шавад. Амали мазкур номи файлро ба минтақаи буфер вобаста намуда, 
 муайян мекунад, ки файл барои чӣ кушода шудааст. (масалан, барои хондан 
 (read only File) ё барои навиштан (write only File) ва ё инки ҳам барои хондан ва
 ҳам барои навиштан. 
 Барои кушодани як файл функсияи fopen() истифода бурда мешавад, ки 
 наҳви он ба сурати зерин аст: 
 Ptvar=fopen(File_name, File_type) 
 Дар ин ҷо ptvar як тағйирёбандаи ишорагар ба номи FILE мебошад, 
 параметри File_name номи файл ва параметри File_type бошад, сабаби 
 кушодани файлро мушаххас мекунад. Функсияи fopen() як ҷараёнро барои 
 истифода файл эҷод мекунад. Наҳви умумии функсияи мазкур намуди зеринро 
 дорад: 
 FILE *fopen(char *File_name, *mode) 
 Дар ин ҷо mode –сатрест, ки вазъияти кушодашавии файлро нишон 
 медиҳад. Дар забони С/С++ mode ё File_type-ҳои зиёде мавҷуданд, ки 
 муҳимтаринашон дар ҷадвали зерин оварда шудааст: 
 № Навъи Маъно ё амали иҷро мешудагӣ 
 файл 
 “r”, Файли додаи мавҷудбударо (файли матнӣ) барои хондан 
 “rt” мекушояд. 
 “w”, Як файли навро танҳо барои навиштан мекушояд. Агар файли нав 
 “wt” бо ягон файли мавҷудбуда ҳамном бошад, файли кӯҳна нест 
 мешавад. 
 “a”, Як файли мавҷудбударо (файли матнӣ) барои илова намудан 
 “at” мекушояд. Агар бо номи нишондодашуда файл мавҷуд набошад, 
 ба таври автоматӣ сохта мешавад. Иттилооти нав дар охири файл 
 захира мешавад. 
 “r+”, Як файли мавҷудбударо ҳам барои хондан ва ҳам барои навиштан 
 “r+t” мекушояд. 
 “w+”, Файли наве ҳам барои хондан ва ҳам барои навиштан мекушояд. 
 “w+t” Агар бо ин ном файл мавҷуд бошад, нест мешавад. 
 “a+”, Файли мавҷудбударо ҳам барои хондан ва ҳам барои илова 
 “a+t” намудан мекушояд. Агар бо ин ном файл мавҷуд набошад, ба 
 таври автоматӣ файли нав сохта мешавад. 
 “rb” Як файли бинориро барои хондан мекушояд. 
 “wb” Як файли бинориро барои навиштан ме-кушояд. 
 “ab” Файли бинорро барои илова намудани маълумотҳои нав 
 мекушояд. 
 “r+b” Як файли бинориро барои хондан ё навиш-тан мекушояд. 
 “w+b” Як файли бинориро ҳам барои хондан ва ҳам барои навиштан 
 мекушояд. 
 “a+b” Як файли бинориро барои хондан ё навиш-тани мекушояд ва ё аз 
 нав месозад. 
 Чи хеле ки аз ин ҷадвал мушаххас шуд, як файл метавонад барои хондан ё
 навиштан ва ё барои хондану навиштан кушода ё эҷод гардад. Инчунин аз 
 ҷадвал айён мегардад, ки файлҳо метавонанд ба намуди матнӣ ё бинорӣ кушода
 ва ё эҷод гарданд, яъне mode-ҳои бинорӣ аз mode-ҳои матнӣ фарқ доранд. 
 Масалан, агар мо хоҳем, ки файли матниеро барои навиштан кушоем, 
 оператори зерин кифоягӣ мекунад. 
 Fp=fopen(“text”,”r”) 
 Дар ин ҷо fp ишорагаре бо номи файл аст. Оператори мазкур дар амалия
 аслан ба намуди зерин истифода бурда мешавад. Мисол: 
 #include <iostream> 
 #include <stdio.h> 
 using namespace std; 
 int main() 
 { 
 FILE *fp; 
 if ((fp=fopen("text","w"))==NULL) 
 { 
 puts("Cannot open File\n"); 
 exit(); 
 } 
 return; 
 } 
 Равиши мазкур ҳар хатогие, ки ҳангоми кушодани файл пеш меояд ошкор 
 менамояд. Аслан хатогиҳо дар ҳолати пур будани диск ва дигар ҳолатҳои 
 монанди ин пеш меоянд. NULL бошад, як макросе мебошад, ки дар 
 библиотекаи <stdio.h> нигоҳ дошта мешавад. Дар ин ҷо он барои санҷиши шарт
 истифода шудааст. 
 Тавре ки қаблан баён карда будем, агар функсияи fopen()-ро барои 
 хондани як файл истифода барем, ба ин ном файл мавҷуд набошад, файли нав 
 сохта мешавад. Агар хоҳем, ки додаҳои лозимиеро дар охири файл нависем, 
 истифодаи mode-и “a” кифоя аст. Дар ин ҳолат низ бо номи мавриди назар 
 файли мавҷудбуда нест мешавад. 
 Як чизро набояд фаромӯш кард, ки дар ҳолати нолозим шудани файл бояд
 он баста шавад, яъне маҳкам гардад. Барои бастан ё маҳкам намудани як файл
 функсияи fclose() даъват карда мешавад. Мисол: 
 #include <iostream> 
 #include <stdio.h> 
 using namespace std; 
 int main(){ 
 FILE *fp; 
 if ((fp=fopen("text","w"))==NULL) 
 { 
 puts("Cannot open File\n"); 
 exit(); 
 fclose(fp); 
 } 
 return; 
 } 
 Дар ин ҷо агар файл бомуваффақият кушода нашавад, пайғоми “Cannot 
 open File\n” дар саҳифаи тасвир намоиш дода шуда, файл маҳкам карда 
 мешавад. Ин мисолро метавон низ ба намуди зерин навишт. 
 #include <iostream> 
 #include <stdio.h> 
 using namespace std; 
 int main(){ 
 FILE *fp; 
 fp=fopen("text","w"); 
 if (fp==NULL) 
 { 
 puts("Cannot open File\n"); 
 exit(); 
 fclose(fp); 
 } 
 return; 
 } 
 Тавре ки дар гузашта баён карда будем, забони С/С++ нисбат ба дигар 
 забонҳо функсияҳои зиёдеро барои навиштан ва хондани додаҳо аз файл 
 истифода мебарад. Ҳоло бошад, якчандто аз ин функсияҳоро дида мебароем. 
 Функсияи putc() 
 Функсияи putc() барои навиштани рамзе ба як stream, ки пештар 
 тавассути fopen() кушода буд, хизмат мекунад. Наҳви умумии ин функсия 
 намуди зеринро дорад. 
 int putc(int chr, FILE *fp) 
 Дар ин ҷо fp-ишорагаре ба файл аст, ки онро функсияи fopen 
 бармегардонад. Агар амали функсияи мазкур бомуваффақият ба анҷом нарасад,
 рамзи мавриди назарро бармегардонад, дар акси ҳол қимати EOF 
 бармегардонад. EOF Тавре ки қаблан гуфта шуд, як макросе аз китобхонаи 
 <stdio.h> аст, ки интиҳои файлро ифода мекунад, яъне он шакли тахфифшудаи
 End of File мебошад. 
 Функсияи getc() 
 Функсияи getc() барои хондани як рамз аз файле, ки бо ёрии функсияи 
 fopen() кушода шудааст, хизмат мекунад. Наҳви умумии истифодаи ин функсия
 намуди зеринро дорад: 
 int getc(int chr, FILE *fp) 
 Дар ин ҷо низ fp ишорагаре аз навъи FILE аст, ки бо ёрии функсияи 
 fopen() баргардонида шудааст. Функсияи мазкур як миқдор бутунро 
 бармегардонад ва вақте ки ба охири файл расид, як аломати EOF-ро 
 бармегардонад. Барои хондани як файл то охираш метавонад қитъаи барномаи 
 зерин кифоят кунад. Мисол: 
 #include <iostream> 
 #include <stdio.h> 
 using namespace std; 
 int main(){ 
 FILE *fp; 
 char chr; 
 fp=fopen("text","r+t"); 
 if (fp!=NULL) 
 { 
 chr=getc(fp); 
 while(chr!=EOF) 
 { 
 printf("%c",chr); 
 chr=getc(fp); 
 } 
 } 
 else 
 { 
 puts("Cannot open File\n"); 
 exit(); 
 fclose(fp); 
 } 
 return; 
 } 
 Дар ин мисол барои дар саҳифаи тасвир намоиш додани рамзҳои 
 хондашуда функсияи printf(«%c»,chr) истифода бурда шудааст. 
 Функсияи feof() 
 Тавре ки баён гардид, системаи файлии буфердор метавонад бо файлҳои 
 бинорӣ низ амалеро анҷом диҳад. Вақте ки файли бинорӣ кушода мешавад, 
 интиҳои он низ адади бутун ба ҳисоб меравад. Пас саволе ба миён меояд, ки чӣ
 тавр интиҳои ин навъ файлҳоро муайян карда мешавад? Барои ҳалли ин 
 мушкили функсияи feof() истифода бурда мешавад. Функсияи мазкур ҳангоми 
 расидан ба охири файл қимати ва дар акси ҳол, қимати -ро бармегардонад.
 Қитъаи барномаи зерин як файлро то ба интиҳои он расидан мехонад. 
 while (!feof(fp)) 
 ch=getc(fp); 
 Функсияи мазкурро метавон барои файлҳои матнӣ низ истифода бурд. 
 Ҳоло мисоли дар боло овардашударо тавассути ин функсия дида мебароем. 
 Мисол: 
 #include <iostream> 
 #include <stdio.h> 
 using namespace std; 
 int main(){ 
 FILE *fp; 
 char chr; 
 fp=fopen("text","r+t"); 
 if (fp!=NULL){ 
 chr=getc(fp); 
 while(!feof(fp)) { 
 printf("%c",chr); 
 chr=getc(fp); 
 } 
 } 
 else 
 { 
 puts("Cannot open File\n"); 
 exit(); 
 fclose(fp); 
 } 
 return; 
 } 
 Функсияи freopen() 
 Функсияи мазкур файлро барои навиштан ва ё хондан боз намуда, 
 ҷараёнҳои дохилкунӣ ва хориҷкуниро ба он пайваст мекунад. Наҳви умумии 
 истифодабарии функсияи мазкур намуди зеринро дорад: 
 freopen(«file_path»,»type»,»STREAM»). 
 Дар ин ҷо «file_path» – номи файл ё роҳ ба файл, «type» реҷаи кушодани
 файл (ба ҷадвали мавзӯи “Кушодан ва пӯшидани як файли бинорӣ” нигаред) ва
 «STREAM» – ҷараёни дохилкуни ва хориҷкунӣ мебошад. Ҷараёни дохилкунӣ ва 
 хориҷкунӣ яке аз стандартҳои stdin, stdout ё stderr мебошад. Мисол ду адади
 бутун дар файли матнӣ дода шудааст. Барномае нависед, ки суммаи онҳоро 
 ёфта дар ҳамон файл илова кунед. 
 Варианти якум. Бо истифода аз тобеъҳои scanf() ва printf(). 
 #include <iostream> 
 #include <stdio.h> 
 using namespace std; 
 int main(){ 
 long a,b; 
 freopen("input.txt","r",stdin); 
 freopen("output.txt","w",stdout); 
 scanf("%ld%ld",&a,&b); 
 printf("%ld",a+b); 
 return; 
 } 
 Варианти дуввум. Бо истифода аз объектҳои cin ва cout. 
 #include <iostream> 
 #include <stdio.h> 
 using namespace std; 
 int main(){ 
 long a,b; 
 freopen("input.txt","r",stdin); 
 freopen("output.txt","w",stdout); 
 cin>>a>>b; 
 cout<<a+b; 
 return; 
 } 
 Истифодаи массивҳои сеченака 
 То ҳол мо массивҳои якченака ва дученакаро истифода кардем. 
 Массивҳои сеченака низ баъзан барои ҳалли масъалаҳо истифода бурда 
 мешаванд. Тавре ки медонем, наҳви муаррификунии массиви сеченака шакли 
 зеринро дорад: 
 тип номи массив[андозаи якум][ андозаи дуюм][ андозаи сеюм]; 
 Дар ин ҷо ба сифати тип метавон, дилхоҳ типи стандарти (дар ҳолати 
 лозими ғайристандарти)-ро истифода кард. Ном ва андозаҳои ин массивҳо низ
 монанди дигар массивҳо мебошад. Ҳоло тарзи истифодаи ин навъ массивҳоро 
 дар мисоли кучаке дида мебароем. 
 Масъала. Дар як файли матнӣ k- то массиви дученакаи андозааш ба MxN 
 баробар дода шудааст. Талаб карда мешавад, барномае нависед, ки матритсаи
 L-умро ( ) дар файли дигар сабт кунад. 
 Ҳал. Ин масъаларо метавон бо роҳҳои гуногун ҳал кард. Яке аз роҳҳои 
 содда, ис т иф од аи массиви сеченака мебошад. Дар ин навъ массивҳо андозаи
 якум рақами матритса ва ду ченаки боқимонда бошанд, элементҳои матритсаро
 ифода мекунанд. Ба барномаи зерин диққат диҳед: 
 #include <iostream> 
 #include <fstream> 
 using namespace std; 
 int main(){ 
 ofstream("input.txt","r",stdin); 
 freopen("output.txt","w",stdout); 
 const int n=, m=, k=; 
 int a[k][n][m]; 
 int l,i,j,f; 
 l=; 
 for (f=; f<=l; f++) 
 for (i=; i<n; i++) 
 for (j=; j<m; j++) 
 cin>>a[f][i][j]; 
 for (i=; i<n; i++) 
 { 
 for (j=; j<m; j++) 
 cout<<a[l][i][j]<<" "; 
 cout<<endl; 
 } 
 return; 
 } 
 Функсияи fclose() 
 Функсияи fclose() барои пӯшонидан ё маҳкам намудани як файл ё stream,
 ки тавассути функсияи fopen() кушода шудааст, истифода бурда мешавад. Тавре
 ки қаблан ёдрас карда будем, пеш аз анҷом ёфтани барнома бояд файл баста 
 шавад. Ҳангоми баста нашудани файл сабаби аз даст додани додаҳо ва баъзан
 ҳатто сабаби нест шудани файл мегардад. Наҳви умумии ин функсия намуди 
 зеринро дорад: 
 int fclose(FILE *fp) 
 Дар ин ҷо fp низ ҳамон ишорагаре бо файл аст. Дар сурати 
 бомуваффақият баста шудани файл функсия қимати ва дар акси ҳол қимати 
 ғайринулӣ бармегардонад. Ҳангоми мавҷуд набудани файл ё пур будани диск 
 хатогӣ ба вуқуъ меояд. 
 Функсияи ferror() 
 Функсияи ferror() барои ошкор намудани хатогиҳо дар файли сохташуда 
 истифода бурда мешавад. Наҳви умумии он намуди зеринро дорад: 
 int ferror(FILE *fp) 
 Дар ин ҷо fp як ишорагаре ба файл буда, ба қимати true доро аст, агар дар
 амали охирони ба файл гузаронидашуда хатогӣ вуҷуд дошта бошад ва дар акси
 ҳол, ба қимати false доро мегардад. Барои хатогиҳои дар файл содиршударо 
 дарёфт кардан бояд пеш аз ҳар амале, ки бо файл карда мешавад, ин функсия
 даъват карда шавад, вагарна дар охир наметавонад ҳамаи хатогиҳоро муайян 
 кунад. 
 Функсияҳои fscanf() ва fprintf() 
 Функсияҳои fscanf() ва fprintf() низ ду функсияи дигари системаи 
 буфердори I/O буда, амали ба функсияи scanf() ва printf() монандро иҷро 
 мекунанд. Тарзи умумии истифодаи ин функсияҳо ба сурати зерин аст. 
 fprintf(fp,”Control string”, argument list) 
 fscanf(fp,”Control string”, argument list) 
 Дар ин ҷо fp ишорагаре аз навъи файл аст, ки тавассути функсияи fopen()
 баргардонида шудааст. Амали иҷромекардаи функсияҳо аз он иборат аст, ки 
 қиматҳои худро ба файле, ки тавассути fp таъриф шудааст, равона мекунанд.
 Мисол. Барномае нависед, ки додаҳои як ширкати мобилӣ, ки дар файл 
 захира шудаанд, пардозиш намояд. Яъне барнома имконият диҳад, ки дар файл
 рақами муштарии нав илова карда шуда, амали ҷустуҷӯ низ иҷро гардад. 
 #include <iostream> 
 #include <fstream> 
 #include <stdio.h> 
 #include <string.h> 
 #include <ctype.h> 
 using namespace std; 
 void add(void); 
 void lookup(void); 
 char menu(void); 
 int main(){ 
 char choice; 
 do 
 { 
 choice=menu(); 
 switch(choice) 
 { 
 case ’a’: add(); break; 
 case ’l’: lookup(); break; 
 } 
 } 
 while(choice!=’q’); 
 } 
 char menu(void) 
 { 
 char chr; 
 do 
 { 
 printf("a (Add),l (Lokup, q (Quit) \n"); 
 chr=tolower(getch()); 
 printf("\n"); 
 } while (chr!=’q’ && chr!=’a’ && chr!=’l’); 
 return chr; 
 } 
 void add(void){ 
 FILE *fp; 
 char name[]; 
 int code,num; 
 if((fp=fopen("phone","a"))==NULL) 
 { 
 printf("Cannot open directory File"); 
 exit(); 
 } 
 else 
 { 
 printf("Enter name and number\n"); 
 fscanf(stdin,"%s %d",name, &num); 
 fscanf(stdin,"%*с"); 
 fprintf(fp," %s %d \n",name, num); 
 fclose(fp); 
 } 
 } 
 void lookup(void){ 
 FILE *cpf; 
 char name[], name[]; 
 int code,num,exchg; 
 if((cpf=fopen("phone","r"))==NULL) 
 { 
 printf("Cannot open directory File"); 
 exit(); 
 } 
 printf("name?\n"); 
 gets(name); 
 while(!feof(cpf)){ 
 fscanf(cpf,"%s %d",name, &num); 
 if (!strcmp(name, name)) 
 { 
 printf("%s %d",name, num); 
 break; 
 } 
 } 
 fclose(cpf); 
 } 
 Функсияҳои remove() ва rename() 
 Функсияи remove() барои аз диск нест кардани як файл истифода бурда 
 мешавад. Наҳви истифодабарии он намуди зеринро дорад: 
 int remove( const char *Filename) 
 Дар ин ҷо const char *Filename ҳамон тағйирёбандаи ишорагар аз навъи
 сохтори FILE мебошад. 
 Функсияи rename() бошад, барои номи файли дар диск мавҷуд бударо 
 иваз кардан истифода бурда мешавад. Наҳви истифодабарии он намуди зеринро
 дорад: 
 int remove( const char *oldFilename, const char *newFilename) 
 Дар ин ҷо oldFilename, номи мавҷудбуда ва newFilename бошад, номи 
 нави файл мебошад. Ҳангоми бомуваффақият иваз намудани номи файл, 
 функсияи мазкур дорои қимати мегардад, дар акси ҳол бошад, қимати 
 функсия ғайринулӣ аст. 
 Функсияи fwrite()-ро аслан барои навиштани сохторҳо ва ё мас-сивҳо ба
 файл истифода мебаранд ва наҳви он ба сурати зерин аст: 
 fwrite(array_name,sizeof(array_type),,fp). 
 Функсияи fread()-ро бошад, барои хондани додаҳои як сохтор ё массив аз
 файл ба кор мебаранд. Наҳви умумии истифодаи он намуди зеринро дорад: 
 fread(array_name,sizeof(array_type),,fp). 
 Мисол. Дар як файли бинорӣ элементҳои массив захира шудааанд. 
 Барномае нависед, ки ҳамаи элементҳоо массивро аз файл хонда, ба саҳифаи 
 тасвир барорад. 
 #include <iostream> 
 #include <fstream> 
 using namespace std; 
 int main(){ 
 FILE *f; 
 int i, n,*a; 
 f=fopen("test.dat","rb"); 
 fread(&n, sizeof(int),,f); 
 cout<<n<<endl; 
 a=new int [n]; 
 fread(a, sizeof(int),n,f); 
 for(i=;i<n;i++) 
 cout<<a[i]<<"\t"; 
 fclose(f); 
 return; 
 } 
 Тавре ки қайд карда будем, функсияҳои мазкур ҳам барои хондан ва 
 навиштани массивҳо ва ҳам сохторҳо истифода бурда мешаванд. Ҳоло бошад, 
 ба ин вобаста мисоли дигареро дида мебароем. 
 Мисол. Барномае нависед, ки элементҳои сохтореро аз файл хонда, ба 
 саҳифаи тасвир барорад. 
 #include <iostream> 
 #include <fstream> 
 using namespace std; 
 struct{ 
 int no; 
 char name[]; 
 float balance; 
 } rec; 
 int main(){ 
 FILE *fp; 
 if((fp=fopen("piple ","rb"))==NULL) 
 { 
 cout<<"Cannot open File\n"; 
 exit(); 
 } 
 while(fread(&rec, sizeof(rec),,fp)==) 
 cout<<rec.no<<" " <<rec.name<<" " <<rec.balance; 
 fclose(fp); 
 return; 
 } 
 Дар ин ҷо оператори fread(&rec, sizeof(rec),,fp) додаҳое, ки аз файл хонда
 мешаванд, дар сохтори rec ҷой медиҳад, яъне функсияи fread() миқдори 
 додаҳоеро, ки аз файл хондааст, бармегардонад, миқдори сохтори додаҳо дар
 аргументи сеюми функсияи мазкур мушаххас карда шудааст. Вақте ки 
 хондан ба охири барнома расид, ин миқдор баробари нол мешавад. 
 Дар системаи I/O додаҳои сохтор ба намуди бинорӣ захира карда 
 мешаванд. Ва бояд ба таври бинорӣ хонда шаванд. Агар фарз кардему додаҳо 
 дар файл ба намуди матнӣ захира карда шаванд ва дар байни додаҳо адади 
 (дилхоҳ рақам дар ин ҷо барои мисол адади гирифта шуд) бутуни дар 
 қолаби даҳӣ мавҷуд бошад. Аз сабаби он ки файлҳои бинорӣ додаҳоро ба 
 намуди байтҳо захира мекунанд. Бинобар ин, агар адади -ро ба байтҳо тақсим
 кунем, намуди зеринро мегирад. =( ) вақте ки иҷроиши 
 барнома ба ин ҷо мерасад, рақамҳои сифр ҳамчун EOF фаҳмида шуда, барнома 
 кори худро ба анҷом мерасонад. Ин амал бошад, хатогии бузург ба ҳисоб 
 меравад. 
 Файлҳои бинорӣ Тавре ки қаблан баён кардем, ин пайдарпайии сохтори 
 додаҳо мебошанд ва додаҳоро аз онҳо пайдарпай хонда ва навишта мешаванд. 
 Масалан, дар файли бинорие, ки пайдарпайии ададҳои ҳақиқӣ дар он захира 
 шудаанд, барои хондани адад аз ин пайдарпайи ва баъд як адад ба мо лозим
 меояд, ки ду маротиба файлро барои хондан кушоем. Ин амал дилгир-кунанда 
 мебошад, зеро барои ҳар амал зарурати аз сари нав кушодан ва бастани файл
 пеш меояд. Барои пурратар шинос шудан ба ин амал барномаи зеринро дида 
 мебароем. Мисол: 
 #include <iostream> 
 #include <fstream> 
 using namespace std; 
 int main(){ 
 FILE *f; 
 int i, n; 
 int a[]; 
 f=fopen("test.dat","rb"); 
 for (i=;i<;i++) 
 fread(a, sizeof(int),,f); 
 fclose(f); 
 for(i=;i<;i++) 
 cout<<a[i]<<"\t"; 
 f=fopen("test.dat","rb"); 
 fread(&n, sizeof(int),,f); 
 cout<<n<<"\t"; 
 fclose(f); 
 return; 
 } 
 Чи хеле ки дида мешавад, барои хондани адад аз файл як маротиба 
 файл кушода шуда, пас аз хондани ададҳо баста шудааст. Барои аз сари нав 
 хондани элементи якум, бори дигар иҷрои амали кушодан ва пӯшидани файл 
 лозим шудаст. Ин амал ҳарчанд, ки иҷро мешавад, вале агар онро тавассути 
 функсияи fseek() анҷом диҳем, хеле сода иҷро мегардад. 
 Функсияи fseek() 
 Функсияи мазкур мавқеи файл ё ишорагари мавқеи файлро метавонад 
 муайян созад. Бо ёрии ин функсия ишорагаре ба мавқеи лозимиии файл равон 
 карда мешавад. Наҳви умумии истифодаи функсияи мазкур намуди зеринро 
 дорад: 
 int fseek(FILE *fp, long int num_инt, int origin); 
 Дар ин ҷо fp ишорагаре аз навъи сохтори FILE аст, ки бо фурӯхонии 
 функсияи fopen() баргардонида шудаааст, num_инt-миқдои ҷустуҷӯшаванда аз 
 мабдаъ ё origin мебошад, ки origin дар навбати худ яке аз макросҳои ҷадвали
 зерин мебошад. 
 Н№оми макрос Мабдаъ ё origin 
 SEEK_SET Шуруъ аз авввали файл 
 SEEK_CUP Шуруъ аз мавқеи ҷорӣ 
 SEEK_END Шуруъ аз интиҳои файл 
 Ин макросҳо дорои миқдори бутун низ мебошанд. Масалан, дар мавриди 
 SEEK_SET дар мавриди SEEK_CUP ва дар мавриди SEEK_END. 
 Агар қимати num_инt мусбат бошад, ишорагари файл додаҳоро аз мавқеи 
 нишондодашуда ба пеш мехонад ва дар сурати манфӣ будан додаҳоро аз мавқеи
 нишондодашуда ба қафо мехонад. 
 Истифодаи функсияи fseek() барои файлҳои матнӣ тавсия дода 
 намешавад, зеро он махсус барои файлҳои бинорӣ пешбинӣшудаааст ва дар 
 сурати файлҳо матнӣ барнома ба хатогӣ рӯбарӯ мешавад. 
 Мисол. Дар як файли бинорӣ элементҳои массиви навъи бутун дода 
 шудаааст. Барномае нависед, ки ҷойи элементи максималӣ ва минималии 
 массивиро дар дохили файл иваз кунад. 
 #include <iostream> 
 #include <fstream> 
 using namespace std; 
 int main(){ 
 FILE *f; 
 int i, n, nmax, nmin, max, min; 
 double *a; 
 f=fopen("simple.dat","rb+"); 
 fread(&n, sizeof(int),,f); 
 cout<<"n="<<n<<endl; 
 a=new double[n]; 
 fread(a, sizeof(double),n,f); 
 for (i=;i<n;i++) 
 cout<<a[i]<<"\t"; 
 nmax=nmin=; 
 max=min=a[]; 
 for(i=;i<n;i++) 
 { 
 if (a[i]>max) 
 { 
 max=a[i]; 
 nmax=i; 
 } 
 if (a[i]<min) 
 { 
 min=a[i]; 
 nmin=i; 
 } 
 } 
 fseek(f, sizeof(int)+nmax*sizeof(double),SEEK_SET); 
 fwrite(&min, sizeof(double),,f); 
 fseek(f, sizeof(int)+nmin*sizeof(double),SEEK_SET); 
 fwrite(&max, sizeof(double),,f); 
 fclose(f); 
 delete [] a; 
 return; 
 } 
 Саволҳо барои мустаҳкамкунӣ 
 мешавад? 
 файл истифода бурда мешавад? 
 мешавад? 
 аст? 
 саҳифаи тасвир навишт? 
 macro мебошад? 
 мекунад? 
 дар файл истифода бурда мешаванд? 
 навишт? 
 медиҳад? 
 мувофиқтар аст? 
 Намунаи ҳалли масъалаҳо 
 ) Ҳама элементҳои матритсаи квадратии андозааш ба N x N баробар аз 
 сифрҳо () ва воҳидҳо () таркиб ёфтаанд. Миқдори «ҷазираҳо»-е, ки аз 
 воҳидҳо иборатанд ёфта шавад. Таҳти мафҳуми «ҷазира» гурӯҳи воҳидҳо (ё 
 як воҳид) фаҳмида мешавад, ки аз ҳамаи тарафҳо бо сифрҳо иҳота карда 
 шудааст. (ё бо тарафҳои матриса). Гурӯҳи воҳидҳо як ҷазираро ташкил 
 медиҳанд, агар аз яктои онҳо ба катакчаи ҳамсоя бе убури катакчае, ки дар он
 сифр аст, гузаштан мумкин бошад. Катакчаҳо ҳамсоя номида мешаванд, агар
 дар самти амуди ё уфуқии якдигар ҷойгир бошанд. 
 Додаҳои вурудӣ 
 Дар сатри нахустини файли input.txt адади натуралии N (андозаи 
 матриса), ки аз зиёд нест навишта мешавад. Дар N сатри боқимонда 
 элементҳои матритса тавассути фосила (пробел) навишта мешаванд. 
 Додаҳои хуруҷӣ 
 Дар файли output.txt як адад- миқдори ҷазираҳо хориҷ карда мешавад. 
 Мисол 
 input.txt output.txt 
 Матни барнома. 
 #include <bits/stdc++.h> 
 using namespace std; 
 char a[][]; 
 bool used[][]; 
 void dfs(int x, int y){ 
 used[x][y] = true; 
 if(a[x+][y] == '' &&!used[x+][y]) dfs(x+, y); 
 if(a[x-][y] == '' &&!used[x-][y]) dfs(x-, y); 
 if(a[x][y+] == '' &&!used[x][y+]) dfs(x, y+); 
 if(a[x][y-] == '' &&!used[x][y-]) dfs(x, y-); 
 } 
 int main(){ 
 int n; 
 freopen("input.txt", "r", stdin); 
 freopen("output.txt", "w", stdout); 
 cin >> n; 
 for(int i=; i<=n; ++i){ 
 for(int j=; j<=n; ++j){ 
 cin >> a[i][j]; 
 } 
 } 
 int ans =; 
 for(int i=; i<=n; ++i){ 
 for(int j=; j<=n; ++j){ 
 if(a[i][j] == '' &&!used[i][j]){ 
 dfs(i, j), ++ ans; 
 } 
 } 
 } 
 cout << ans << endl; 
 return; 
 } 
 ) Рассоми машҳур хост то шоҳкории нав созад. Пас аз чанд рӯзи кори хост
 то заҳмати (санъати) худро таҳқиқ кунад Рассом ба ёд овард, ки ба сурати
 зерин расм тасвир карда шудааст: ибтидо матоъи сафед (доска), ки шакли 
 росткунҷавии паҳноияш ба w ва баландиаш ба h баробар аст мегирад. Сипас,
 дар ин матоъи сафед n росткунҷа, ки тарафҳояш ба тарафи матоъи сафед 
 паралелл буда, қуллаҳояш дорои координатаҳои бутун мебошанд, тасвир 
 мекунад. Ба рассом кумак кунед, то масоҳати ранг накардаи матоъи сафедро
 муайян кунад. 
 Додаҳои вурудӣ 
 Дар сатри нахустини файли вурудии INPUT.TXT ду адади натуралии w 
 ва h ( ≤ w, h ≤ ) ва дар сатри дуюм адади бутуни n ( ≤ n ≤ ) –
 миқлори росткунҷаҳо навишта мешавад. Дар n-сатри боқимонда бошад, 
 маълумот оиди ҳамаи росткунҷаҳо навишта мешавад. Ҳар як сатр 
 маълумоти як росткунҷаро ба шакли чор адад x, y, x, y ифода мекунад.
 Дар инҷо (x, y) ва (x, y) – мувофиқан координатаҳои кунҷҳои рости 
 болоӣ ва чапи поёнии росткунҷаро ифода мекунанд. 
 Додаҳои хуруҷӣ 
 Дар файли хуруҷии output.txt як адади бутун – масоҳати қисми 
 рангнокардаи муқаллам хориҷ карда мешавад. 
 Мисол 
 № input.txt output.txt 
 Матни барнома. 
 #include <bits/stdc++.h> 
 using namespace std; 
 bool used[][]; 
 int main(){ 
 int n, m, k; 
 freopen("input.txt", "r", stdin); 
 freopen("output.txt", "w", stdout); 
 cin >> n >> m >> k; 
 swap(n, m); 
 for(int a=; a<=k; ++a){ 
 int x, y, x, y; 
 cin >> x >> y >> x >> y; 
 for(int i=x; i<x; ++i){ 
 for(int j=y; j<y; ++j){ 
 used[i][j] = true; 
 } 
 } 
 } 
 int ans =; 
 for(int i=; i<n; ++i){ 
 for(int j=; j<m; ++j){ 
 ans += ( - used[i][j]); 
 } 
 } 
 cout << ans << endl; 
 return; 
 } 
 ) Миқдори ҳамаи ададҳои N-рақама дар системаи ҳисоби K, ки дар 
 навишташон ду сифр() пайдарпай вонамехурад, ҳисоб карда шавад. 
 Додаҳои вурудӣ 
 Дар файли input.txt ду адади натуралии N ва K дар системаи ҳисоби даҳӣ
 навишта мешаванд. ( ≤ K ≤; ≤ N; ≤ N+K ≤ ). 
 Додаҳои хуруҷӣ 
 Дар файли output.txt як адади бутун дар системаи ҳисоби даҳӣ-ҷавоби 
 мисол хориҷ карда шавад. 
 Мисолҳо 
 № input.txt output.txt 
 Матни барнома. 
 #include <bits/stdc++.h> 
 using namespace std; 
 char a[], b[]; 
 int ans =; 
 void rec(int n, int m, int k){ 
 if(n == ){ 
 ++ ans; 
 return; 
 } 
 int i =; 
 if(n == m || b[n+] == '') 
 i =; 
 for(; i<k; ++i){ 
 b[n] = a[i]; 
 rec(n-, m, k); 
 } 
 } 
 int main(){ 
 int n, k; 
 freopen("input.txt", "r", stdin); 
 freopen("output.txt", "w", stdout); 
 cin >> n >> k; 
 a[n+] = ''; 
 for(int i=; i<; ++i) 
 a[i] = i + ''; 
 for(int i=; i<; ++i) 
 a[i] = (i - ) + 'A'; 
 rec(n, n, k); 
 cout << ans << endl; 
 return; 
 } 
 ) Шоҳи Флатландия хост то якчанд дарахти назди қасрашро бурад. Дарахтон
 дар назди қасри шоҳ дар як қатор шинонида шудаанд, ки миқдори умумии 
 онҳо ба n баробар аст. Масофаи байни дарахтон якхела мебошад. 
 Баъди буридан дар назди қаср бояд m дарахт боқи монда, ки масофаи 
 байни онҳо низ якхела бошад. Ба шоҳ кумак кунед, яъне миқдори 
 имконпазири усулҳои буридани дарахтонро ба ӯ фаҳмонед. 
 Барномае нависед, ки бо дода шудани ададҳои n ва m миқдори усулҳои 
 буридани якчанд дарахтро аз байни n дарахт муайян кунад, ки m то боқӣ 
 монад ва масофаи байни онҳо якхела бошад. 
 Додаҳои вурудӣ 
 Дар файли input.txt ду адади бутуни n ва m ( ≤ m, n ≤ ) навишта
 меҳӯшавад. 
 Додаҳои хуруҷӣ 
 Дар як сатри файли output.txt як адади бутун—миқдори усулҳо. 
 Мисол 
 № input.txt output.txt 
 Қайд. Агар шартан ададҳои дар назди қаср руидаро бо ҳарфҳо ба шакли 
 «TTTTT» ишорат кунем, онгоҳ пас аз буридан дарарахтони боқимонда 
 метавонанад чунин шакл дошта бошанд: 
 «TTT..», «.TTT.», «..TTT», «T.T.T». 
 #include <bits/stdc++.h> 
 using namespace std; 
 int main(){ 
 int n, m; 
 freopen("input.txt", "r", stdin); 
 freopen("output.txt", "w", stdout); 
 cin >> n >> m; 
 int ans =; 
 for(int i=; i<n; ++i){ 
 int k = (m - ) * i + m; 
 if(k <= n) ans += (n - k + ); 
 } 
 cout << ans << endl; 
 return; 
 } 
 ) Масъала. Барномае нависед, ки бо додаҳои як файл, ки аз маъ-лумотҳои 
 коргарон иборатанд, чунин амалиётро иҷро кунад: 
 Барои ҳалли ин масъала сохторе, ки майдонҳои он аз код, ном, насаб, 
 маъош ва синну сол иборат мебошанд, ба намуди зерин муаррифӣ карда 
 мешавад: 
 struct StructKorgar { 
 int kod; 
 char name[]; 
 char LastName[]; 
 long int maosh; 
 int sol; 
 } 
 Баъд аз ин массиве бо номи korgaron аз навъи сохтор муаррифӣ карда 
 мешавад. 
 Ба ғайр аз ин, ҳафт функсия, ки пешнамунаи онҳо намуди зеринро дорад,
 муарррифӣ карда мешаванд: 
 void namoish_dodan (int n); 
 void khondan_az_file (int n); 
 void sabt_kardan (int n); 
 int ilova_kardan (int n); 
 void tahrir_kardan (int n); 
 int nest_kardan (int n); 
 void hisobot (n); 
 Биёед, аввал ҳар яке аз ин функсияҳоро алоҳида-алоҳида дида мебароем.
 Функсияи namoish_dodan (int n), функсияи мазкур барои дар саҳифаи 
 тасвир намоиш додани додаҳои аз файл хондашуда хизмат мекунад. 
 Функсияи khondan_az_file (int n) барои аз файл хондани додаҳои коргарон
 ва тавассути функсияи namoish_dodan (int n) дар саҳифаи тасвир навиштани 
 додаҳо истифода бурда мешавад. 
 Функсияи sabt_kardan (int n) барои сабт намудани додаҳо дар файл хизмат
 мекунад. 
 Функсияи ilova_kardan(int n) барои илова намудани коргари нав истифода
 бурда мешавад. 
 Функсияи tahrir_kardan (int n) барои таҳрир намудани додаҳои n-ум коргар
 истифода бурда мешавад. 
 Функсияи nest_kardan (int n) барои нест кардани додаҳои коргар n-ум 
 истифода бурда мешавад. 
 Функсияи hisobot (n) бошад, барои ҳамаи додаҳои коргаронро дар 
 саҳифаи тасвир намоиш додан истифода бурда мешавад. 
 Акнун, ки ба функсияҳои лозимӣ шинос шудем, биёед матни барномаро 
 ба таври пурра меорем. 
 Матни барнома. 
 #include <iostream> 
 #include <fstream> 
 #include <iomanip> 
 using namespace std; 
 int n; 
 struct StructKorgar{ 
 int kod; 
 char name[]; 
 char LastName[]; 
 long int maosh; 
 int sol; 
 } korgaron[]; 
 void namoish_dodan (int n){ 
 int i; 
 if (n!= ) 
 { 
 for (i =; i < n; i++) 
 { 
 cout << "\t-------------------------"; 
 cout << "\n\tKod: " << korgaron[i].kod; 
 cout << "\n\tname: " << korgaron[i].name; 
 cout << "\n\tLastName: " << korgaron[i].LastName; 
 cout << "\n\tMaosh: " << korgaron[i].maosh; 
 cout << "\n\tSol: " << korgaron[i].sol << "\n"; 
 } 
 cout << "\t-------------------------"; 
 } 
 } 
 void khondan_az_file (int n){ 
 int i; 
 ifstream fin ("korgaron.txt"); 
 fin >> n; 
 for (i =; i < n; i++) 
 { 
 fin >> korgaron[i].kod; 
 fin >> korgaron[i].name; 
 fin >> korgaron[i].LastName; 
 fin >> korgaron[i].maosh; 
 fin >> korgaron[i].sol; 
 } 
 namoish_dodan (n); 
 cout << "\n\n\tbarovardan..."; 
 } 
 void sabt_kardan (int n){ 
 int i; 
 ofstream fout ("korgaron.txt"); 
 fout << n << "\n"; 
 for (i =; i < n; i++){ 
 fout << korgaron[i].kod << "\t"; 
 fout << korgaron[i].name << "\t"; 
 fout << korgaron[i].LastName << "\t"; 
 fout << korgaron[i].maosh << "\t"; 
 fout << korgaron[i].sol << "\n"; 
 } 
 cout << "\tSabt..."; 
 } 
 int ilova_kardan (int n){ 
 cout << "\tKod: " << n +; korgaron[n].kod = n +; 
 cout << "\n\tName: "; cin >> korgaron[n].name; 
 cout << "\tLastName: "; cin >> korgaron[n].LastName; 
 cout << "\tMaosh: "; cin >> korgaron[n].maosh; 
 cout << "\tSod: "; cin >> korgaron[n].sol; 
 n++; 
 cout << "\n\tIlova..."; 
 return n; 
 } 
 void tahrir_kardan (int n){ 
 int tmp; 
 namoish_dodan (n); 
 cout << "\n\n"; 
 cout << "\tKodi korgarro baroi tahrir kardan dohil kuned: "; 
 cin >> tmp; 
 if (tmp!= ) { 
 tmp--; 
 cout << "\n\tKod: " << tmp +; korgaron[tmp].kod = tmp +; 
 cout << "\n\tName: "; cin >> korgaron[tmp].name; 
 cout << "\tLastName: "; cin >> korgaron[tmp].LastName; 
 cout << "\tMaosh: "; cin >> korgaron[tmp].maosh; 
 cout << "\tSol: "; cin >> korgaron[tmp].sol; 
 cout << "\n\tTahrir\n\n"; 
 namoish_dodan (n); 
 } 
 } 
 int nest_kardan (int n){ 
 int i, tmp; 
 namoish_dodan (n); 
 cout << "\n\n"; 
 cout << "\tKodi korgarro baroi nest kardan dohil kuned: "; 
 cin >> tmp; 
 if (tmp!= ) { 
 tmp--; 
 for (i = tmp; i < n; i++) 
 { 
 korgaron[i] = korgaron[i+]; 
 korgaron[i].kod = i +; 
 } 
 n--; 
 cout << "\n\tNest kardan\n\n"; 
 namoish_dodan (n); 
 return n; 
 } 
 } 
 void hisobot (int n) { 
 int i, phoiz; 
 float daromad; 
 cout << " --------------------------------------------\n"; 
 cout << " | LastName | Sol | Maosh | % | Daromad |\n"; 
 cout << " -------------------------------------------\n\n"; 
 for (i =; i < n; i++) { 
 phoiz =; 
 if (korgaron[i].maosh >= ){ 
 phoiz++; 
 } 
 if (korgaron[i].sol <= ){ 
 phoiz++; 
 } 
 daromad = korgaron[i].maosh / phoiz; 
 cout << " ---------------------------------------\n"; 
 cout << " |" << setw() << korgaron[i].LastName 
 << " |" << setw() << korgaron[i].sol 
 << " |" << setw() << korgaron[i].maosh << setw() << "somoni" 
 << " |" << setw() << phoiz << "%" 
 << " |" << setw() << daromad << setw() << "somoni" 
 << " |\n"; 
 } 
 cout << "--------------------------------------------------\n"; 
 } 
 int main(){ 
 int n, tmp; 
 ifstream fin ("korgaron.txt"); 
 fin >> n; 
 menu: 
 cout << ". Hondan az fayl" << endl; 
 cout << ". Dar fayl sabt kardan" << endl; 
 cout << ". Ilova namudani korgar" << endl; 
 cout << ". Tagiiir dodan" << endl; 
 cout << ". Nest kardani korgar" << endl; 
 cout << ". Namoish dodani korgar" << endl; 
 cout << ". Barovardani hisobot" << endl; 
 cout << ". Baromad" << endl; 
 cout << "\n\n" << "Amaliyotro dohil kuned: "; 
 cin >> tmp; 
 cout << "\n"; 
 switch (tmp) 
 { 
 case: khondan_az_file (n); cout << "\n\n"; 
 goto menu; 
 case: sabt_kardan (n); cout << "\n\n"; 
 goto menu; 
 case: if (korgaron[].kod == || n == ) { 
 n = ilova_kardan (); cout << "\n\n"; 
 goto menu; 
 } 
 else 
 { 
 n = ilova_kardan (n); cout << "\n\n"; 
 goto menu; 
 }; 
 case: if (korgaron[].kod == || n == ) { 
 cout << "\tBD holi...\n\n"; 
 goto menu; 
 } 
 else { 
 tahrir_kardan (n); cout << "\n\n"; 
 goto menu; 
 }; 
 case: if (korgaron[].kod == || n == ) 
 { 
 cout << "\tBD holi...\n\n"; 
 goto menu; 
 } 
 else 
 { 
 n = nest_kardan (n); 
 cout << "\n\n"; 
 goto menu; 
 }; 
 case: if (korgaron[].kod == || n == ) 
 { 
 cout << "\tBD holi...\n\n"; 
 goto menu; 
 } 
 else { 
 namoish_dodan (n); cout << "\n\n"; 
 goto menu; 
 }; 
 case: if (korgaron[].kod == || n == ){ 
 cout << "\tBD holi...\n\n"; 
 goto menu; 
 } 
 else 
 { 
 hisobot (n); cout << "\n\n"; 
 goto menu; 
 }; 
 case: break; 
 default: break; 
 } 
 return; 
 } 
 Масъалаҳо барои кори мустақилона 
 геометрии онҳоро ёбед. 
 бо ин давра маҳдудро ҳисоб кунед. 
 иваз кунед. 
 геометрии рақамҳои ададро ҳисоб кунед. 
 ки бо истифода аз формулаи Герон масоҳати онро ҳисоб кунед. 
 Қайд.Формулаи Герон наму ди з е ринро дорад, 
 ки дар ин ҷо r-нимпериметр мебошад. Ва аз геометрия маълум аст, ки 
 √ 
 P=a+b+c ва 
 максималиро ёфта, дар файли нав нависед. 
 Барномае нависед, ки дар охири ҳар сатр миқдори ҳарфҳои ҳар сатрро 
 нависад. 
 ададҳои манфиро ҳисоб намуда дар файли нав нависед. 
 файли якум мавҷуданду дар файли дуввум нестанд, нависед. 
 Барномае нависед, ки …-и онро ҳисоб кунад. 
  миқдори ададҳои ҷуфт ва тоқ 
  миқдори ададҳои мусбат ва манфӣ 
  миқдори ададҳои сода ва мураккаб 
  миқдор ва суммаи ададҳои мукаммал 
  қимати миёнаи арифметикӣ ва геометрии ададҳо 
  адади максималӣ ва минималӣ 
 Барномае нависед, ки бо дохил кардани калима тарҷумаи онро барорад. 
 калонтарин тақсимкунанда (КТУ) – и онҳоро созед. 
 шудааст. Элементи максималиро дар ҳар сатр ёбед. 
 нависед. 
 файли матнӣ ҷойгиранд, дода шудааст. Миқдори ададҳоеро, ки дар байни 
 аввалин ва охирин адади калонтарин ҷойгиранд, ёбед. Агар дар гурӯҳи ададҳо
 танҳо як адади калонтарин мавҷуд бошад, он гоҳ хориҷ карда шавад. 
 Натиҷаи амалиётҳо дар файли мавҷудбуда сабт карда шавад. 
 Муайян карда шавад, ки оё дар массив ададҳои ҷуфт ва тоқ пайдарпай ҷойгир
 шудаанд ё не. Агар ададҳои ҷуфт ва тоқ пайдарпай ҷойгир бошанд, он гоҳ 
 ва дар ҳолати баръакс рақами тартибии аввалин адади пайдарпайиро 
 вайронкунанда хориҷ карда шавад. Натиҷаи амалиётҳо дар файли мавҷудбуда
 сабт карда шавад. 
 сатрҳои файли додашуда ба таври лексикографӣ, яъне сатрҳо бо тартиби 
 зиёдшавии коди рамзҳояшон (аз рамзи аввалин сар карда) ҷойгир шудаанд. 
 матнӣ дода шудааст. Дар байни онҳо аломатҳои "+" ва "-" –ро тавре гузоред,
 ки қимати ифодаи со х таш уд а б а адади бутуни додашудаи S баробар бошад.
 Агар чунин амал ғайриимкон бошад, он гоҳ сатри "No solution" ва дар ҳолати
 баръакс ифодаи тартибдодашуда дар файли нав хориҷ карда шавад. Агар 
 чунин ифодаҳои тартибдодашуда, ки қиматашон ба S баробар аст, якчандто 
 бошанд, он гоҳ яке аз онҳо дар файл хориҷ карда шавад. 
 файл нависед. 
 боқимондаро аз рӯи формулаи ҳисоб карда дар файл 
 сабт кунед. Сипас, аъзои -у ми о нр о х о риҷ кунед. 
 калимаҳо, микдори сатрҳ о, миқдори калимаҳои такроршавандаро дар намуди
 ҷадвали содиротӣ дар экран хориҷ кунед. 
 калимаҳое, ки ҷумлаи якумро ташкил додаанд дар ҷумлаи дуюм дида 
 мешаванд ё не. 
 Боби. Барноманависии динамикӣ 
 Муқаддима 
 Барноманависии динамикӣ ин усули барноманависие мебошад, ки дар он 
 барномаҳои калон ба қисматҳои хурд тақсим карда шуда, ба намуди соддатар 
 ҳал карда мешаванд. Ин навъ барноманависӣ дар назарияи идоракунӣ, назарияи
 системаҳои ҳисобкунӣ ва ғайра истифода бурда мешавад. 
 Сабаби динамикӣ ном гирифтани ин навъ барноманависӣ дар он аст, ки 
 қариб ҳамаи додаҳо (тағйирёбандаҳо) ба намуди динамикӣ муаррифӣ гардида 
 истифода бурда мешаванд. 
 Дар боби ишорагарҳо баъзе аз истифодаи додаҳои динамикиро дида 
 баромада будем. Дар ин боб, қариб ҳамаи он мафҳумро истифода мекунем. 
 Воситаҳои муҳимтарини ин навъ барноманависӣ дар поён оварда 
 шудаанд: 
 ) Листҳои пайвандӣ; 
 ) Пушаҳо (стек); 
 ) Сафҳо (очеред); 
 ) Графҳо: 
 ) Дарахтҳои дуӣ. 
 Ҳар яке аз ин воситаҳоро мавриди баҳс қарор медиҳем. 
 Листҳои пайвандӣ 
 Листҳои пайвандӣ як навъе аз сохтори додаҳои динамикӣ мебошанд, ки 
 онҳо доимӣ набуда, дар рафти иҷроиши барнома метавонанд андозаи худро дар
 хотираи компютер тағйир диҳанд. Ҳар як элементи листи пайвандӣ гиреҳ (node)
 номида шуда, дорои ду элемент мебошад, ки элементи аввала ягон додаро 
 ифода намуда, элементи дуввум ба гиреҳи баъди ишора мекунад. Ба сифати 
 элементи аввала метавон дилхоҳ додаро (тағйирёбандаҳои оддӣ, массивҳо, 
 сохторҳо, объектҳо ва ғайра) истифода кард. 
 Ҳар як элементи листи пайвандӣ суроғаи элементи листи дигарро дар худ
 нигоҳ медорад. Ба ин минвол метавон ба ҳамаи гиреҳҳои листи пайвандӣ 
 дастрас шуд. 
 Баъзан листи пайвандиро инчунин листҳои динамикӣ низ мегӯянд. 
 Сабаби пайвандӣ ном бурдани онҳо дар он аст, ки ҳар як гиреҳ бо гиреҳҳои 
 дигар пайванд мебошад. Сабаби динамикӣ гуфтани ин навъ додаҳо дар он аст,
 ки андозаи онҳо пас аз иҷроиши барнома метавонад ба таври дилхоҳ тағйир 
 ёбанд. Барои ба хонанда пурратар шинос шудан дар поён листи пайвандии 
 дорои чор гиреҳеро ба намуди графикӣ меорем. Расми. 
 Расми. 
 Тавре ки аз ин расм дида мешавад, ҳар як гиреҳи листи пайвандӣ дорои ду
 элемент иттилоот ва суроға мебошад. Ҳар як гиреҳ суроғаи гиреҳи баъдинаро
 дар худ нигоҳ медорад. Гиреҳи листи охирон ба ҷое ишора намекунад ва 
 қимати қисми суроғаи он NULL (сифр) мебошад. Листеро, ки ҳар гиреҳи он бо
 як пайванд ба гиреҳи баъди пайваст мешавад, листи якпайвандӣ номида 
 мешавад. 
 Баъзе аз листи пайвандӣ ҳастанд, ки ҳар гиреҳи онҳо дорои ду пайванд
 буда, як пайванди он ба гиреҳи баъди ва пайванди дигарашон ба гиреҳи қабли
 ишора мекунад. Ин навъ листҳоро листҳои ду пайвандӣ меноманд. Дар ин навъ
 листҳо ишорагари гиреҳи аввал ва охир ба ҷое ишора намекунанд, ва қимати 
 қисми суроғаи онҳо NULL мебошад. Барои ба хонанда пурратар намудани ин 
 матлаб дар поён листи дупайвандии дорои се гиреҳ оварда шудааст. 
 Расми. 
 Илова бар ин навъи дигари листи пайванди низ вуҷуд доранд, ки онҳоро
 листи пайвандии ҳалқавӣ меноманд. Дар ин навъ листи пайванди қисми 
 ишорагари гиреҳи охирон ба гиреҳи аввала ишора мекунад. Листҳои пайвандии
 ҳалқавӣ метавонанд, листҳои якпайванди ё ду пайвандӣ бошанд. Листҳои 
 пайвандии ҳалқавӣ шакли зеринро доранд: 
 Расми. 
 Барои ба моҳияти листҳои пайванди хубтар шинос шудан аввал листҳои 
 якпайвандӣ ва баъд листҳои дупайвандиро мавриди баҳс қарор медиҳем. 
 Эълон намудани Node 
 Пеш аз кор кардан ба листҳои пайвандӣ зарур аст, ки навъе барои 
 гиреҳҳои он муаррифӣ карда мешавад. Гиреҳҳои листи пайвандӣ асосан ба 
 намуди сохтор муаррифӣ карда мешаванд. Наҳви муаррификунии сохтори Node 
 шакли зеринро дорад: 
 struct номи сохтори Node 
 { 
 Навъ итилоот; 
 Номи сохтор *ишорагар; 
 } 
 Дар ин ҷо ба сифати итилоот, метавон додаи дилхоҳ навъи стандартӣ ва
 ғайристандартиро истифода кард. Ба сифати мисол cохтори Node-ро дида 
 мебароем, ки дорои ду майдон мебошад. Майдони якуми он адади бутун буда, 
 майдони дуввум ишорагар мебошад. 
 struct Node{ 
 int data; 
 Node *next 
 } 
 Пас аз ин дастур метавон гиреҳҳои лозимиро аз навъи ин сохтор ба сурати
 зерин муаррифӣ кард. 
 Node *p,*q; 
 Бо ёрии ин дастур ду гиреҳ муаррифӣ карда мешавад. 
 Пайваст намудани гиреҳҳои листҳои якпайвандӣ 
 Барои эҷод намудани листҳои пайвандӣ бояд, гиреҳҳои он ба ҳамдигар 
 пайваст карда шаванд. Ишорагарҳои *p ва *q –ро, ки қаблан муаррифӣ намуда
 будем, дар назар гирифта, қитъаи барномаи зеринро менависем. 
 p=new Node; 
 p->data =; 
 q=new Node; 
 q->data =; 
 Бо иҷрои ин дастурҳо ду node барои листи пайванди эҷод карда мешавад.
 Пас аз эҷод намудани node-ҳо зарурати пайваст намудани онҳо пеш меояд. 
 Барои пайваст намудани гиреҳҳои p ва q аз дастурҳои зерин истифода бурда 
 мешавад. 
 p->Next =q; 
 Маънои ин дастур ин аст, ки ҷое, ки q ба онҷо ишора мекунад p->Next низ
 бояд ба онҷо ишора кунад. Бо суханҳои дигар ишорагари гиреҳи p ба гиреҳи q
 ишора мекунад. Азбаски ишорагари Next –и гиреҳи q ба ҷое ишора намекунад,
 ба он қимати NULL мебахшем. Барои иҷрои ин амал яке аз роҳҳои зерин 
 истифода бурда мешавад: 
 ) q->Next =NULL; 
 ) p->Next->Next =NULL; 
 Маънои дастури якум ин аст, ки ба майдони Next-и гиреҳи q қимати 
 NULL бахшида шавад ва маънои дастури дуввум ин аст, ки ба майдони Next-и
 node ки ишорагари p ба он ишора мекунад қимати NULL бахшида шавад. Барои 
 моҳияти ин дастурҳоро фаҳмидан онҳоро ба намуди графикӣ тасвир мекунем. 
 Дар натиҷа шакли зерин ҳосил мешавад. 
 Илова намудани node дар листи пайвандӣ 
 Дар расми листи пайвандии дорои ду гиреҳҳои оварда шудаааст. Дар 
 онҷо p-ро ибтидои лист ва q-ро интиҳои лист меноманд. Илова бар ин метавон
 ба листи пайвандӣ гиреҳҳои нав низ ҳамроҳ кард. гиреҳҳои нав метавонанд дар
 аввал, дар мобайн ёдар охири листи пайвандӣ қарор гиранд. Масалан, барои дар
 байни гиреҳҳои p ва q илова намудани гиреҳи нав аввал онро ба сурати зерин
 эҷод мекунем: 
 Node *d=new Node; 
 d->data=; 
 Пас аз сохта шудани гиреҳи нав зарурати онро дар байни гиреҳҳои p ва q
 гузоштан пеш меояд. Барои иҷрои ин амал дастурҳои зерин истифода бурда 
 мешавад: 
 p->Next=d; 
 d->Next=q; 
 Намуди графикии ин амал чунин шакл дорад: 
 Расми. 
 Барои дар ибтидои лист гузоштани гиреҳи аввал бо номи head ишорагаре
 муаррифӣ намуда, гиреҳи нав эчод мекунем. 
 Node *head=new Node; 
 head->data=; 
 Пас аз муаррифии гиреҳи нав зарурати ба ибтидои лист гузоштани он пеш
 меояд. Барои иҷрои ин амал бояд ишорагар (node) p ба ибтидои гиреҳи нав 
 ишора кунад. Ба дастурҳои зерин диққат диҳед: 
 head->Next=p; 
 P=head; 
 Намуди графикии ин амал шакли зеринро дорад: Расми 
 Расми. 
 Эҷоди листҳои якпайвандӣ 
 Пас аз муаррифи кунии навъи node ба сохтани худи сохтори листи 
 пайвандӣ шуруъ мекунем. Тавре ки қайд карда будем, листи пайванди аз 
 гиреҳҳо ташкил ёфтааст, бинобар ин дар сохтори List ҳамаи амалиётҳои марбут
 ба листи пайвандӣ (илова, нест, ҷустуҷӯ ва ғайра) навишта мешаванд. Дар аввал
 ду амалиёти асосиро дар сохтори List дида мебароем. Ин амалиётҳо иборатанд
 аз илова намудани гиреҳи нав ва хориҷ намудани node-ҳо. Барои ба хонанда 
 фаҳмо шудани ин матлаб намуди умумии класи List-ро дар поён меорем. 
 struct List{ 
 Node *head; //сар (ибтидо) и листи пайвандӣ; 
 List(){ //Конструктор; 
 head=NULL; // то ҳол дар листи пайвандӣ ягон элемент нест; 
 } 
 // метод барои илова намудани элемент нав 
 void addNode(int d){ 
 } 
 // Метод барои хориҷ намудани элементҳои листи пайвандӣ 
 void printNode() { 
 } 
 Ин сохтор дорои як майдони ишорагар бо номи *head, як конструктор ва
 ду метод (функсия-аъзо) мебошад. Ишорагари *head аз навъи Node буда, ба 
 ибтидои листи пайванди ишора мекунад. Конструктор барои ба гиреҳи 
 нахустин бахшидани қимати NULL истифода бурда мешавад. Сабаби қимати 
 NULL бахшидан ба тағйирёбандаи ишорагари *head дар он аст, ки ҳангоми 
 сохтани нусхаи сохтори List он дорои ягон элемент набуда, ба ҷое ишора 
 намекунад. Методҳои addNode ва printNode() бошанд, мувофиқан барои илова 
 намудани элемент аз қафои листи пайвандӣ ва хориҷ намудани элементҳои 
 листи пайванди пешбинӣ шудаанд. Акнун, ки ба сохтори листи пайвандӣ шинос
 шудем, матни барномаро ба таври пурра меорем. 
 #include <iostream> 
 using namespace std; 
 struct Node 
 { 
 int data; 
 Node *Next; 
 }; 
 struct List{ 
 Node *head; //сар (ибтидо)-и листи пайвандӣ; 
 List() 
 { 
 head=NULL; //то ҳол элементи якум вуҷуд надорад; 
 } 
 // метод барои илова намудани элемент нав 
 void addNode(int d) 
 { 
 Node *nd=new Node; // ба намуди динамикӣ сохтани гиреҳи нав 
 nd->data =d; // қимат бахшидан ба node; 
 nd->Next= NULL; 
 if (head==NULL) 
 head=nd; 
 else 
 { 
 Node *current=head; 
 // дар ҳалқаи такрорӣ элементи пеш аз охирон ёфта мешавад. 
 while(current-head!=NULL) 
 current=current->Next; 
 current->Next=nd; 
 } 
 } 
 // Метод барои хориҷ намудани элементҳои листи пайвандӣ 
 void printNode(){ 
 Node *current=head; 
 while(current) 
 { 
 cout<<current->data<<endl; 
 current=current->Next; 
 } 
 } 
 }; 
 int main(){ 
 List myList; 
 myList.addNode(); 
 myList.addNode(); 
 myList.addNode(); 
 myList.addNode(); 
 myList.addNode(); 
 myList.printNode(); 
 system ("pause"); 
 return; 
 } 
 Натиҷаи барнома шакли зеринро дорад: 
 Барои ба хонанда фаҳмо шудан, ҳарду методи сохтори List-ро пайдарпай
 мавриди баҳс қарор медиҳем. 
 Дар сатри якуми методи addNode() тавассути оператори new объекти 
 (гиреҳи) наве аз навъи Node сохта шудааст. Тавре ки медонем ҳангоми 
 иҷроиши ин сатр дар ишорагари nd суроғаи гиреҳи нав сохташуда навишта 
 мешавад, агар сохтани node бо муваффақият анҷом гирад. Дар ҳолати акс ба он
 қимати NULL бахшида мешавад. Баъд аз ин тавассути дастури nd->data=d ба 
 майдони гиреҳи сохташуда муроҷиат карда шуда, ба он қимати лозимӣ навишта
 мешавад. Ин қимат аргументи методи addNode() мебошад. Ба ишорагар 
 бахшидани қимати NULL маънои аз нав сохтани node-ро дорад, ки дар охири 
 листи пайвандӣ гузошта мешавад. Ин амал тавасути дастури nd->Next= NULL 
 иҷро карда мешавад. 
 Қитъаи зерини барнома муайян мекунад, ки гиреҳи нахустини листи 
 пайвандӣ сохта мешавад ё дигар. 
 if (head==NULL) 
 head=nd; 
 else 
 {.... 
 } 
 Дар сурати сохтани гиреҳи нахустин, ба ишорагари head қимати NULL 
 бахшида мешавад ва дастурҳои пас аз шарт иҷро карда мешаванд. Дар ин сурат
 ба head суроғаи гиреҳи аввала аз хотира бахшида мешавад. Дар ҳолати сохтани
 гиреҳҳои боқимонад (,,,...) қисмати дастурҳои пас аз else, ки шакли зеринро
 доранд иҷро карда мешаванд. 
 Node *current=head; 
 // дар ҳалқаи такрорӣ элементи пеш аз охирон ёфта мешавад. 
 while(current-next!=NULL) 
 current=current->next; 
 current->next=nd; 
 Дар ин ҷо тағйирёбандаи иловагие аз навъи Node муаррифӣ шуда, ба 
 сифати қимати аввала ба он суроғаи ибтидои лист бахшида мешавад. Пас аз ин
 дар дохили ҳалқаи такрорӣ то мавқеи гиреҳи охирон сохтаамон ҳаракат 
 мекунад. Дар сурати ба он расидан суроғаи гиреҳи нав сохташуда ба он 
 бахшида мешавад. Барои пурратар дарк кардани ин матлаб, дар поён тасвири 
 графикии илова намудани гиреҳи нав дар охири лист оварда шудааст. 
 Расми. 
 Пас аз оне, ки ба моҳияти методи addNode() пурра шинос шудем, методи
 printNode()-ро, ки шакли зеринро дорад мавриди баҳс қарор медиҳем. 
 void printNode() { 
 Node *current=head; 
 while(current) 
 { 
 cout<<current->data<<endl; 
 current=current->Next; 
 } 
 } 
 Дар ин ҷо тағйирёбандаи ёрирасоне аз навъи Node сохта шуда, ба он 
 суроғаи гиреҳи якуми листи пайвандӣ бахшида шудааст. Сипас дар дохили 
 ҳалқаи такрорӣ то расидан ба гиреҳи охирон пайдарпай қиматҳи гиреҳҳо хориҷ
 карда мешаванд. 
 Тавре ки дар ин мисол дида мешавад элементи нав аз охир илова карда 
 шудааст. Илова бар ин, равиши дигаре низ вуҷуд дорад, ки дар он элемент аз
 аввали лист илова карда мешавад. Барои ин зарур аст, ки барномаи қаблӣ ба
 сурати зерин тағйир дода шавад. 
 #include <iostream> 
 using namespace std; 
 struct Node{ 
 int data; 
 Node *Next; 
 }; 
 struct List{ 
 Node *head; //сар (ибтидо) и листи пайвандӣ; 
 List() 
 { 
 head=NULL; //то ҳол элементи якум вуҷуд надорад; 
 } 
 // метод барои илова намудани элемент нав 
 void addNode(int d){ 
 Node *nd=new Node; // ба намуди динамикӣ сохтани гиреҳи нав 
 nd->data =d; // қимат бахшидан ба node; 
 // гиреҳи нав дар охир илова карда мешавад, барои ин NULL 
 nd->Next= head; 
 head=nd; 
 if(head==NULL) //агар гиреҳи аввал сохта шавад 
 head=nd; 
 else // агар гиреҳи аввал набошад 
 { 
 Node *current=head; 
 //дар ҳалқа гиреҳи пеш аз охирон ҷустуҷӯ карда мешавад. 
 while (current->Next!=NULL) 
 current=current->Next; 
 // гиреҳи пешина ба охирон ишора мекунад 
 current->Next =nd; 
 } 
 } 
 // Метод барои хориҷ намудани элементҳои листи пайвандӣ 
 void printNode(){ 
 Node *current=head; 
 while(current!=NULL) 
 { 
 cout<<current->data<<" "; 
 current=current->Next; 
 } 
 } 
 }; 
 int main(){ 
 List myList; 
 myList.addNode(); 
 myList.addNode(); 
 myList.addNode(); 
 myList.addNode(); 
 myList.addNode(); 
 myList.printNode(); 
 return; 
 } 
 Дар ин варианти барнома методи add Node() ба шакли зерин тағйир дода
 шудааст: 
 void addNode(int d) { 
 Node *nd=new Node; // ба намуди динамикӣ сохтани гиреҳи нав 
 nd->data =d; // қимат бахшидан ба node; 
 nd->Next= head; 
 head=nd; 
 } 
 Натиҷаи барнома шакли зеринро дорад: 
 Нест намудани гиреҳ аз листи пайвандӣ 
 Барои нест намудани гиреҳе аз листи пайвандӣ, зарур аст, ки ишорагари
 онро ёфта ба NULL баробар кард. Бигзор листи пайвандие иборат аз се гиреҳ
 дода шуда бошад. (Расми ). Барои нест намудани гиреҳи d кифоя аст, ки 
 майдони Next-и ишорагари p ба q ишора кунад ва майдони Next-и ишорагари d
 бошад, NULL бахшида мешавад. Баъд аз ин гиреҳеро, ки ишорагари d ба он 
 ишора мекунад, ба фазои озодӣ ҳофиза бармегардад. Ба дастурҳои зерин диққат
 диҳед: 
 p->Next=q; 
 d->Next=NULL; 
 delete d; 
 Нест намудани гиреҳ аз ибтидои листи пайвандӣ низ ба ҳамин монанд 
 мебошад, вале дар ёд дошта бошед, ки ишорагаре, ки ба ибтидои лист ишора 
 мекард, бояд ба гиреҳи баъдӣ ишора кунад. Масалан барои нест намудани 
 гиреҳи аввалаи расми. чунин амал мекунем: Гиреҳи head-ро, ки ибтидои лист
 аст ба гиреҳи баъдӣ мебарем ва майдони Next- вобаста ба гиреҳи p ба NULL 
 баробар карда мешавад. Дар охир p-ро ба фазои озод бармегардонем. Ба 
 дастурҳои зерин диққат диҳед: 
 head=head->Next; 
 p->Next=NULL; 
 delete p; 
 Мисол. Функсияе нависед, ки аз листи пайвандии мисоли қаблӣ, 
 элементи дуввумро нест кунад. 
 #include <iostream> 
 using namespace std; 
 struct Node{ 
 int data; 
 Node *Next; 
 }; 
 struct List{ 
 Node *head; //сар (ибтидо) и листи пайвандӣ; 
 List() 
 { 
 head=NULL; //то ҳол элементи якум вуҷуд надорад; 
 } 
 // метод барои илова намудани элемент нав 
 void addNode(int d) 
 { 
 Node *nd=new Node; // ба намуди динамикӣ сохтани гиреҳи нав 
 nd->data =d; // қимат бахшидан ба node; 
 // гиреҳи нав дар охир илова карда мешавад, барои ин NULL 
 nd->Next= head; 
 head=nd; 
 if(head==NULL) //агар гиреҳи аввал сохта шавад 
 head=nd; 
 else // агар гиреҳи аввал набошад 
 { 
 Node *current=head; 
 //дар ҳалқа гиреҳи пеш аз охирон ҷустуҷӯ карда мешавад. 
 while (current->Next!=NULL) 
 current=current->Next; 
 // гиреҳи пешина ба охирон ишора мекунад 
 current->Next =nd; 
 } 
 } 
 // Метод барои хориҷ намудани элементҳои листи пайвандӣ 
 void printNode(){ 
 Node *current=head; 
 while(current!=NULL) 
 { 
 cout<<current->data<<endl; 
 current=current->Next; 
 } 
 } 
 //Метод барои нест намудани элементи дуввум 
 void DelSecond(){ 
 Node *q; 
 if (head!=NULL){ 
 q =head->Next; 
 if (q!=NULL){ 
 head->Next=q->Next; 
 delete q; 
 } 
 } 
 } 
 }; 
 int main(){ 
 List myList; 
 myList.addNode(); 
 myList.addNode(); 
 myList.addNode(); 
 myList.addNode(); 
 myList.addNode(); 
 myList.printNode(); 
 cout<<endl; 
 myList.DelSecond(); 
 myList.printNode(); 
 system ("Pause"); 
 return; 
 } 
 Иҷрои амалиётҳои дигар бо листҳои якпайвандии 
 Барои листҳои якпайвандӣ метавон амалиётҳои дигарро низ иҷро намуд. 
 Ҳоло дар сохтори List амалиётҳои зеринро илова мекунем: 
 ) Илова намудани гиреҳ ба ибтидои листи пайвандӣ; 
 ) Илова намудани гиреҳ дар охири листи пайвандӣ; 
 ) Рақамгузории элементҳои листи пайвандӣ; 
 ) Ҷустуҷӯи элемент дар дохили листи пайвандӣ; 
 ) Нест намудани гиреҳ аз ибтидои листи пайвандӣ; 
 ) Нест намудани гиреҳ аз охири листи пайвандӣ; 
 ) Хориҷ намудани элементҳои листи пайвандӣ аз аввал ба охир; 
 ) Хориҷ намудани элементҳои листи пайвандӣ аз охир ба аввал; 
 Барои иҷрои ҳар кадом ин амалиёт методи мувофиқ ба онро менависем. 
 Дар натиҷа мисоли қаблан овардаамон шакли зеринро мегирад: 
 #include <iostream> 
 using namespace std; 
 struct Node{ 
 int key; //рақами гиреҳ дар листи пайвандӣ; 
 int data; //итилооти гиреҳ; 
 Node *next; // ишорагар ба гиреҳи баъдӣ; 
 Node *last; //ишорагар ба гиреҳи қаблӣ; 
 Node(int data, Node *next, Node *last) 
 { 
 this->data = data; 
 this->next = next; 
 this->last = last; 
 } 
 Node(int data) 
 { 
 this->data = data; 
 } 
 }; 
 struct List{ 
 Node *head; // сар (ибтидо) и листи пайвандӣ; 
 Node *temp; //ишорагар ба гиреҳи охирон; 
 List(){ 
 /* ҳангоми сохтани гиреҳи якум ишорагар баробар бо NULL 
 карда мешавад, барои он яъне гиреҳи баъди вуҷуд надорад; 
 */ 
 head=NULL; 
 temp=NULL; 
 } 
 // метод барои муайян намудани рақами гиреҳ; 
 void numNode() 
 { 
 Node *counter = head; 
 int i =; 
 while(counter) 
 { 
 counter->key = ++i; 
 counter = counter->next; 
 } 
 } 
 //метод барои илова кардани гиреҳ дар озири листи пайвандӣ; 
 void addNodeEnd(int data){ 
 //гиреҳи нав сохта онро дар охири лист қарор медиҳем; 
 Node *nd = new Node(data, NULL, temp); 
 temp = nd; 
 if(head) 
 { 
 //ба ибтидои лист (гиреҳи якум) ишора мекунад 
 Node *current = head; 
 // Ҳалқаи такрорӣ барои муайян кардани гиреҳи баъдӣ. 
 // Ин ҳалқа то расидан ба охирон гиреҳ иҷро карда мешавад 
 while(current->next 
 current = current->next; //Гузаштан ба гиреҳи навбатӣ; 
 ////гиреҳи қабли ба гиреҳи баъди ишорат мекунад; 
 current->next = nd; 
 } 
 // агар лист холи бошад, гиреҳи нахустин сохта мешавад 
 else 
 head=nd; 
 numNode(); //рақамгузории гиреҳ; 
 } 
 // метод барои илова намудани гиреҳ аз аввали листи пайвандӣ 
 void addNodeBeginning(int data){ 
 Node *nd = new Node(data); 
 if(head) //агар дар лист гиреҳ алакай вуҷуд дошта бошад; 
 { 
 Node *tmp = head; 
 head = nd; 
 nd->next = tmp; 
 } 
 else //агар лист холӣ бошад; 
 { 
 head = nd; 
 nd->next = NULL; 
 } 
 numNode(); 
 } 
 //Метод барои нест намудани гиреҳ аз аввали листи пайвандӣ; 
 void deleteNodeEnd(){ 
 if(temp) 
 { 
 Node *current = temp; 
 current = current->last; 
 delete current->next; 
 current->next = NULL; 
 } 
 else 
 cout << "The list is empty!" << endl; 
 } 
 //метод барои нест намудани гиреҳ аз ибтидои лист; 
 void deleteNodeBeginning() 
 { 
 if(head) 
 { 
 Node *tmp = head; 
 tmp = tmp->next; 
 delete head; //озод намудани хотира аз ин суроға; 
 head = tmp; //бахшидани қимати нав; 
 } 
 else 
 cout << "The list is empty!" << endl; 
 numNode(); 
 } 
 //метод барои ҷустуҷӯи гиреҳ аз дохили листи 
 //пайванди бо дода шудани калид; 
 int find(int k){ 
 Node *counter = head; 
 while(counter) 
 { 
 if(counter->key == k) 
 return counter->data; 
 counter = counter->next; 
 } 
 } 
 //Хориҷ намудани элементҳои лист бо тартиби роста; 
 void printListForward() const { 
 Node *current = head; 
 while(current) //то расидан ба гиреҳи охирон; 
 { 
 //хориҷ намудани иттилоот ба саҳифаи тасвир; 
 cout << current->key << " - " << current->data << endl; 
 current = current->next$ ||uepfinfy,f ubhtҳb,f]lӣ$ 
 } 
 } 
 //Метод барои хориҷ намудани элементҳои листи 
 // бо тартиби баракс; 
 void printListBack() const 
 { 
 Node *current = temp; 
 while(current) 
 { 
 cout << current->key << " - " << current->data << endl; 
 current = current->last; 
 } 
 } 
 }; 
 int main(){ 
 List myList; 
 int key; 
 //даъвати метод барои илова намудани гиреҳҳо аз охир 
 myList.addNodeEnd(); 
 myList.addNodeEnd(); 
 myList.addNodeEnd(); 
 myList.addNodeEnd(); 
 myList.addNodeEnd(); 
 myList.addNodeEnd(); 
 myList.addNodeEnd(); 
 cout<<"Call method printListForward()"<<endl; 
 myList.printListForward(); 
 cout << endl; 
 cout<<"Call method printListBack()"<<endl; 
 myList.printListBack(); 
 myList.addNodeBeginning(); 
 myList.addNodeBeginning(); 
 myList.addNodeBeginning(); 
 myList.addNodeBeginning(); 
 cout << endl; 
 cout<<"Call method printListForward()"<<endl; 
 myList.printListForward(); 
 myList.deleteNodeEnd(); 
 cout << endl; 
 cout<<"Call method printListForward()"<<endl; 
 myList.printListForward(); 
 myList.deleteNodeBeginning(); 
 cout << endl; 
 cout<<"Call method printListForward()"<<endl; 
 myList.printListForward(); 
 cout << "Enter a number of node: "; 
 cin >> key; 
 cout << "Data node " << key << " = " << myList.find(key) << endl; 
 system ("Pause"); 
 return; 
 } 
 Дар дохили барнома, шарҳҳои лозими оварда шудаанд. Аз инру барнома 
 ҳоҷат ба шарҳу тавзеҳ надорад. 
 Листҳои дупайвандӣ 
 Дар листҳои дупайвандӣ ҳар гиреҳи лист ба гиреҳи баъди ва қабли ишора
 мекунад. Бо ибораи дигар ҳар гиреҳи листи дупайвандӣ суроғаи гиреҳи баъдӣ
 ва қаблии худро доро аст. Барои эҷоди чунин листҳо бояд ҳар як гиреҳи он бо
 ҳам пайваст карда шаванд. Аз ин ҷо дар дилхоҳ мавқеи листҳои 
 дупайвандӣметавон ба тарафи аввал ё охир ҳаракат кард. Ин амал барои 
 листҳои якпайвандӣ иҷро карда намешавад. Наҳви умумии муаррификунии 
 навъ барои листҳои дупайвандт (Node) шакли зеринро дорад. 
 struct Node{ 
 Node *left; 
 Навъ итилоот; 
 Node *right; 
 } 
 Дар ин ҷо тавре ки дида мешавад ду ишорагар бо номҳои left ва right 
 муаррифӣ гардидаанд. Тавре ки гуфтем, ишорагари left ба гиреҳи самти чап ва
 ишорагари right ба гиреҳи самти рост ишора мекунад. Итилоот метавонад 
 дилхоҳ додаи навъи стандартӣ ва ғайристандартӣ бошад. Дар поён ба монанди
 мисоли қабли мисолеро дида мебароем. Барои мисоли мавриди назар ба сурати
 зерин Node сохта мешавад. 
 struct Node{ 
 Node *left; 
 int data; 
 Node *right; 
 } 
 Пас аз муаррификунии навъ зарурати сохтани гиреҳҳо пеш меояд. 
 Гиреҳҳои листҳоии дупайванди монанди гиреҳҳои листҳои якпайванди 
 муаррифӣ карда мешаванд. 
 Node *p=new Node; 
 Node *q=new Node; 
 Бо иҷрои ин дастурҳо шакли зерин эҷод карда мешавад: 
 Барои пайваст кардани ин ду гиреҳ бо ҳамдигар аз дастурҳои зерин 
 истифода мекунем: 
 p->right=q; 
 q->left=p; 
 p->left=NULL; 
 q->right=NULL; 
 Бо иҷрои ин дастурҳо ду гиреҳ бо ҳамдигар пайваст карда мешаванд. 
 Намуди графикии ин амал чунин аст: 
 Мисол. Барномае нависед, ки дар он амали сохтан ва хориҷ намуда-ни 
 листи дупайванди вуҷуд дошта бошад. 
 #include <iostream> 
 using namespace std; 
 struct Node //сохтани навъ барои листи дупайвандӣ; 
 { 
 Node *Prev; // ишорагар ба суроғаи гиреҳи қаблӣ; 
 int x; //итилооти лист; 
 Node *Next; //ишорагар ба суроғаи гиреҳи баъдӣ; 
 // 
 }; 
 struct List { 
 Node *Head,*Tail; //ишорагар ба аввал ва охири лист; 
 List(){ 
 Head=NULL; 
 Tail=NULL; 
 } 
 //Метод барои илова намудани гиреҳ дар листи дупайвандӣ; 
 void Add(int x) 
 { 
 Node *temp=new Node; //ҷудо кардани хотира барои гиреҳи нав; 
 temp->Next=NULL; //дар ибтидо вуҷуд надоштани гиреҳи баъдӣ; 
 temp->x=x;//навиштани қимат дар лист; 
 if (Head!=NULL) //агар лист холӣ набошад; 
 { 
 temp->Prev=Tail; //ба майдони мувофиқи элементти 
 // баъдӣ ишора мекунем; 
 Tail->Next=temp; //Суроғаи баъдиро ба қафои элемент 
 //ишора мекунем 
 Tail=temp; //Иваз намудани суроғаи дум; 
 } 
 else //агар лист холӣ бошад; 
 { 
 temp->Prev=NULL; //Элементи қаблӣ ба холи ишора мекунад; 
 Head=Tail=temp //Сар=дум=элементе, ки ҳозир илова 
 //карда шудааст; 
 } 
 } 
 // Метод барои хоиҷ намудани элементҳои лист; 
 void Show() 
 { 
 // Хориҷ намудани лист ах қафо 
 cout<<"Print list from begin to end"<<endl; 
 Node *temp=Tail; 
 //Ишорагари муваққати ба суроғаи элементи охирон; 
 while (temp!=NULL) //то расидан ба элементи холӣ; 
 { 
 cout<<temp->x<<" "; //хориҷ намудани элемент; 
 temp=temp->Prev; 
 } 
 cout<<"\n"; 
 //хориҷ намудани лист аз аввал; 
 cout<<"Print list from end to begin"<<endl; 
 temp=Head; //ишорагари муваққати ба суроғаи элементи нахустин; 
 while (temp!=NULL) //то расидан ба элементи холӣ; 
 { 
 cout<<temp->x<<" "; //хориҷ намудани элементи хондашуда; 
 temp=temp->Next; //иваз намудани суроға ба 
 // суроғаи элементи баъдӣ; 
 } 
 cout<<"\n"; 
 } 
 }; 
 int main(){ 
 List myList; //Муарифӣ намудани тағйирёбандаи листи дупайвандӣ; 
 myList.Add(); //Илова намудани элементҳо; 
 myList.Add(); 
 myList.Add(); 
 myList.Add(); 
 myList.Show(); //Даъвати методи Show() барои хориҷ 
 //намудани элементҳо 
 return; 
 } 
 Пуштаҳо (Stack) 
 Пуштаҳо додаҳои динамикие мебошанд, ки фақат онҳоро метавон аз боло 
 дастаёбӣ кард. Дар листҳои пайвандӣ барноманавис метавонанд, ба ҳар яке аз
 гиреҳҳо дастёбӣ дошта бошад, вале дар пушта ин тавр нест. Фарз кунед, ки 
 мехоҳед дар сандуқе, ки андозаи васеъгии он ба як китоб баробар буда, 
 баландиаш ба якчанд ҷилди китоб баробар мебошад, китобҳои худро ҷойгир 
 кунед. Пас аз чидани китобҳо ҳар бор танҳо китоби аз ҳама болоро метавон 
 бардошт. Барои ба даст овардани китоби аз ҳама поён зарур аст, ки ҳамаи 
 китобҳоро аз сандуқ берун овард. Дар ин ҷо сандуқ пуштаеро мемонад, ки 
 унсурҳои онро танҳо метавон аз боло дастёбӣ кард. 
 Ба таври куллӣ, пуштаро метавон ҳамчун листи пайвандие дар назар 
 гирифт, маҳалли дарҷ ва ҳазфи гиреҳҳо аз ибтидои он анҷом дода мешавад. Аз
 сабаби оне, ки ба элементи охирони пушта нисбат ба элементҳои дигар метавон
 зудтар дастёбӣ шуд, бинобар ин пуштаро LIFO низ мегӯянд. LIFO мухаффафи 
 Last Input First Output буда, маънои “Охир омад аввал меравад”-ро дорад. 
 Пуштаҳоро метавон бо истифода за листҳои пайвандӣ ва массивҳо 
 пиёдасозӣ намуд. 
 Бо пуштаҳо метавон амалҳои зеринро анҷом дод. Ин амалҳо иборатанд аз:
 ) Эълони пуштаи холӣ; 
 ) Санҷидани холи будани пушта; 
 ) Илова намудани элемент дар пушта; 
 ) Нест намудани элемент аз пушта; 
 ) Ҷустуҷӯи элемент аз пушта; 
 ва ғайра. 
 Дар аввал пиёдасозии пуштаро тавассути массивҳо мавриди баҳс қарор 
 медиҳем. 
 Пиёдасозии пушта бо массив 
 Барои пиёдасозии пуштаҳо тавассути массив, аввал массиве бо андозаи n
 муарррифӣ карда, сипас ду тағйирёбандаи иловагӣ барои муайянкунии ибтидо 
 ва интиҳои пушта муаррифӣ мекунем. Масалан тарзи муаррификунии пуштааз 
 навъи бутун шакли зеринро дорад: 
 int Stack[n]; 
 int pos, tos; 
 Пас аз муаррификунии пушта амалҳои лозимиро бо пушта ба навбат дида 
 мебароем. 
 ) Эҷоди пуштаи холӣ. Барои эҷоди пуштаи холи ба тағйирёбандаҳои pos
 ва tos мувофиқан қиматҳои ва -ро мебахшем. 
 pos=; 
 tos=; 
 ) Холи будани пуштаро санҷидан. 
 if(top<pos) 
 cout<<”Stack is Empty”; 
 ) Илова намудани элемент дар пушта. Барои илова намудани элемент дар
 пушта аввал бояд санҷида шавад, ки пушта пур нест. Ин амал ба сурати зерин
 иҷро карда мешавад. 
 tos++; 
 if (tos>n) 
 cout<<"Stack is 
 Full"; 
 else 
 Stack[tos]=item; 
 Қайд. Пур будани пушта, ҳангоми амалисозии он бо массив санҷида 
 мешавад. Барои листҳои пайвандӣ ин амал вуҷуд надорад. 
 ) Нест намудани элемент аз пушта. Пеш аз нест намудани элемент аз 
 пушта, бояд аввал санҷида шавад, ки пушта холӣ нест. Пас аз ин элементи 
 лозимӣ аз пушта нест карда мешавад. 
 if(top<pos) 
 cout<<"Stack is Empty"; 
 else{ 
 item=Stack[tos]; 
 tos=tos-; 
 } 
 ) Бозёбии элемент аз пушта. Пеш аз иҷрои амали бозёбӣ аввал холӣ 
 набудани пушта санҷида мешавад. Ин амал ба сурати зерин иҷро мегарданд. 
 if(top<pos) 
 cout<<”Stack is Empty”; 
 else 
 item=Stack[tos]; 
 Пиёдасозии пушта бо листҳои пайвандӣ 
 Дар ин пиёдасозӣ пуштаро ба сурати листи пайвандӣ дар назар мегирем,
 ки элементҳо танҳо аз ибтидо илова ё нест карда мешавад. 
 ) Эҷоди гиреҳи пушта. Ин амл монанди листҳои пайвандӣ аст, ки myTop
 ба ибтидои он ишора мекунад. 
 ) Эҷоди пуштаи холӣ. Барои иҷрои ин амал бояд myTop баробар бо 
 NULL карда шавад. 
 myTop=NULL; 
 ) Холӣ будани пуштаро санҷидан. 
 if(myTop==NULL) 
 cout<<”Stack is Empty”; 
 ) Илова намудани элемент дар пушта. Барои илова намудани элемент дар
 пушта аввал бояд санҷида шавад, ки пушта пур нест. Ин амал ба сурати зерин
 иҷро карда мешавад. 
 P= new Stack; 
 p->Next=myTop; 
 myTop=p 
 ) Нест намудани элемент аз пушта. Пеш аз нест намудани элемент аз 
 пушта, бояд аввал санҷида шавад, ки пушта холӣ нест. Пас аз ин элементи 
 лозимӣ аз пушта нест карда мешавад. 
 if(myTop==NULL) 
 cout<<"Stack is Empty"; 
 else 
 { 
 h=myTop; 
 item=h->data; 
 myTop=myTop->Next; 
 delete h; 
 } 
 ) Бозёбии элемент аз пушта. Пеш аз иҷрои амали бозёбӣ аввал холm 
 набудани пушта санҷида мешавад. Ин амал ба сурати зерин иҷро мегарданд. 
 if(myTop==NULL) 
 cout<<"Stack is Empty"; 
 else 
 myTop=myTop->data; 
 Барои моҳияти ин амалҳоро пурра дарк кардан мисоли кучакеро дида 
 мебароем. 
 #include <iostream> 
 using namespace std; 
 /*сохтори стек*/ 
 struct List 
 { 
 int x; //элементи маълумотӣ 
 List *Next,*Head; //Сари пушта ва ишорагар ба элементи баъдӣ 
 }; 
 /*Функсия барои илова намудани элемент ба пушта (руйхати LIFO)*/ 
 void Add(int x, List **MyList) 
 { 
 List *temp=new List; //Ҷудо кардани хоӣтра барои элементи нав 
 //дар майдони х қимате, ки аз функсия ба даст омадааст менависем 
 temp->x=x; 
 //Нишон медиҳем, ки элементи қаблӣ ин элементи баъдӣ мебошад 
 temp->Next=(*MyList)->Head; 
 //сари стекро як хонача ба тарафи рост мекучонем 
 (*MyList)->Head=temp; 
 } 
 /*Функсия барои хориҷ намудани пушта*/ 
 void Show(List *MyList) 
 { 
 //ишорагаре,ки ба ибтидои пушта ишора мекунад эълон мекунем 
 List *temp=MyList->Head; 
 //тавассути давр ҳамаи элементҳоро аз назар мегузаронем 
 while (temp!=NULL) 
 { 
 cout<<temp->x<<" "; //хориҷ намудани элементи стек 
 temp=temp->Next; //гузаштан ба элементи баъдӣ 
 } 
 } 
 /*функсия барои нест намудани пуштаро аз хофиза*/ 
 void ClearList(List *MyList) 
 { 
 while (MyList->Head!=NULL) 
 { 
 List *temp=MyList->Head->Next; 
 delete MyList->Head; 
 //ивз намудани суроғаи элемент ба элементи баъдӣ 
 MyList->Head=temp; 
 } 
 } 
 int main(){ 
 List *MyList=new List; //Ҷудо намудани ҳофиза барои стек 
 MyList->Head=NULL; // 
 for (int i=;i<;i++) 
 Add(i,&MyList); //Гузоштани элементҳо дар стек 
 Show(MyList); //хориҷ намудани элементҳои стек 
 void ClearList(List *MyList); //тоза намудани хотира. 
 system ("Pause"); 
 return; 
 Мисоли дигар. 
 #include <iostream> 
 using namespace std; 
 struct stek { 
 int d; 
 struct stek *next; // Ишорагар ба элемети баъдӣ (стек) 
 }; 
 void push(stek* &next, int d) { 
 // Эълон намудани тағйирёбандаи нави динамикӣ аз навъи stek 
 stek *pv = new stek; 
 pv->d = d; // бахшидани қимат 
 // пайваст намудани элементи навро бо элементи қаблӣ 
 pv->next = next; 
 // элементи нав ҳамчун қуллаи пушта ҳисобида мешавад 
 next = pv; 
 } 
 int pop(stek* &next){ 
 // ба тағйирёбандаи temp бахшидани қимати қуллаи стек 
 int temp = next->d; 
 // барои холи намудани хотираро аз он суроғаи қуллаи пуштаро дар 
 //ишорагар нигоҳ медорем 
 stek *pv = next; 
 next = next->next; 
 delete pv; 
 cout<<temp; //хориҷ намудани элементи ҷорӣ 
 return temp; // баргардонидани қимати дар қулла буда 
 } 
 int main(){ 
 stek *p=; 
 push(p,); //Дар стек гузоштани қимати 
 push(p,); // Дар стек гузоштани қимати 
 pop(p); //хориҷ намудани қимати 
 pop(p); //хориҷ намудани қимати 
 system ("Pause"); 
 return; 
 } 
 Сафҳо 
 Саф низ яке аз навъи сохтмони додаҳои динамикӣ аст, ки корбурди 
 хосеро дорад. Мафҳуми саф дар барномасозӣ монанди сафи рӯзмарра аст, ки 
 барои савор шудан ба таксӣ, харидани нон аз нонвойхона ва ғайра мебошад. 
 Дар ин навъ сафҳо Тавре ки медонем, ҳар касе, ки зудтар вориди саф шуд, 
 зудтар ба он хизмат расонида мешавад. Ба ҳамин далел сафро сохтмони 
 додаҳои FIFO мегӯянд. FIFO мухаффафи First In First Out буда, маънои “Хуруҷ
 ба тартиби вуруд” ё “Аввал даромадан аввал хориҷ шудан”-ро дорад. Сафро 
 низ метавон тавассути литсҳои пайвандӣ ё массивҳо пиёдасозӣ кард. Дар ин ҷо
 пиёдасозии сафро тавассути листҳои пайвандӣ дида мебароем. Ҳар саф ниёз ба
 ду ишорагар дорад, ки мувофиқан онҳоро front (ибтидои саф) ва rear (интиҳои
 саф) мегӯянд. Амали нест намудани элемент саф, аз ибтидои лист анҷом дода
 мешавад, ва бо ҳазфи ҳар унсуре аз саф ишорагари front ба тарафи ишорагари
 rear ҳаракат мекунад. 
 Равиши илова намудани элемент дар саф монанди илова намудани гиреҳ 
 дар охири листи пайвандӣ мебошад. 
 Нест намудани элемент аз листи пайвандӣ монанди нест намудани гиреҳ 
 аз интиҳои листи пайвандӣ мебошад. 
 Амалҳои асосие, ки бо сафҳо анҷом дода мешаванд иборатанд аз: 
 ) Эҷоди сафи холӣ; 
 ) Илова намудани элемент дар саф; 
 ) Ҷустуҷӯи элемент дар дохили саф; 
 ) Нест намудани элемент аз саф; 
 Саволҳо барои мустаҳкамкунӣ 
 ) Листи пайвандӣ гуфта, чиро дар назар доранд? 
 ) Листи пайвандӣ чи тавр муаррифӣ карда мешавад? 
 ) Листҳои пайвандӣ чанд хел мешаванд? 
 ) Листҳои дупайвандӣ чи тавр муаррифӣ карда мешаанд? 
 ) Пушта чист ва чи фарқият аз листи пайвандӣ дорад? 
 ) Пуштаҳо чи тавр муаррифӣ карда мешаванд? 
 ) Дастёби ба элементҳои пушта чи тавр аст? 
 ) Саф чист ва чи фарқият аз пушта дорад? 
 ) Чи тавр элемент аз саф нест карда мешавад? 
 ) Оид ба листҳои пайвандӣ, пуштаҳо ва сафҳо мисол биёред. 
 Мисолҳо барои кори мустақилона 
 ) Функсияе нависед, ки муҳтавои элементи аввал ва охирони листи пайвандӣ
 ро иваз кунад. 
 ) Барномае нависед, ки ду листи пайвандӣ ро бо ҳам муқоиса кунад. 
 ) Барномае нависед, ки қимати миёнаи арифметикии ҳамаи элементҳои листи
 пайвандӣ ро ҳисоб кунад. 
 ) Ду листи пайвандӣ дода шудааст. Барномае нависед, ки аз элементҳои 
 якхелаи ин листҳои пайвандии додашуда листи пайвандии дигареро тартиб 
 диҳад. 
 ) Барномае нависед, ки пас аз ҳамаи элементҳои тоқи листи пайвандӣ 
 элементи додашударо гузорад. 
 ) Барномае нависед, ки амали листҳои пайвандиро таваассути массивҳо иҷро
 кунад. 
 ) Бо истифода аз пуштаҳо барномае нависед, ки дар мавқеаш пушида шудани
 қавсҳои (,), {,}, [, ]-ро муайян кунад. 
 ) Барномае нависед, ки сафҳоро дар листҳои дупайвандӣ нигоҳ дошта 
 амалҳои лозимиро болои онҳо анҷом диҳад. 
 ) Фосилаи қимати навъҳои бутун (int, longint, shortint) маҳдуд мебошад.
 Масалан, қимати! аз ин фосила хориҷ мешавад. Барои нигоҳ доштани 
 ададҳои калон аз листҳои дупайвандӣ истифода бурда, амалҳои зеринро анҷом
 диҳед: 
 a) Сумма, фарқ, нисбат ва ҳосили зарби ададҳои дароз. 
 b) Ба дараҷаи адади кутоҳ бардоштани адади дароз. 
 c) Ба дараҷаи дароз бардоштани адади дароз. 
 ) Барномае нависед, ки бо истифода аз листҳои дупайвандӣ факториали 
 дилхоҳ адади бутуни додашударо ҳисоб кунад. 
 ) N адади аввалаи натуралӣ, ки аз тақсимкунандаҳои содда, танҳо, ва –
 ро доранд бо тартиб хориҷ карда шавад. 
 ) Бо истифода аз листҳои пайвандӣ барномае нависед, ки дар нимсола аз 
 гӯруҳи донишҷуён, донишҷуёни гирандаи идрорро муайян кунад. Донишҷӯ 
 ҳамон вақт соҳиби идрор мешавад, агар аз ҳамаи фанҳои таълими баҳои 
 ғайриқаноатбахш гирад. Ному насаби донишҷӯ, номгӯи фанҳо ва баҳои ҳаряк 
 донишҷӯ аз ҳамаи фанҳо дода мешавад. 
 ) Бо истифода аз листҳои пайвандӣ ададҳои соддаи фосилаи аз то n-ро 
 хориҷ кунад. 
 ) Бо истифода аз листҳои пайвандӣ ададҳои мукаммали фосилаи аз то n-ро
 хориҷ кунад. 
 ) Барномае нависед, ки элементи аввалаи ҷуфти листи пайвандиро нест 
 кунад. 
 ) Барномае нависед, ки пас аз элементи дуввуми листи пайвандӣ элементи
 додашударо гузорад. 
 ) Барномае нависед, ки пас аз ҳар элементи манфӣ, элементи додашударо 
 гузорад. 
 ) Барномае нависед, ки гиреҳи n-уми листи пайвандиро нест кунад. 
 ) Барномае нависед, ки элементҳои соддаи листи пайвандиро нест кунад. 
 ) Барномае нависед, ки гиреҳи n-уми листи пайвандиро ба квадрат бардорад.
 Боби. Китобхонаи қолаб (шаблон)-ҳои стандартӣ STL 
 (Standard Template Library) 
 Муқаддима 
 Китобхонаи STL дар забони С++ яке аз китобхонаҳои нисбатан бузурге ба
 ҳисоб меравад, ки дар он функсияҳои зиёде барои кор кардан бо листҳо, 
 векторҳо, алгоритмҳо, сатрҳо ва ғайра мавҷуданд. Ба таври дигар гӯем, STL –ин
 маҷмӯи қолаб (шаблон)-ҳои class-ҳо ва функсия(function)-ҳо мебошад. Агар 
 ҳамаи STL- ро гирд оварем, як китоби мураттабе ҳосил мушавад. Аз ин рӯ, 
 баъзан қисматҳои муҳими онро меорему халос. Воқеан STL-таъминоти 
 барномавии аз ҳама васеъ дар забони С++ ба ҳисоб меравад. Аз ин рӯ, лозим
 донистем, ки дар ин китоб танҳо як қисмати ниҳоят хурди ин библиотекро 
 мавриди баррасӣ қарор дода, қисмати дигарашро ҳавола бар хонанда созем. 
 Тавре ки қайд намудем, STL-қисмати мураккабтарин нисбат ба қисматҳои дигар
 мебошад ва агар хонандаи арҷманди мо ҳамаи маводи бобҳои гузаштаро аз худ
 карда бошад, метавонад ба осони ин бобро низ аз худ кунанд. Дар ин боб аслан
 аз қолабҳо истифода бурда мешавад. Шояд баъзе хонандагони мо суол диҳанд:
 зарурати истифодабарии қолабҳо дар чист, оё функсияҳо наметавонанд ҳамаи 
 талаботи моро қонеъ гардонанд? Барои ба ин савол ҷавоб гардонидан як мисоли
 кучакеро дида мебароем. 
 Мисоли. Функсияе нависед, ки аз ду адади додашуда калонта-ринашро 
 муайян кунад. 
 #include <iostream> 
 using namespace std; 
 int max(int a, int b) 
 { 
 return a>b?a:b; 
 } 
 int main() 
 { 
 int a, b; 
 cin>>a>>b; 
 cout<<max(a,b); 
 return; 
 } 
 Тавре ки дида мешавад, дар ин мисол функсияи max(a, b) аз ду адади 
 бутуни додашуда калонтаринашро бармегардонад. Акнун фарз мекунем, ки 
 аргументҳои мо ҳақиқӣ ё рамзӣ бошанд, дар ин сурат функсияи мазкур ба 
 хатогӣ рубарӯ мешавад, зеро он танҳо барои ададҳои бутун навишта шудаст. 
 Пас, барои он ки функсияи мо барои ҳамаи навъҳои додашуда кор кунад, зарур
 аст, ки барои ҳар як навъ онро аз сари нав нависем. Ин амал коди барномаро
 тулонӣ гардонида, суръати иҷроиши онро суст мегардонад. Илова бар ин, 
 ислоҳи хатогиҳо низ душвор мегардад. Пас, барои аз ин душворӣ раҳо шудан 
 функсияи лозимиро як маротиба бо истифода аз шаблонҳо навишта барои ҳамаи
 навъҳо истифода мебарем. Биёед мисоли -ро аз сари нав бо истифода аз 
 қолабҳо менависем: 
 #include <iostream> 
 using namespace std; 
 template <class T> 
 T max( T a, T b){ 
 return a>b?a:b; 
 } 
 int main(int argc, char* argv[]){ 
 int a, b; 
 double x, y; 
 char c, c; 
 cout<<"du adadi butun dohil kuned:\n"; 
 cin>>a>>b; 
 cout<<"max("<<a<<","<<b<<")="<<max(a,b); 
 cout<<"\ndu adadi hakiki dohil kuned:\n"; 
 cin>>x>>y; 
 cout<<"max("<<x<<","<<y<<")="<<max(x,y); 
 cout<<"\n du simbol dohil kuned:\n"; 
 cin>>c>>c; 
 cout<<"max("<<c<<","<<c<<")="<<max(c,c); 
 return; 
 } 
 Дар ин барнома функсияи max ба намуди қолаб муаррифӣ гардидааст. 
 Дар функсияи асосӣ ҳангоми даъвати ин функсия тағйирёбандаҳои навъҳои 
 гуногун ба сифати аргументи он иштирок мекунанд ва аз натиҷа дида мешавад,
 ки функсияи мазкур рӯи дилхоҳ навъи додашуда кор мекунад. 
 Назардошти умуми дар бораи библиотекаи STL 
 Элементҳои асосии STL, ки ядрои он низ номида мешаванд, иборатанд аз:
 Контейнерҳо-ин объектҳое мебошанд, ки барои объекти дигарро дар худ 
 нигоҳ доштан хизмат мекунанд. Дар STL якчанд навъи контейнерҳо мавҷуданд,
 ба монанди: векторҳо, листҳо, қаторҳои дутарафа, ва ғайра. Класси vector –
 барои кор кардан ба масивҳои пуё (динамикӣ), класси list- барои кор кардан бо
 рӯйхатҳо, класси queue –барои сохтани қаторҳои дутарафа ва ғайра хизмат 
 мекунанд. Ба ғайр аз инҳо, дар STL контейнерҳои ассотсиативӣ мавҷуданд, ки
 ҳар кадомаш қиматеро аз рӯи калиди додашуда соҳиб мешавад. Ба ин мисол 
 шуда метавонад класси map. 
 Ҳар як класси контейнер маҷмӯи функсияҳоеро истифода мекунад, ки ба 
 худаш хосанд. Масалан, контейнери list функсияҳоеро барои гузоштан, нест 
 кардан, якҷоя кардан ва ғайра истифода мекунад. 
 Алгоритмҳо-барои ба контейнерҳо бахшидани қимати аввала, мураттаб 
 намудани элементҳои контейнер, ҷустуҷӯ намудани элементе аз дохили 
 контейнер, иваз намудани ягон элементи контейнер ва ғайра истифода 
 истифода бурда мешаванд. 
 Итераторҳо –объектҳое мебошанд, ки ба монанди ишорагарҳо амал 
 мекунанд. Онҳо бо ёрии калимаи калидии iterator дар контейнерҳои гуногун 
 муаррифӣ карда мешаванд. Вазифаи асосии итераторҳо барои суроғаи 
 контейнерҳоро дар худ нигоҳ доштан мебошад. 
 Дар STL на танҳо контейнерҳо, алгоритмҳо ва итераторҳо мавҷуданд, 
 балки компонентҳои стандартии дигаре низ мавҷуданд, ки баъдтар мавриди 
 баҳс қарор мегиранд. 
 Ҳар як контейнер ба худ ҷудокунии ҳофиза (allonameor )-ро дорад. 
 Ҷудокунии ҳофиза –ин ҳофизаи барои контейнер ҷудошударо идора (control) 
 мекунад. Ҷудокунии стандартӣ -ин объекти класси allonameor мебошад ва дар
 вақти зарурӣ метавон аз ҷудокунии махсус низ истифода кард. 
 Якчандто аз контейнерҳо ва алгоритмҳо навъи махсусеро, ки передикат 
 (prediname) ном дорад, истифода мебаранд. Аслан ду намуди предикатҳо вуҷуд
 дорад ягона ва дугона. Передикатҳои ягона дорои як аргумент буда, тавассути
 калимаи калидии UnPred муаррифӣ карда мешаванд. Передикатҳои дугона 
 бошанд, дорои ду аргумент буда, тавассути калимаи калидии BinPred муаррифӣ
 карда мешаванд. 
 Илова бар ин, class-ҳои гуногуни STL бо пайваст кардани библиотекҳои
 стандартии С++ ба кор медароянд. Ин библиотекаҳо <utility> ва <functional>
 мебошанд. Дар библиотекаи <utility> шаблони класси pair муаррифӣ карда 
 шудааст, ки он ҷуфти қиматҳоро, ки калид ва қимат ном доранд, дар худ нигоҳ
 медоранд. Дар библиотекаи <functional> бошад, қолабҳое муаррифӣ шудаанд, 
 ки барои сохтани объектҳое, ки онҳоро функсияи operator() муайян мекунад,
 истифода бурда мешаванд. Ин объектҳо объектҳои функсионалӣ номида шуда, 
 дар алгортимҳо ба сифати ишорагар истифода карда мешаванд. 
 Объектҳои функсионалӣ 
 Объектҳои функсионалӣ классе мебошанд, ки дар он амали даъвати 
 функсия муайян карда шудааст. Одатан ин хел объектҳо ба сифати параметри 
 алгоритмҳои стандартӣ истифода бурда мешаванд. Тавассути ин объектҳо 
 истифодабаранда метавонад, барои муқоисаи обектҳо ва коркарди онҳо меъёре
 (критерияе) эҷод кунад. 
 Барои он алгоритмҳое, ки объектҳои функсионалӣ истифода бурда 
 мешаванд, метавон ишорагар ба функсияро низ истифода кард. Истифодаи 
 обектҳои функсионалӣ назар ба ишорагари функсия пуртаъсиртар мебошад, 
 зеро оператори () метавонад, ҳамчун оператори дохилӣ муаррифӣ гардад. 
 Обектҳои функсионалӣ дар библиотекаи <functional> ҷойгир мебошанд. 
 Аз байни ин объектҳо, метавон он объектҳое, ки қимати мантиқӣ 
 бармегардонанд, предикат номида мешаванд. Функсияҳои оддие, ки қимати 
 мантиқӣ бармегардонанд, низ предикат мебошанд. 
 Дар STL қолабҳои унарӣ ва бинарии объектҳои функсионалӣ муайян 
 гардидааст. 
 template <class Arg, class Result> 
 struct unary_function{ 
 typedef Arg argument type; 
 typedef Result result_type; 
 }; 
 template <class Arg, class Arg, class Result> 
 struct binary_function{ 
 typedef Arg first_argument_type; 
 typedef Arg second_argument_type; 
 typedef Result result_type; 
 } 
 Объектҳои функсионалии STL зодаи ин функсия-объектҳои базавӣ 
 мебошанд. Онҳо одатан якҷоя бо адаптерҳо ва дигар воситаҳои забон истифода
 бурда мешаванд. 
 Дар STL якчанд навъи адаптерҳо мавҷуданд: 
  Пайвасткунандаҳо-барои истифодабарии объектҳои функсиона-лии 
 дуаргумента ҳамчун объекти якаргумента; 
  Инкоркунандаҳо -барои ивазкунии қимати предикат; 
  Адаптерҳои ишорагар ба функсия; 
  Адаптерҳои методӣ - барои истифодабарии методҳо дар алгоритмҳо. 
 Объектҳои функсионалии арифметикӣ 
 Дар STL қолабҳои объектҳои функсионалӣ, барои ҳамаи операторҳои 
 арифметикӣ, муайян гардидааст. 
 Ном Навъ натиҷа 
 бинарӣ x+y 
 бинарӣ x-y 
 бинарӣ x*y 
 бинарӣ x/y 
 бинарӣ x%y 
 унарӣ -x 
 Дар поён қолаби объе кт и p l us оварда шудааст. (Объектҳои дигар низ ба он
 монанд мебошанд.) 
 template <class T> struct plus: binary_fuction<T,T,T>{ 
 T operator () (const T& x, const t& y) const{ 
 return x+y; 
 } 
 }; 
 Аз сабаби оне ки объектҳои функсионалӣ якҷоя бо алгоритмҳо истифода 
 бурда мешаванд, мисоли онҳоро ҳангоми омӯхтани алгоритмҳо дида мебароем. 
 Предикатҳо 
 Дар STL қолабҳои объектҳои функсионалӣ барои муқоиса ва иҷрои 
 амалҳои мантиқӣ муайян гардидаанд, ки қимати мантиқӣ бармегардонанд, яъне
 онҳо предикат мебошанд. 
 Ном Навъ Натиҷа 
 equal_to бинарӣ x==y 
 not_equal_to бинарӣ x!=y 
 Greater бинарӣ x>y 
 Less бинарӣ x<y 
 greater_equal бинарӣ x>=y 
 less_equal бинарӣ x<=y 
 logical_end бинарӣ x&&y 
 logical_or бинарӣ x||y 
 logical_not унарӣ!x 
 Дар поён қолаби объекти equal_to оварда шудааст. Объектҳои дигар бо он
 монанд мебошанд. 
 template <class T> struct equal_to: 
 binary_function<T, T, bool>{ 
 bool operator()(const T& x, const T& y) const{ 
 return x==y; 
 } 
 }; 
 Илова бар ин барномасоз метавонад, барои худ предикат нависад. Ин 
 амал он вақт лозим мешавад, ки агар элементҳои контейнер аз навъи 
 истифодабаранда иборат бошанд. Мисол: 
 struct my_struct: 
 public bimary_function<myst, myst, bool>{ 
 bool operator () (myst& ms, myst& ms){ 
 return m.get_ myst ()<m.get_ myst (); 
 } 
 }; 
 Инкоркунандаҳо 
 Инкоркунандаҳои not ва not барои ба даст овардани инверсияи 
 предикатҳои бинарӣ ва унарӣ истифода бурда мешаванд. Истифодаи 
 инкоркунандаҳо хело содда мебошад, масалан барои ба даст овардани 
 инверсияи equal_to<int>() дастури not(equal_to<int>()) кифоягӣ мекунад. Ин
 дастур бо not_equal_to<int>() баробарқувва мебошад. 
 Асосан инкоркунандаҳо барои инверсияи предикатҳои сохтаи барномасоз 
 пешбинӣ шудаанд. Барои предикатҳои STL бошад, инверсияҳои тайёр мавҷуд 
 аст. 
 Татбиқи инкоркунандаҳоро дида мебароем. Дар STL объектҳои 
 unari_negate ва binary_negate, ки мувофиқан зодаи unary_function ва 
 binary_function мебошанд, мавҷуданд. Ин классҳо ба сифати параметр 
 конструктори объектеро ки предикати навъи матлуб мебошад, қабул мекунанд.
 template <class Predicate> 
 class unary_negate: public 
 unary_function<typename Predicate:: argument_type, bool>{ 
 public: 
 explicit unary_negate(const Pradicate &pred); 
 bool operator() 
 (const typename Pradicate::argument_type &x)const; 
 }; 
 Амалгари () инверсияи предикати not ва not-ро ҳамчун шаблони 
 функсия бармегардонад. Чунин функсия предикат қабул карда, объекти 
 функсионалӣ бармегардонад. 
 template <class Predicate> 
 unary_negate<Predicate not(const Predicate &pred); 
 template <class Predicate> 
 binary_negate<Predicate not(const Predicate &pred); 
 Пайвасткунандаҳо 
 Бо ёрии предикатҳои бинарӣ метавон, ду объектҳои гуногунро муқоиса 
 кард. Баъзан зарурати муқоисаи объект бо доимӣ пеш меояд. Ҳангоми 
 истифодаи предикатҳо, барои ин мақсад, лозим меояд, ки аргументҳои он бо 
 доимӣ пайваст карда шаванд. Барои иҷрои ин амал аз пайвасткунандаҳои 
 bindnd ва bindst истифода бурда мешавад. Ин пайвасткунандаҳо, мувофиқан,
 барои ба қимати аниқе пайваст кардани аргументи дуввум ва якуми функсияи 
 бинарӣ истифода бурда мешаванд. 
 Пайвасткунандаҳо дар STL ҳамчун қолаби функсия истифода бурда 
 мешаванд, ки ба сифати аргументи аввала, объекти функсионалии дорои ду 
 аргументро қабул карда, ба сифати аргументи дуввум бошад, алоқакунандаи 
 қимати value-ро истифода мекунанд. 
 Барои муайян кардани навъе, ки объекти функсионалӣ бармегардонад, 
 дар STL қолаби классҳои bindernd ва binderst тавзеҳ дода шудааст. Қолаби ин
 пайвасткунандаҳо шакли зеринро дорад: 
 template <class Op, class T> 
 bindernd<op> bindernd(const Op &op, const T &x) 
 template <class Op, class T> 
 binderst<op> binderst(const Op &op, const T &x) 
 дар инҷо Op-навъи объекти функсионалӣ буда, T бошад, навъи алоқакунандаи 
 қимат мебошад. 
 Мисол. Ҳисоб намудани миқдори элементҳои ба баробари массив. 
 #include <iostream> 
 #include <functional.h> 
 #include <algorithm.h> 
 using namespace std; 
 int main() 
 { 
 int x[]={,,,,,,,,, }; 
 cout<<count_if(x,x+,bindst(equal_to<int>(),)); 
 return; 
 } 
 Дар инҷо барои ҳисоб намудани миқдори элементҳо аз алгоритми 
 count_if() истифода бурда шудааст, ки дар оянда дар ин бора тавзеҳ хоҳем дод.
 Ду аргументҳо аввалаи ин алгоритм итератор буда, мувофиқан аввал ва охири
 пайдарпайиро нишон медиҳанд. Аргументи сеюми бошад, функсияи бинари 
 буда, шарти додашудаи x==y, яъне x=-ро месанҷад. 
 Адаптерҳои ишорагар ба функсия 
 Барои пайваст кардани ишорагарҳои оддиро ба функсия, аз табдилдиҳии 
 махсус ва ё адаптерҳо истифода бурда мешавад. Дар STL ду объекти 
 функсионалӣ: ишорагар ба функсияи унарӣ pointer_to_unary_function ва 
 ишорагар ба функсияи бинарӣ pointer_to_binary_function ва инчунин ду 
 функсия-адаптер ptr_fun бо як ва ду аргумент муаррифӣ гардидаанд. Ин 
 функсия-адаптерҳо ишорагар ба функсияи ба сифати аргументашон 
 фиристодашударо ба объекти функсионалӣ табдил медиҳанд. 
 template <class Arg, class Result> 
 class pointer_to_unary_function:public unary_function<Arg, Result>{
 public: 
 explicit pointer_to_unary_function(Result (*f) (Arg)); 
 Result operator () (Arg x) const; 
 }; 
 template <class Arg, class Result> 
 pointer_to_unary_function <Arg, Result> 
 ptr_func(Result (*f) (Arg)); 
 result operator () (Arg x) const; 
 template <class Arg, class Arg, class Result> 
 class pointer_to_binary_function:public 
 binary_function<Arg, Arg, Result>{ 
 Public: 
 explicit pointer_to_binary_function(Result (*f) (Arg, Arg)); 
 Result operator () (Arg x, Arg y) const; 
 }; 
 template <class Arg, class Arg, class Result> 
 pointer_to_binary_function<Arg, Arg, Result>{ 
 ptr_fun(Result (*f) (Arg, Arg)); 
 Мисол. Истифодаи адаптери функсия. 
 #include <iostream> 
 #include <functional.h> 
 #include <algorithm.h> 
 using namespace std; 
 struct MyStruct{ 
 int a, b; 
 }; 
 bool lss( MyStruct x, MyStruct y){ 
 return x.a==y.a; 
 } 
 int main() 
 { 
 MyStruct x[]={{,},{,},{,},{,},{,},{,}, 
 {,},{,},{,}, {,}}; 
 MyStruct el={,}; 
 cout<<count_if(x,x+,bindnd(ptr_fun(lss),el)); 
 return; 
 } 
 Алгоритми стандартии count_if миқдори элементҳое ро, ки шарти 
 аргументи сеюмро қаноат мекунанд, ҳисоб менамояд. Ин параметр объекти 
 функсионалӣ буда, онро алоқакунандаи bindnd бо ёрии адаптери ptr_fun аз 
 функсияи lss ба даст овардааст. Натиҷаи барнома ба баробар мебошад. 
 Адаптери методҳо 
 Ҳангоми дар контейнер нигоҳ доштани объектҳои класси 
 истифодабаранда, баъзан зарурати татбиқи як методи класс ба ҳамаи 
 элементҳои контейнер пеш меояд. Барои аз назар гузаронидани элементҳои 
 контейнер, дар библиотекаи стандартӣ алгоритми for_each мавҷуд аст. Ба 
 сифати аргументи алгоритми мазкур, ишорагари функсия равон карда мешавад.
 Ишорагари равонкардашуда, барои ҳамаи элементҳои контейнер алоҳида- 
 алоҳида даъват карда мешавад. 
 #include <iostream> 
 #include <functional> 
 #include <algorithm> 
 using namespace std; 
 void print(int x){ 
 cout<<x<<" "<<endl; 
 } 
 int main(int argc, char* argv[]){ 
 int x[]={,,,,,,,,, }; 
 for_each(x,x+, print); 
 return; 
 } 
 Адаптери методҳо, ба сифати аргументи алгоритмҳои стандартӣ 
 имконияти истифодаи методҳоро фароҳам меоранд. Монанди пайвасткунандаҳо 
 ва инкоркунандаҳо онҳо низ функсияеро ба даст оварда аз он функсияи дигарро
 месозанд. Дар STL якчандто адаптерҳо, бо миқдори гуногуни аргументҳо, 
 барои методҳо муайян гардидаанд. Дар ҷадвали зерин ин адаптерҳо гирд оварда
 шудаанд. 
 Ном Навъи объект Маъно ва мафҳум 
 mem_fun mem_fun_t Методи беаргументро тавасути 
 ишорагар даъват мекунад. 
 mem_fun const_ mem_fun_t Методи доимии беаргументро 
 тавасути ишорагар даъват мекунад. 
 mem_fun mem_funl_t Методи унариро тавассути 
 ишорагар даъват мекунад. 
 mem_fun_ref mem_fun_ref_t Методи беаргументро тавасути 
 нишонагар даъват мекунад. 
 mem_fun_ref const_mem_fun_ref_t Методи беаргументи доимиро 
 тавасcути нишонагар даъват 
 мекунад. 
 mem_fun_ref mem_funl_ref_t Методи унариро тавассути 
 нишонагар даъват мекунад. 
 mem_fun_ref const_mem_funl_ref_t Методи унарии доимиро тавассути 
 нишонагар даъват мекунад. 
 mem_fun_ref const_ mem_funl_t Методи унарии доимиро тавассути 
 ишорагар даъват мекунад. 
 Контейнерҳои class-ҳо 
 Тавре ки дар гузашта қайд намудем, контейнерҳо объектҳои STL буда, 
 барои нигоҳ доштани додаҳо дар худ истифода бурда меша-ванд. Дар ҷадвали 
 зерин якчандто аз контейнерҳо гирд оварда шудаанд. 
 № Контейнер Маъно ва мафҳум Библиотека 
 bitset Маҷмӯи бити <bitset> 
 deque Дек (қаторрҳои дусамта) <deque> 
 list Рӯйхатҳо <list> 
 map Тасвирҳо <map> 
 multimap Тасвирҳои васеъкардашуда <map> 
 multiset Маҷмӯҳои васеъ кардашуда <set> 
 queue Навбатҳо <queue> 
 set Маҷмӯҳо <set> 
 vector Кор бо векторҳо <vector> 
 Аз сабаби он ки номи навъ дар муррификунии шаблонҳои class тавассути
 typedef-и типҳо муайян мегардад. Дар ҷадвали зерин як-чандто аз typedef-ҳои
 машҳур барои намуна оварда шудаанд. 
 № Typedef Маъно ва мафҳум 
 size_type Навъи бутун ба size_t монанд мебошад. 
 reference Нишона ба элемент 
 const_reference Нишонаи доими ба элемент 
 iterator Итератор 
 const_iterator Итераторҳои доимӣ 
 reverse_iterator Итераторҳои реверсӣ 
 const_reverse_iterator Итераторҳои реверсии доими 
 value_type Навъи қимате, ки дар контейнер нигоҳ 
 дошта мешавад 
 allonameor_type Навъи тақсимшуда 
 key_type Навъи калид 
 key_compare Навъи функсияе, ки ду калидро муқоиса 
 мекунад 
 mapped_type Навъи қимате, ки дар тасвирҳо сабт 
 мешавад 
 value_compare Навъи функсияе, ки ду қиматро муқоиса 
 мекунад 
 Векторҳо 
 Яке аз контейнерҳое, ки нисбатан истифодаи васеътар доранд, ин 
 векторҳо мебошанд. Класси вектор, тавре ки қаблан қайд карда будем, барои
 кор кардан бо массивҳои пӯё пешбинӣ шудааст. Массиви динамикӣ массивест, 
 ки андозаи онро метавонем дар ҳолатҳои лозими зиёд ё кам кунем. Андозаи 
 массивҳои муқаррарӣ ё статикӣ як адади доимӣ буда, пас аз тарҷума (compile)
 шудани барнома наметавонистем, ки андозаи онро тағйир диҳем. Ҳалли ин 
 масъала дар забони С++ бо ду усул пешбинӣ шудааст, яке аз ин усулҳо 
 истифода аз ишорагар ба номи массив буд. Усули дигар, ки нисбатан васеътар
 аст, векторҳо мебошанд. Наҳви умумии муаррификунии объектҳои класси 
 vector ба сурати зерин аст: 
 Template <class T, class Allonameor=Allonameor<T>> 
 Дар ин ҷо Т тип ё навъест, ки додаҳо бо он навъ дар ҳофиза захира карда
 мешаванд. Allonameor бошад, барои додаҳо ҳофизаеро ҷудо ё муайян мекунад.
 Класси вектор дорои конструкторҳои стандартии зерин мебошад: 
 )explicit vector (const allonameor &a=Allonameor()); 
 )explicit vector (size_type num, const T &Val=T(), const_Allonameor 
 &A=allonameor ()); 
 )vector (const vector <T, Allonameor> &ob); 
 )template <class InIter> vector (InIter start, InIter end, const allonameor
 &a=Allonameor()); 
 Конструктори якум барои сохтани вектори холӣ пешбини шудааст. 
 Конструктори дуюм бошад, барои сохтани векторе, ки дорои num элемент буда,
 ҳар элементи он дорои қимати val мебошад, пешбинӣ шудааст. Конструктори 
 сеюм наҳви сохтани вектореро ифода мекунад, ки элементҳои он аз вектори ab
 гирифта мешаванд. Конструктори охирон бошад, барои сохтани векторе, ки 
 элементҳои он дар фосилаи аз start то end мехобанд, истифода бурда мешавад.
 Ҳоло тарзи муаррифӣ намудани як чанд векторро меорем. 
 ) vector <double> dv; //сохтани вектор аз ҳақиқӣ бутун бо андозаи 
 ) vector <int> iv; //сохтани вектори холӣ аз навъи бутун 
 ) vector <char> chrv; //сохтани вектори холӣ аз навъи символӣ 
 ) vector <char> chrv(,’a’); // сохтани вектор бо қимати аввалаи панҷто а
 ) vector <int> ivt(iv); //сохтани вектор дар асоси вектори мавҷудбуда 
 Барои объектҳои класси вектор операторҳои муқоисакунии зе-рин 
 муайян карда шудаанд. 
 ==, <, <=, >, >=,!, 
 Ба ғайр аз ин, барои класси вектор оператори “[]” муайян гардидааст, ки
 он барои дастрас шудан ба элементҳои вектор пешбинӣ шудааст. Илова бар ин,
 дар класси вектор функсияҳои зиёде муаррифӣ шудаанд, ки барои кор кардан 
 бо векторҳо хизмат мекунанд. Барои ба ин функсияҳо дастрас шудан, яъне 
 истифода кардан аз векторҳо бояд, ки библиотекаи <vector.h> ба барнома 
 пайваст карда шавад. Дар ҷадвали зерин якчандто аз ин функсияҳои кор бо 
 векторҳо оварда шудаанд. 
 № Функсия (Функция -член) Маъно ва мафҳум 
 template <class InIter> void Пайдарпаие, ки дар фосилаи аз start то
 assign (InIter Start, inIter end) end муайяншударо дар вектор 
 мегузорад. 
 void assign (size_type num, Дар вектор num-то элемент бо қимати 
 const T &val) дар параметри val нишондодашуда 
 мегузорад 
 reference at (size_type i); Нишонагар ба элементе, ки дар 
 const_reference at (size_type i) параметри I нишон дода шудааст, 
 const; бармегардонад. 
 reference back(); Суроғаи элементи охирони векторрро 
 const_reference back() const; бармегардонад. 
 iterator begin(); Барои элементи якуми вектор 
 const_iterator begin() const; итератор бармегардонад. 
 size_type capacity() const; Андозаи ҷории векторро 
 бармегардонад 
 void clear(); Ҳамаи элементҳои векторро нест 
 мекунад. 
 bool empty() const; Агар вектор элемент надошта бошад, 
 қимати ҳақ бармегардо-над. 
 iterator end(); Барои элементи охирони вектор 
 const_iterator end() const; итератор бармегардонад. 
 iterator erase (Iterator start, Элементҳое, ки дар фосилаи аз start то
 iterator end); end нишон дода шудаанд аз вектор 
 нест мекунад. 
 reference front(); Барои элементи якум дар вектор 
 const reference front() const; нишонагар бармегардонад 
 allonameor_type get allonameor Ҳофизаи барои вектор ҷудо-шударо 
 () const; бармегардонад. 
 iterator insert (Iterator I, const T Пеш аз элементе, ки дар параметри I
 & val=T()); нишон дода шуда–аст, қимати val-ро 
 мегузорад. 
 Template <class InIter> Пеш аз элементе, ки дар пара-метри I 
 void insert (Iterator I, InIter start, нишон дода шудааст, пайдарпайии
 InIter end); элементҳои аз start то end –ро 
 мегузорад. 
 size_type max_size() const Барои муайян намудани эле-менти 
 максималии вектор хизмат мекунад. 
 void pop_ back() Элементи охирони векторро нест 
 мекунад. 
 void pop _back(const T &val) Элементе, ки дар параметри val нишон 
 дода шудааст, дар охири вектор 
 мегузорад. 
 reference Iterator rbegin(); Итератори реверсивӣ ба охири вектор 
 const reference_iterator rbegin () бармегардонад. 
 const 
 void resize (size_type num) Андозаи векторро баробари num 
 мекунад. 
 void resize (size_type num T Андозаи векторро баробари num 
 val=T()) мекунад.. Агар вектор аз num камтар 
 элемент дошта бошад, пас элементе, 
 ки дар параметри val нишон дода 
 шудааст, дар охири вектор ҷойгир 
 карда мешавад. 
 size_type size() const; Миқдори ҷории векторро барме- 
 гардонад. 
 void Элементҳои вектори даъват-шударо ба 
 swap(deque<T,Allonameor> элементҳои ob иваз мекунад. 
 &ob); 
 Тавре ки қаблан ишора карда будем, итераторҳо низ монанди ишорагарҳо
 мебошанд. Пас, функсияи begin() итератореро, ки ба аввали вектор ишора 
 мекунад, бармегардонад. Ба ҳамин монанд функсияи end () низ итератореро, ки
 ба охири вектор ишора карда шудааст, бармегардонад. 
 Функсияи push_back() қимат ё қиматҳои додашударо дар охири вектор 
 илова мекунад. Дар ин ҳолат, андозаи вектор ба таври автоматӣ тағйир меёбад.
 Бо ёрии функсияи insert() элементҳои лозимиро метавонем дар дилхоҳ ҷойи 
 вектор илова намоем ва тавассути функсияи erase () бошад, метавонем элемент ё
 элементҳои нолозимиро аз векторро нест кунем. Функсияи size() бошад, андозаи
 векторро муаян мекунад ва ба ҳамин монанд функсияҳои дигар низ амалеро 
 болои векторҳо иҷро мекунанд. Як чизро набояд фаромӯш кард, ки ҳамаи 
 функсияҳои дар ҷадвали боло овардашуда, функсия-аъзо мебошанд ва якҷоя бо
 номи вектор истифода бурда мешаванд. 
 Мисол. Тарзи муаррифӣ намудани вектор ва истифода функсияҳои size() 
 ва push_bask() оварда шудааст. 
 #include <iostream> 
 #include <functional.h> 
 #include <algorithm.h> 
 using namespace std; 
 #define n 
 int main(int argc, char* argv[]) 
 { 
 vector <int> v; 
 int i; 
 for (i=;i<=n;i+=) 
 v.push_back(i); 
 cout<<"Andozai vector="<<v.size()<<endl; 
 for (i=;i<v.size();i++) 
 cout<<v[i]<<« «; 
 cout<<endl; 
 for (i=;i<=n;i+=) 
 v.push_back(i); 
 cout<<"Andozai navi vector="<<v.size() <<endl; 
 for (i=;i<v.size();i++) 
 cout<<v[i]<<" "; 
 cout<<endl; 
 return; 
 } 
 Дар ин мисол, он тавре, ки мушоҳида мешавад, дар аввал вектори холие
 бо номи v муаррифӣ карда шуда, сипас бо он даҳ адади ҷуфт бахшида шудааст,
 дар натиҷаи ин амал андозаи вектор баробар ба мешавад. Баъдан адади
 тоқи дигар ба охири вектор илова карда мешавад ва андозаи нави вектор 
 баробар ба мешавад. Натиҷаи барнома намуди зеринро дорад: 
 Andozai vector= 
 Andozai navi vector= 
 Массивҳо ба сифати элемент дар вектор 
 Тавре ки гуфтем, вектор ин массиви навъи пуё (dynamic) мебошад. Пас,
 элементҳои он метавонанд элементҳои як массиве, ки қаблан муаррифӣ 
 шудааст, бошанд. 
 Мисол. Барномае нависед, ки дар он ба сифати элементи вектор массиве
 иштирок кунад. 
 #include <iostream> 
 #include <functional.h> 
 #include <algorithm.h> 
 using namespace std; 
 #define n 
 int main(int argc, char* argv[]) 
 { 
 vector <int> v; 
 int a[n]; 
 int i; 
 for (i=;i<n;i++) 
 a[i]=random()+; 
 for (i=;i<n;i++) 
 v.push_back(a[i]); 
 cout<<"Andozai vector="<<v.size() <<endl; 
 for (i=;i<v.size();i++) 
 cout<<v[i]<<" "; 
 cout<<endl; 
 return; 
 } 
 Тавре ки дар ин ҷо айён аст, дар аввал массиве бо номи а ки дорои n 
 элемент мебошад, муаррифӣ шудааст, сипас, элементҳои ин массив аз ададҳои
 тасодуфӣ пур карда шудаанд. Дар дохили ҳалқа элементҳои массив ба вектор 
 илова карда мешаванд. Барои элементҳом массивро ба вектор илова кардан, 
 бояд массив ва вектор аз як навъ бошанд, вагарана барнома ба хатогӣ рӯбарӯ
 мешавад. Натиҷаи барнома намуди зеринро дорад: 
 Andozai vector= 
 Дастрасшавӣ ба элементҳои вектор тавассути итераторҳо 
 Ба элементҳои вектор метавон тавассути итераторҳо низ дастрас шуд. Ин
 амалро мо дар гузашта, тавассути ишорагарҳо дида баромада будем. Яъне дар
 гузашта дида будем, ки элементҳои массив ҳам тавассути ишорагар ҳам 
 тавассути зернавис метавонанд дастраси исти-фодабаранда гарданд. Ҳоло 
 бошад, ин амалро барои векторҳо тавассути итераторҳо анҷом медиҳем. Наҳви
 муаррифӣ намудани итератор ба намуди зерин аст: 
 vector <навъи вектор>::iterator номи итератор =қимати аввалаи итератор
 Мисол. Истифодаи итераторҳо барои дастрасӣ ба элементҳои вектор. 
 #include <iostream> 
 #include <algorithm.h> 
 #define n 
 int main(int argc, char* argv[]) 
 { 
 vector <int> v; 
 int a[n]; 
 int i; 
 for (i=;i<n;i++) 
 a[i]=random()+; 
 for (i=;i<n;i++) 
 v.push_back(a[i]); 
 cout<<"Elementhoi vector bo index" <<endl; 
 for (i=;i<v.size();i++) 
 cout<<v[i]<<" "; 
 cout<<endl; 
 cout<<"Elementhoi vector bo iterator:" <<endl; 
 vector <int>::iterator vi=v.begin(); 
 while(vi!=v.end() ){ 
 cout<<*vi<<" "; 
 vi++; 
 } 
 return; 
 } 
 Ин мисол ҳамон мисоли қабли буда, танҳо дар ин ҷо итераторе ба намуди
 зерин муаррифӣ шуда аст. 
 vector <int>::iterator vi=v.begin(); 
 Ба сифати қимати аввала итератор ба аввали вектор ишора мекунад. Баъд
 дар дохили ҳалқаи такрорӣ то ба охири вектор расидан давр такрор гардида, ҳар
 дафъа як элементро ба чоп медиҳад. Вақте ки охири вектор намоён гашт, 
 барнома кори худро ба анҷом мерасонад. Дар ин ҷо begin () ва end () ишора ба
 аввал ва охири вектор мекунанд. Натиҷаи барнома намуди зеринро дорад: 
 Elementhoi vector bo index: 
 Elementhoi vector bo iterator: 
 Функсияҳои insert() ва erase () 
 Тавре ки дар мисоли пешина мушоҳида кардем, функсияи push_back() 
 барои илова намудани элемент фақат ба охири вектор истифода мешуд. Барои 
 дар дилхоҳ ҷойи вектор гузоштани элемент функсияи insert() истифода бурда
 мешавад ва барои нест кардани эле-ментҳо бошад, аз функсияи erase() истифода
 бурда мешавад. Ин функсияҳо бо итераторҳо амал мекунанд. Ба барномаи 
 зерин диққат диҳед: 
 #include <iostream> 
 #include <algorithm.h> 
 using namespace std; 
 #define n 
 int main(int argc, char* argv[]){ 
 vector <int> v; 
 int i; 
 for (i=;i<=n;i++) 
 v.push_back(i); 
 cout<<"Andozai vector="<<v.size() <<endl; 
 for (i=;i<v.size();i++) 
 cout<<v[i]<<" "; 
 cout<<endl; 
 vector <int>::iterator vi=v.begin(); 
 vi+=; 
 for (i=;i<=n; i+=) 
 v.insert(vi,,i); 
 cout<<"Andozai navi vector="<<v.size() <<endl; 
 for (i=;i<v.size();i++) 
 cout<<v[i]<<" "; 
 cout<<endl; 
 return; 
 } 
 Дар ин мисол, низ аввал ба vector ададҳои фосилаи аз то бахшида
 шуда, сипас бо номи vi итераторе муаррифӣ гардидааст. Ба сифати қимати 
 аввала ба итератори эълоншуда ибтидои вектор бахшида шудааст. 
 Дастури vi+=, онро мефаҳмонад, ки шурӯъ аз элементи даҳуми вектор 
 элемент илова карда шавад. 
 Дастури 
 for (i=;i<=n; i+=) 
 v.insert(vi,,i) 
 ба вектор аз мавқеи -ум ҳамаи ададҳои ба чор каратии фосилаи аз то -ро
 илова мекунад. Адади миқдори такроршавии ҳар як элементро мефаҳмонад. 
 Натиҷаи барнома чунин мебошад: 
 Andozai vector= 
 Andozai navi vector= 
 Функсияи erase бошад, барои аз вектор нест намудани элементҳои 
 нишондодашуда истифода бурда мешавад. Ин функсия низ бо итераторҳо кор 
 мекунад. 
 Мисол. Истифодаи функсияи erase якҷоя бо итераторҳо. 
 #include <iostream> 
 #include <algorithm.h> 
 using namespace std; 
 #define n 
 int main(int argc, char* argv[]){ 
 vector <int> v; 
 int i; 
 for (i=;i<=n;i++) 
 v.push_back(i); 
 cout<<"Andozai vector="<<v.size() <<endl; 
 for (i=;i<v.size();i++) 
 cout<<v[i]<<" "; 
 cout<<endl; 
 vector <int>::iterator vi=v.begin(); 
 vi+=; 
 v.erase(vi, vi+); 
 cout<<"Andozai navi vector="<<v.size() <<endl; 
 for (i=;i<v.size();i++) 
 cout<<v[i]<<" "; 
 cout<<endl; 
 return; 
 } 
 Ин мисол бошад, аз вектори додашуда элементҳои фосилаи аз то -ро
 нест мекунад. Дастури vector <int>::iterator vi=v.begin() итератореро бо номи
 вектор муаррифӣ намуда, ба сифати қимати аввала ба он ибтидои векторро 
 нишон медиҳад. Баъдан дастури vi+= қимати итераторро баробар ба элементи
 панҷум қарор медиҳад. Сатри v.erase(vi, vi+) бошад, аз вектори 
 нишондодашуда, -то элементро сар карда, аз мавқеи аз +-ум нест мекунад.
 Натиҷаи барнома намуди зеринро дорад: 
 Andozai vector= 
 Andozai navi vector= 
 Рӯйхатҳо 
 Дар класси векторҳо, тавре ки мушоҳида кардем, ба элементҳои вектор 
 танҳо аз як тараф метавонем, дастрасӣ дошта бо-шем. Ҳоло бошад, classе-ро
 дида мебароем, ки ба элементҳои он мета-вонем ҳам аз пеш ба охир ва ҳам аз
 охир ба аввал дастрасӣ дошта бо-шем. Ин class-ҳо класси рӯйхатҳои дусамта
 ном доранд. Наҳви шаблони умумии ин class-ҳо намуди зеринро дорад: 
 Template <class T, class Allonameor=allonameor <T>> class list> 
 Дар ин ҷо T навъи додашудае мебошад, ки class-ҳо бо он тип дар ҳофиза
 сабт карда мешаванд. Allonameor ҳофизаест, ки барои сабт шудани листҳо ҷудо
 карда мешавад. 
 Дар класси лист конструктурҳои зерин истифода бурда мешаванд: 
 allonameor()); 
 allonameor()); 
 Дар қолаби якум наҳви сохтани рӯйхати холӣ нишон дода шудааст. 
 Форма ё қолаби дуюм барои сохтани рӯйхати дорои num элемент, ки ҳар 
 элементи он ба қимати val баробар мебошанд, истифода мешаванд. Қолаби 
 сеюм барои сохтани рӯйхате, ки элементҳои он аз объекти ab гирифта шудаанд,
 пешбинӣ шудааст. Қолаби охирон бошад, барои сохтани рӯйхате, ки 
 элементҳои он дар порчаи аз start то end мехобанд, истифода мешаванд. 
 Монанди класси vector класси лист низ дорои функсия-аъзоҳои зиёде мебошад,
 ки баъзе аз онҳо дар ҷадвали зерин гирд оварда шудаанд. Функсия-аъзоҳои аз
 ҳама зиёдтар истифода мешаванд: функсия-аъзои push_front()-барои гузоштани
 элементҳо ба аввали class, push_back()- барои гузоштани аъзоҳо ба охири class,
 merge –барои якҷоя кардани ду рӯйхат ва ғайра. 
 № Функсия (Функция-член) Маъно ва мафҳум 
 template <class InIter> void Пайдарпайие, ки дар фосилаи аз start то 
 assign (InIter Start, InIter end) end муайяншударо дар вектор 
 мегузорад. 
 void assign (size_type num, Дар list num-то элемент бо қимати дар 
 const T &val) параметри val нишондодашуда 
 мегузорад 
 reference back(); Ба элементи охирони list нишонагар 
 const_reference back() const; бармегардонад. 
 iterator begin(); Барои элементи якми list итератор 
 const_iterator begin() const; бармегардонад. 
 void clear(); Ҳамаи элементҳои list -ро нест мекунад. 
 bool empty() const; Агар list элемент надошта бошад, 
 қимати ҳақ бармегардонад. 
 iterator end(); Барои элементи охирони list итератор 
 const_iterator end() const; бармегардонад. 
 iterator erase (Iterator i) Элементеро, ки дар параметри I 
 суроғааш нишон дода шудааст, аз 
 рӯйхат нест намуда, ба элементи пас аз 
 он итератор бармегардонад. 
 iterator erase (Iterator start, Элементҳое, ки дар фосилаи аз start то
 Iterator end); end нишондода шударо аз list нест 
 мекунад. 
 reference front(); Барои элементи якум дар list нишонагар 
 const reference front() const; бармегардонад 
 allonameor_type get allonameor Ҳофизаи барои list ҷудошударо бар- 
 () const; мегардонад. 
 iterator insert (Iterator I, const T Пеш аз элементе, ки дар параметри I
 & val=T()); нишон дода шудааст қимати val-ро 
 гузошта ба он итератор бармегардонад. 
 void insert (Iterator I, size_type Пеш аз элементе, ки дар параметри val
 num, const T &val) нишон дода шудааст, num нусха қимати 
 val –ро мегузорад 
 Template <class InIter> Пеш аз элементе, ки дар параметри I 
 void insert (Iterator I, InIter нишон дода шудааст, пайдарпайии 
 start, InIter end); элементҳои аз start то end –ро мегузорад. 
 size_type max_size() const Барои муайян намудани элементи 
 максималии list хизмат мекунад. 
 void merge (list <T, List-ҳои мураттабро дар намуди 
 Allonameor> &ob); мураттаб якҷоя мекунад. Дар қолаби 
 Template <class comp> дуюм бошад, бояд нишон дода шавад, ки 
 void merge (List аз рӯи кадом қоида бояд листҳо 
 <T,Allonameor> &ob, comp мураттаб карда шаванд. 
 cmpfn); 
 void pop_ back() Элементи охирони list-ро нест меку-над. 
 void pop_front() Элементҳои додашударо дар аввали лист 
 менависад. 
 void push _back(const T &val) Элементе, ки дар параметри val нишон 
 дода шудааст, дар охири list мегузорад. 
 void push_front(const T val) Элементе, ки дар параметри val нишон 
 дода шудааст, дар аввали list мегузорад. 
 reverse Iterator rbegin(); Итератори реверсивиро ба охири list 
 const rereverse_iterator rbegin бармегардонад. 
 () const 
 reverse Iterator rend(); Итератори реверсиви ба аввали list 
 const rereverse_iterator rend () бармегардонад. 
 const 
 void remove (const T,&val) Аз list элементеро ба қимати val нест 
 мекунад. 
 Template <class unPred> Элементеро, ки дар он передикати унари 
 void remove_if(unPred pr); дорои қимати true аст, аз list нест 
 мекунад. 
 void resize (size_type num, T Андозаи list-ро баробар ба қимати num 
 val=T()); қарор медиҳад. Агар list барои зарурати 
 васеъ шудан эҳтиёҷ дошта бошад, пас, 
 дар охири он элементҳои ба қимати val 
 баробар илова карда мешавад. 
 void resize (size_type num T Андозаи list-ро num мекунад. Агар list аз
 val=T()) num камтар элемент дошта бошад, пас, 
 элементе, ки дар параметри val нишон 
 дода шудааст, дар охири list ҷойгир 
 мекунад. 
 size_type size() const; Миқдори ҷории list-ро бармегардонад. 
 void start (); Фармони якум барои мураттаб намудани 
 template <class comp> элементҳои list истифода бурда 
 void sort(comp cmpfn) мешавад, фармони дуввум бошад, 
 рӯйхатеро тавассути функ-сияи cmpfn 
 мураттаб мекунад. Дар ин сурат бояд 
 машаххас карда шавад, ки элементҳо аз 
 рӯи кадом қонуният бояд мураттаб 
 гарданд. 
 void splice(iterator, list <t, Дар мавқеи i-уми list-и даъватшаван-да
 allonameor > &ob); объекти ob-ро мегузорад. Баъди иҷрои 
 ин амал list холӣ мегардад. 
 void splice (iterator i, list <t, Аз list элементҳоеро, ки суроғаи онҳо
 allonameor > &ob, iterator el) дар параметри el нишон дода шудааст, 
 нест намуда, дар list-и даъватшаванда 
 дар мавқее, ки суроғаи он дар параметри 
 I нишон дода шудааст, менависад. 
 void splice( Iterator I, list <T, Аз list элементҳое, ки дар парамет-ри аз
 allonameor> &ob, Iterator start, start то end нишон дода шудаанд, нест
 Iterator end) намуда, ба рӯйхати даъватшаванда сар 
 карда, аз мавқеи i-юм менависад. 
 void swap ( Элементҳои вектори даъватшударо ба 
 deque<T,Allonameor> &ob); элементҳои ob иваз мекунад. 
 void unique (); Фармони аввал аз list элементҳоеро, ки 
 Template <class BinPred> ду маротиба омадаанд, нест мекунад. 
 void unique (BinPred pr) Фармони дуввум бошад, барои 
 мушаххас намудани он, ки предмкати pr 
 ягона аст, хизмат мекунад. 
 Мисол. Истифодаи руйхатҳо. 
 #include <iostream> 
 #include <algorithm.h> 
 #include <list.h> 
 using namespace std; 
 int main(int argc, char* argv[]){ 
 list <int> l; 
 int i; 
 for (i=; i<=;i+=) 
 l.push_back(i); 
 cout<<"Andozai list="<<l.size()<<endl; 
 cout<<"Elementhoi list:"<<endl; 
 list <int>::iterator p; 
 p=l.begin(); 
 while (p!=l.end() ){ 
 cout<<*p<<" "; 
 p++; 
 } 
 return; 
 } 
 Тавре ки дар ин ҷо дида мешавад, дар аввал List-е бо номи l муаррифӣ
 шудааст, ки дорои эгон элемент намебошад. Баъд дар дохили ҳалқа, тавассути
 функсияи push_bask() ба List элемент бах-шида шудааст. Пас аз иҷрои ин амал
 итерторе муаррифӣ гардида, элемениҳои лист-ро ба чоп медиҳад. Ба қитъаи 
 барномаи зерин нигаред: 
 list <int>::iterator p; 
 p=l.begin(); 
 while (p!=l.end() ){ 
 cout<<*p<<" "; 
 p++; 
 } 
 Дар ин қисмати барнома, итераторе ба номи p муаррифӣ карда шуда, ба 
 сифати қимати аввала ба он элементи якум ё ибтидои list бахшида шудааст. 
 Функсияи begin() ибтидои List-ро нишон медиҳад ва функсияи end() бошад, ба
 интиҳои List ишорат мекунад. Аз ин рӯ, дар дохили ҳалқа то ба интиҳои List
 расидан, ҳар маротиба як элементи List ба чоп бароварда мешавад. Натиҷаи 
 барнома намуди зеринро дорад: 
 Andozai list= 
 Elementhoi list: 
 Тавре ки ишора карда будем, ба элементҳои List метавонем аз ду тараф
 дастрасӣ дошта бошем, ҳам аз аввал ба охир ва ҳам аз охир ба аввал. Инчунин
 List ҳоро List ҳои дусамта меноманд. Мисол: 
 #include <iostream> 
 #include <algorithm.h> 
 #include <list.h> 
 using namespace std; 
 int main(int argc, char* argv[]){ 
 list <int> l; 
 list <int> l; 
 int i; 
 for (i=; i<=;i+=) 
 l.push_back(i); 
 list<int>:: iterator p; 
 cout<<"Elemenyhoi List az chap ba rost.\n"; 
 while (!l.empty() ){ 
 p=l.begin(); 
 cout<<*p<<« «; 
 l.push_front(*p); 
 l.pop_front(); 
 } 
 cout<<"Elemenyhoi List az rost ba chap.\n"; 
 p=l.begin(); 
 while (p!=l.end() ){ 
 cout<<*p<<" "; 
 p++; 
 } 
 return; 
 } 
 Натиҷаи барнома намуди зеринро дорад: 
 Elemenyhoi List az chap ba rost. 
 Elemenyhoi List az rost ba chap 
 Мураттабкунии руйхатҳо 
 Элементҳои List-ҳо тавассути функсияи sort мураттаб карда мешаванд. 
 Дар мисоли зерин тарзи истифодаи ин функсия оварда шудааст. Мисол: 
 #include <iostream> 
 #include <algorithm.h> 
 #include <list.h> 
 int main(int argc, char* argv[]){ 
 list <int> l; 
 int i; 
 for (i=; i<=;i++) 
 l.push_back(random()+); 
 cout<<"Andozai list="<<l.size()<<endl<<endl; 
 cout<<"Elementhoi list pesh az murattabkuni:"<<endl; 
 list <int>::iterator p; 
 p=l.begin(); 
 while (p!=l.end() ){ 
 cout<<*p<<" "; 
 p++; 
 } 
 cout<<endl<<endl; 
 cout<<"Elementhoi list pas az murattabkuni:"<<endl; 
 l.sort(); 
 p=l.begin(); 
 while (p!=l.end() ){ 
 cout<<*p<<" "; 
 p++; 
 } 
 return; 
 } 
 Ин мисол низ монанди мисоли буда, фарқияташ дар он аст, ки дар ин 
 мисол элементҳои List ба таври тасодуфӣ интихоб карда шудаанд ва тавассути
 функсияи sort() мураттаб карда шудаанд. Дар ин мисол, аввал элементҳои List
 бароварда шудаанд, ки пас аз даъвати функсияи sort() бори дигар ба чоп дода
 шудаанд. Пас аз даъвати функсияи sort элементҳои List дар ҳама ҷои барнома,
 пас аз мавқеи даъватшавии функсия мураттаб мебошанд. Натиҷаи барнома 
 чунин аст: 
 Andozai list= 
 Elementhoi list pesh az murattabkuni: 
 Elementhoi list pas az murattabkuni: 
 List-ҳо аз массив 
 Ба сифати элемент ба List-ҳо метавонанд, массивҳо низ иштирок кунанд.
 Ҳоло исботи ин гуфтаро дар мисоли зерин дида мебароем Мисол: 
 #include <iostream> 
 #include <algorithm.h> 
 #include <list.h> 
 using namespace std; 
 #define n 
 int main(int argc, char* argv[]){ 
 int arr[n]; 
 list <int> l; 
 int i; 
 for (i=; i<n;i++) 
 arr[i]=(rand()%); 
 for (i=; i<n;i++) 
 l.push_back(random(arr[i])); 
 cout<<"Andozai list="<<l.size()<<endl; 
 cout<<"Elementhoi list:"<<endl; 
 list <int>::iterator p; 
 p=l.begin(); 
 while (p!=l.end() ){ 
 cout<<*p<<" "; 
 p++; 
 } 
 return; 
 } 
 Тавре ки мебинем, дар ин ҷо массиве ба номи arr муаррифӣ гардида, ба
 ададҳои тасодуфӣ пур карда шудааст. Дар дохили ҳалқаи такрорӣ элементҳои 
 массив ба List бахшида шудаанд. Натиҷаи барнома намуди зеринро дорад: 
 Andozai list= 
 Elementhoi list: 
 Якҷоя кардани ду List 
 Метавонем ду List-ро, ки аз як навъ мебошанд, якҷоя кунем, барои ин 
 функсияи merge истифода бурда мешавад. Пас аз даъвати ин функсия 
 элементҳои ду List-и якҷо карда шуда, мураттаб намоиш дода мешаванд. 
 Мисол: 
 #include <iostream> 
 #include <algorithm.h> 
 #include <list.h> 
 using namespace std; 
 #define n 
 int main(int argc, char* argv[]){ 
 int arr[n]; 
 list <int> l; 
 list <int> l; 
 int i; 
 for (i=; i<n;i++) 
 l.push_back(*i); 
 for (i=; i<n;i++) 
 l.push_back(*i+); 
 cout<<"Andozai list="<<l.size()<<endl<<endl; 
 cout<<"Elementhoi list:"<<endl<<endl; 
 list <int>::iterator p; 
 p=l.begin(); 
 while (p!=l.end() ) 
 { 
 cout<<*p<<" "; 
 p++; 
 } 
 cout<<endl; 
 p=l.begin(); 
 while (p!=l.end() ) 
 { 
 cout<<*p<<" "; 
 p++; 
 } 
 cout<<endl<<endl; 
 l.merge(l); 
 if (l.empty() ) 
 cout<<"list holi shud!"<<endl; 
 p=l.begin(); 
 while (p!=l.end() ){ 
 cout<<*p<<" "; 
 p++; 
 } 
 return; 
 } 
 Дар ин мисол тавре ки мушоҳида мегардад, ду List муаррифӣ гардидаанд.
 Барои List-и якум ба сифати элемент, ададҳои ҷуфт ва ба List-и дуввум, ададҳои
 тоқи фосилаи аз то бахшида шудаанд. Дар аввал элементҳои ин List-ҳо ба
 чоп бароварда мешаванд. Сипас, функсияи merge даъват карда мешавад. 
 Функсияи мазкур List-и дуввумро дар листи якум нусхабардорӣ мекунад. Ҳар 
 гоҳ, ки List-и дуввум аз элемент холӣ шавад, пайғоми муносибе чоп карда 
 мешавад. Натиҷаи барнома List-и дуввум дар якум нусхабардорӣ карда 
 мешавад. Дар ҳангоми нусхабардорӣ инчунин мураттаб низ карда мешавад. 
 Натиҷаи барнома намуди зеринро дорад: 
 Andozai list= 
 Elementhoi list: 
 list holi shud! 
 Тасвирҳо (Таҷассумҳо) 
 Дар библиотекаи map иттиҳоди контейнерҳо мавҷуданд, ки ҳар кадоми 
 онҳо дорои калид ва қимат мебошанд. Калид ин номи муқаррарии элемент буда,
 тавассути он метавон ба қимати он дастрас шуд. Тасвирҳо монанд ба фарҳанги
 луғат мебошанд, яъне бо донистани калима метавонем маънои онро низ ба даст
 оварем. Мисоли дигар калид ин номи одам ва қимат маълумотҳои ҳамон одам 
 мебошанд, ки донистани номи муштари метавонем аз пойгоҳи додаҳои телефон 
 дигар маълумотҳои муштариро ба даст оварем. Дар барноманависӣ тасвирҳо 
 нисбатан маъмултар буда, истифодаи зиёдтар доранд. Калидҳо бояд, ки ягона
 бошанд, дар сурати такрор шудани калид ба кори барнома халал ворид мешавад.
 Аз ин рӯ, роҳи дигареро пеш мегирем, барои калидҳое, ки такроран меоянд, аз
 қолаби multimap истифода мебарем. 
 Тарзи истифодаи қолаби map шакли зеринро дорад: 
 Template <class key, class T, 
 Class comp=Less <key>, 
 Class allonameor =allonameor<pair < const key, T>>> class 
 map 
 Дар ин ҷо key –навъи додаҳои калид, T навъеро ифода мекунад, ки 
 тасвирҳо бо он ном сабт мешаванд. Comp –функсияе мебошад, ки ду калидро 
 муқоиса мекунад. Ба таври пешфарз ба ҷои параметри comp функсияи Less 
 истифода бурда мешавад. Параметри allonameor бошад ҳофизаеро барои 
 тасвирҳо ҷудо ё мушаххас мекунад. 
 Монанди дигар class-ҳо класси map низ дорои конструкторҳои зерин 
 мебошад. 
 &a=allonameor()); 
 &cmpfn=Comp(), const Allonameor & a=Allonameor()); 
 Формаи аввал конструктор тасвири холиеро эҷод мекунад. Қо-лаби 
 дуввум барои сохтани тасвире, ки элементҳои он аз Ob гирифта шудаанд, 
 истифода бурда мешавад. Қолаби сеюм бошад, барои эҷод намудани тасвире, ки
 қиматҳои он дар фосилаи аз start то end мехобанд пешбинӣ шудааст. Параметри
 cmpfn барои муайян намудани ҳарактеристикаи мураттабкунии элементҳои 
 тасвирҳо истифода бурда мешавад. 
 Ҳамаи объектҳое, ки барои онҳо Операторҳои муқоисакунӣ истифода 
 бурда мешаванд, метавонанд, ба сифати калид хизмат кунанд. Амалҳои 
 муқоисакунӣ намуди зеринро доранд: 
 ==, <=, >=,!=, >, <, 
 Қолаби класси калид ва қимат “pair” намуди зеринро дорад: 
 Template <class ktype, class vtype > struct pair { 
 Typedef ktype first_type; // Навъи калид 
 Typedef vtype second_type; // Навъи қимат 
 ktype first; 
 vtype second; 
 //Конструктор 
 pair(); 
 pair (const ktype &k, const vtype &v); 
 Template <classs A, class B> pair (const <A, B> 
 &ob); 
 } 
 Дар ин қолаб калимаи first нишондиҳандаи калид ва калимаи second 
 бошад, нишондиҳандаи қимат мебошад. Ва чи хеле, ки айён аст, ҷуфти калид ва
 қимат дар дохили як сохтор иҷро мегардад. 
 Илова бар ин, ҷуфти калид ва қиматро метавон, тавассути функсияи 
 make_pair() дар асоси навъи додаҳо сохт. Функсияи мазкур хулоса ё ҷамъбасти
 функсияҳо мебошад. Ҷуфти калид ва қимат дар қолаби функсияи make_pair() 
 намуди зеринро дорад: 
 Template <class ktype, class vtype > 
 pair <ktype, vtype> make_pair(const ktype &k, const vtype &v); 
 Мисоли. Барномае нависед, ки ба сифати калид ҳарфҳо ва ба сифати 
 қимат ASCII коди ҳарфҳоро дар худ нигоҳ дорад. Бо дохил кардани рамз коди
 онро нишон диҳад. 
 #include <iostream> 
 #include <algorithm.h> 
 #include <list.h> 
 #include <map.h> 
 #define n 
 using namespace std; 
 int main(int argc, char* argv[]){ 
 int arr[n]; 
 map <char, int> m; 
 int i; 
 for (i=; i<n;i++) 
 m.insert(pair<char, int>(i, i)); 
 char ch; 
 cout<<"Kalidro vorid kuned"<<endl<<endl; 
 cin>>ch; 
 map<char,int>::iterator p; 
 p=m.find(ch); 
 if (p!=m.end() ) 
 cout<<p->second; 
 else 
 cout<<"Chunin kalid mavjud nest!!!!!!!!"<<endl; 
 return; 
 } 
 Дар ин мисол дар аввал барои дастрас шудан ба ҷуфти калид ва қимат, 
 библиотекаи <map > пайваст карда шудааст. Баъдан дар барнома ҷуфти калид ва
 қимат, ки як аргументи он рамзӣ ва дигараш бутун мебошад, ба намуди 
 map <char, int> m 
 муаррифӣ карда шудаааст. Дар дохили ҳалқаи такрори ба ин ҷуфт рамзҳои ASC
 код ва қиматҳои он тавассути функсияи insert ба тасвир гузошта шудаанд. 
 Сипас итераторе ба номи p муаррифӣ шудааст. Ин тасвир тавассути функсияи 
 find() то замони ба охири тасвир расидан калиде, ки ворид карда шудааст, 
 ҷустуҷӯ мегардад. Агар калид пайдо шуд, қимати онро дар саҳифаи тасвир ба
 чоп медиҳад ва агар калид мавҷуд набошад, пайғоми муносибе ба чоп медиҳад.
 Барои дохил кардани калид тағйирёбандае аз навъи char муаррифӣ карда 
 шудааст. 
 Монанди дигар class –ҳо класси map низ дорои функсияҳои зиёде мебошад, ки
 дар ҷадвали зерин гирд оварда шудаанд. 
 № Функсия (Функция -член) Маъно ва мафҳум 
 iterator begin(); Барои элементи якуми тасвир ите- 
 const_iterator begin() const; ратор бармегардонад. 
 void clear(); Ҳамаи элементҳои тасвирро нест 
 мекунад. 
 bool empty() const; Агар тасвир элемент надошта бо-шад 
 қимати ҳақ бармегардонад. 
 iterator end(); Барои элементи охирони тасвир 
 const_iterator end() const; итератор бармегардонад. 
 viod erase (Iterator i) Элементеро, ки дар параметри I 
 суроғааш нишон дода шудааст аз 
 рӯйхат нест намуда, ба элементи пас 
 аз он итератор бармегардонад. 
 void erase (Iterator start, iterator Элементҳое, ки дар фосилаи аз start то
 end); end нишон дода шудаанд, аз тасвир 
 нест мекунад. 
 size_type count(const key_type &k) Рақами калиди воридшударо ба-рои 
 const) тасвир бармегардонад ( ё ) 
 size_type erase (const key_type Элементи тасвиреро, ки калиди он ба 
 &k) қимати k доро аст, аз тасвир нест 
 мекунад. 
 iterator find(const key_type &k) Итератор қимати калиди додашу-даро 
 const_iterator find(const key_type бармегардонад. Агар қимати калид 
 &k) const мавҷуд набошад, охири тасвирро 
 бармегардонад. 
 allonameor_type get _allonameor() Ҳофизаи барои тасвир ҷудокар- 
 const дашударо бармегардонад. 
 iterator insert (iterator i, const Дар мавқее, ки итератори I нишон 
 value_type &val) дода шудааст, қимати val-ро мегу- 
 зорад ва ба ин элемент итератор 
 бармегардонад. 
 template <class initer> void Элементҳои додашударо дар фоси-лаи 
 insert(initer start, initer end) [start; end] мегузорад. 
 pair <iterator, bool> Дар тасвири даъватшуда қимати val-ро 
 insert(const value_type & val) мегузорад ва ба он итератор 
 бармегардонад. Дар ҳамон вақт 
 метавонем элементе гузошт, ки агар 
 дар тасвир вуҷуд надошта бошад. Дар 
 ҳолати вуҷуд доштани элемент 
 қимати pair <iterator, true> ва дар 
 ҳолати вуҷуд надоштан қимати pair< 
 iterator, false> бар-гардонида мешавад. 
 key compare key_comp() const Объект_функсия қиматеро-ро бар- 
 мегардонад, ки ба калид мувофи-қат 
 кунад. 
 iterator lower_bound(const Барои элементи якуми тасвир, ки 
 key_type &k); калид барои он ба қимати к баробар 
 const_iterator lower_bound (const аст ё аз он элемент калонтар аст 
 key_type &k) const; бармегардонад. 
 size_type max_size const(); Қимати максималии элементҳое, ки 
 дар тасвир мавҷуд ҳастанд 
 бармегардонад. 
 reference operator [](const Нишонагар ба элементе, ки дар 
 key_type &i) параметри I нишон дода шудааст 
 бармегардонад. Агар чунин эле-мент 
 вуҷуд надошта бошад дар тасвир онро 
 мегузорад. 
 reverse_iterator rend(); Ба ибтидои тасвир итератори 
 const_reverse_iterator_rend() const реверсивӣ бармегардонад. 
 reverse_iterator rbegin(); Ба интиҳои тасвир итератори 
 const_reverse_iterator_rbegin() реверсивӣ бармегардонад. 
 const 
 size_type size() const; Миқдори элементҳои ҷории тас-вирро 
 бармегардонад. 
 void swap(map_key, T, comp, Барои объекти даъватшавандаро ба 
 Allonameor> &ob) объекти дар параметри ob иваз 
 намудани хизмат мекунад. 
 iterator upper_bound(const Барои элементи тасвир итератор 
 key_type &k); бармегардонад, агар қимати калид аз 
 const_iterator upper_bound(const қимати додашудаи к калон бо-шад. 
 key_type &k) const; 
 value_compare value_comp() Объект_функсия қимати муқоиса- 
 const; кардашударо бармегардонад. 
 Мисоли. Барномае нависед, ки амали ҷустуҷӯи калимаро дар дохили 
 фарҳанг (словар) ҷустуҷӯ кунад. 
 #include <iostream> 
 #include <map.h> 
 using namespace std; 
 #define n 
 typedef map <string, string> mymap; 
 typedef mymap::const_iterator iter; 
 int main(int argc, char* argv[]) 
 { 
 mymap dict; 
 dict["father"]=" padar"; 
 dict["mather"] = "modar"; 
 dict["brather"] = "barodar"; 
 dict["sister"] = "khohar"; 
 dict["grandmather"] = "modarkalon"; 
 string word; // калима барои чустучу дар дохили map 
 cout << "Enter word: "; 
 cin >> word; 
 iter i = dict.find(word); // Чустучу 
 if(i!= dict.end()) // агар калима ёфт шавад 
 cout << "Manoi kalimai"<<word << " " << i->second<<" 
 meboshad." << endl; 
 else 
 cout << "word not found!" << endl; 
 return; 
 } 
 Дар инҷо аввал typedef-и класи map ва итератор муаррифӣ гардидааст, 
 сипас дар методи асосӣ бо номи dict тасвире муаррифӣ гардидааст. Баъд аз ин
 ба тасвири муаррификардашуда қимат бахшида шудааст. Барои ҷустуҷӯи 
 калимаи воридкардашуда аз функсия-аъзои find истифода карда шудааст. 
 Мисоли. Хориҷ кардани элементҳои таҷассум. 
 #include <iostream> 
 #include <map.h> 
 using namespace std; 
 typedef map<string, string> mymap; 
 typedef mymap::const_iterator iter; 
 int main(int argc, char* argv[]) 
 { 
 mymap dict; 
 dict["father"]=" padar"; 
 dict["mather"] = "modar"; 
 dict["brather"] = "barodar"; 
 dict["sister"] = "khohar"; 
 dict["grandmather"] = "modarkalon"; 
 cout<<"Dictionar"<<endl; 
 iter i; 
 for(i=dict.begin();i!=dict.end();i++) 
 cout<<i->first<<":"<<i->second<<endl; 
 return; 
 } 
 Барои хориҷ кардани элементҳои таҷассум аз итераторҳо истифода бурда
 шудааст. 
 Мисоли. Нест кардани элементи таҷассум. 
 #include <iostream> 
 #include <algorithm.h> 
 #include <map.h> 
 using namespace std; 
 typedef map<string, string> mymap; 
 typedef mymap::const_iterator iter; 
 int main(int argc, char* argv[]){ 
 mymap dict; 
 dict["father"]=" padar"; 
 dict["mather"] = "modar"; 
 dict["brather"] = "barodar"; 
 dict["sister"] = "khohar"; 
 dict["grandmather"] = "modarkalon"; 
 cout<<"Dictionar"<<endl; 
 iter i; 
 for(i=dict.begin();i!=dict.end();i++) 
 cout<<i->first<<":"<<i->second<<endl; 
 string word; // калима барои нест кардани элементи map 
 cout << "Enter word for deleted "; 
 cin>>word; 
 if(dict.find(word)!= dict.end()) 
 dict.erase(word); 
 for(i=dict.begin();i!=dict.end();i++) 
 cout<<i->first<<":"<<i->second<<endl; 
 return; 
 } 
 Барои нест кардани элементи таҷассум аз функсия-аъзои erase истифода
 бурда шудааст. 
 Алгоритмҳо 
 Алгоритмҳои зиёди коркарди додаҳо дар контейнерҳо мавҷу-данд. Чи 
 хеле ки медонем, ҳар як контейнер амалҳои махсуси база-виро пуштибонӣ 
 мекунанд. Алгоритмҳои стандарти нисбат ба дигар контейнерҳо истифодаи 
 васеътар доранд. Барои ба объектҳои класси мазкур дастрас шудан, бояд ки 
 библиотекаи <algoritm.h> дар барнома пайваст карда шавад. Дар библиотекаи
 мазкур функсияҳои зиёде мавҷуданд, ки муҳимтаринашон дар ҷадвали зерин 
 гирд оварда шудаанд. 
 № Функсия (Функция-член) Маъно ва мафҳум 
 objecent_find() Дар пайдарпайии элементҳо, элементи 
 мавриди назарро ҷустуҷӯ мекунад ва ба 
 элементи аввала итератор бармегардонад. 
 binary_search() Дар пайдарпаии мураттаб амали ҷустуҷӯро 
 иҷро мекунад. 
 copy() Пайдарпаиеро нусхабардори меку-над. 
 copy_backword() Монанди функсияи copy буда, фарқияташ 
 дар он аст, ки он элементҳоро аз охир 
 нусхабардорӣ мекунад. 
 count() Миқдори элементҳои пайдарпаиро майян 
 мекунад. 
 count_if() Миқдори элементҳое, ки шарти 
 предикатро муайян мекунанд ҳисоб 
 мекунад. 
 equal() Якхелагии (баробарии) ду фосиларо 
 муайян мекунад. 
 equal_range() Фосилаеро бармегардонад, ки ҳангоми ба 
 он гузоштани элемент низоми мураттабии 
 пайдарпаи халалдор намешавад. 
 fill ва fill_n() Ба қимати додашуда фосилаи 
 нишондодашударо пур мекунад. 
 find() Дар фосилаи нишондодашуда қи-мати 
 додашударо ҷустуҷӯ мекунад ва итератор 
 ба элементи ҷустӯҷушаванда 
 бармегардонад. 
 find_end() Монанди find буда танҳо элементи 
 охирони ҷустуҷӯшавандаро 
 бармегардонад. 
 find_first_of() Амали ҷустуҷӯро барои элементи якум дар 
 дохили пайдарпаии додашуда иҷро 
 мекунад, ки он ба дилхоҳ элементи 
 фосилаи додашуда мувофиқат мекунад. 
 find_if() Дар фосилаи додашуда амали ҷустуҷӯиро 
 иҷро намуда, ба элементе, ки 
 истифодабаранда барои он передикати 
 ягона муайян кардаааст қимати true 
 бармегардонад. 
 for_each() Барои фосилаи нишондодашуда ин 
 функсия иҷро мегардад. 
 generate ва generate_n() Элементҳоеро, ки функсия итератор аз 
 фосилаи додашуда баргардонидааст, 
 муқоиса мекунад. 
 implace_merge() Як фосилаи додашударо ба дигараш якҷоя 
 мекунад. 
 iter_swap() Ҷои қиматҳоеро, ки итератор онҳоро ба 
 сифати аргумент баргардонидааст, иваз 
 мекунад. 
 lexiographical_compare() Як пайдарпайи додашударо бо дигараш 
 дар тартиботи лексикографӣ муқоиса 
 мекунад. 
 lower_bound() Амали ҷустуҷӯро барои элементи якум дар 
 пайдарпайии додашуда, ки он аз элементи 
 додашуда хурд намебошад, амалӣ 
 мегардонад. 
 max() Аз ду элемент калонтаринашро бар- 
 мегардонад. 
 max_element() Барои элементҳои максималӣ дар фосилаи 
 додашуда итератор бармегардонад. 
 merge() Ду пайдарпайии мураттабро якҷоя 
 мекунад. Пайдарпайии ҳосилшударо низ 
 мураттаб мекунад. 
 min() Аз ду қимати додашуда хурдтаринашро 
 бармегардонад. 
 min_element() Барои элементҳои минималӣ дар фосилаи 
 додашуда итератор бармегардонад. 
 mistach() Амали ҷустуҷӯро барои элементҳои якхела 
 набудаи ду пайдарпайи иҷро намуда, ба он 
 элементҳо итератор бармегардонад. 
 partial_sort() Элементҳои фосилаи додашударо 
 мураттаб мекунад. 
 partition() Фосилаи додашударо аз рӯи шарти зерин 
 мураттаб мекунад. Ҳамаи элементҳое, ки 
 дар передикат дода шудаанд, қимати true 
 бармегардонад ва барои элементҳое, ки 
 пеш аз предикат омадаанд, қимати false 
 бармегардонад. 
 pop_heap() Ҷои элементи якум ва якто кам аз охирони 
 пайдарпаи додашударо иваз намуда, баъд 
 онро барқарор мекунад. 
 remove(), remove_if(), Аз фосилаи додашуда элементҳоро нест 
 remove_copy() ва мекунад. 
 remove_copy_if() 
 replace(), replace_if(), Элементҳои фосилаи додашударо ба дигар 
 replace_copy() ва элементҳо иваз мекунад. 
 replace_copy_if() 
 rotate ва rotate_copy() Дар фосилаи додашуда амали лағжиши 
 давриро аз рост амалӣ мекунад. 
 reverse ва reverse_copy() Элементҳои фосилаи додашударо ба 
 бараксаш иваз мекунад. 
 search() Амали ҷустуҷӯии як пайдарпаиро дар 
 дохили дигараш иҷро мекунад. 
 searche_n() Дар дохили якчанд пайдарпайи элементи 
 монандро ҷустуҷӯмекунад. 
 set_difference() Аз фарқи ду пайдарпайи пайдарпайии нав 
 месозад. 
 set_intersection() Аз бурриши ду пайдарпаи пайдар-пайии 
 нав месозад. 
 set_symmetric_difference() Аз фарқи симметрии ду пайдарпайи 
 пайдарпаии нав месозад. 
 set_union() Аз якҷоякунии ду пайдарпайии мураттаб 
 пайдарпайии нав месозад. 
 sort() Элементҳои фосилаи додашударо 
 мураттаб мекунад. 
 sort_heap() Амали мураттабкунии Кӯчишро дар 
 фосилаи додашуда амалӣ мекунад. 
 stople_partition() Пайдарпайии додашударо аз рӯи шарти 
 зерин мураттаб мекунад: Барои ҳамаи 
 элементҳое, ки дар передикат дода 
 шудаанд, қимати true бармегардонад ва 
 барои элементҳое, ки пеш аз предикат 
 омадаанд, қимати false бармегардонад. 
 Чунин мураттабкунӣ мураттабкунии усту- 
 вор номида мешавад. 
 stable_sort() Амали мураттабкунии устуворро ба-рои 
 фосилаи додашуда амалӣ меку-над. Ин 
 мураттабкунӣ маънои онро дорад, ки 
 элементҳои якхела ба назар гирифта 
 намешаванд. 
 swap() Ҷойи ду қимати додашударо иваз мекунад. 
 swap_ranges() Амали мубодилаи элементҳоро дар 
 фосилаи додашуда иҷро мекунад. 
 transform Функсияро дар фосилаи додашуда татбиқ 
 намуда, натиҷаҳоро дар пайдарпаиии нав 
 гирд меоварад. 
 unique ва unique_copy() Дар фосилаи додашуда элементҳоеро ки 
 такроран омадаанд нест мекунад. 
 upper_bound() Аз пайдарпаии додашуда элементи 
 охиринро, ки аз элементи додашуда калон 
 намебошад ҷустуҷӯмекунад. 
 Ҳамаи алгоритмҳои забони С++ ба гурӯҳҳои зерин тақсим карда 
 мешаванд: 
 мешавад, ба монанди: 
 имконияти бо усулҳои гуногун мураттаб намудани элементҳои контейнерро 
 фароҳам меоранд. Алгоритмҳои гурӯҳи маз-кур ба элементҳои рӯйхат (List) 
 татбиқ карда намешаванд. Ба ин гурӯҳ алгоритмҳо дохил мешаванд: 
 дигаргун кардан ва ё пур намудани пайдарпаиҳо истифода мешаванд. Ба ин 
 гурӯҳ алгоритмҳои зерин дохил мешаванд: 
 нест намудани як ё як фосилаи додашудаи элементҳо истифода бурда мешаванд.
 Ба ин гурӯҳ алгоритмҳо дохил мешаванд: 
 контейнеррро ба контейнери дигар муқоиса кардан истифода бурда мешаванд. 
 Ба ин гурӯҳ алгоритмҳо дохил мешаванд: 
 ҳисобкунӣ дар контейнерҳо истифода бурда мешаванд. Алгоритмҳои мазкур 
 ҳангоми пайваст намудани библио-текаи numeric ба кор медароянд. Ба ин гурӯҳ
 алгоритмҳо дохил мешаванд: 
 Истифодаи алгоритмҳо дар амалия 
 Барои ба хонандагон фаҳмотар шудан, мисоли якчандто алгоритмро дар 
 поён меорем, алгоритмҳои боқимондаро бошад, ҳавола ба хонандагон месозем.
 Ҳангоми навиштани қолаби алгоритмҳо, аз калимаҳои кутоҳшудаи зерин 
 истифода бурда мешавад: 
 in-итератор барои хондан (inputiterator); 
 out- итератор барои навиштан (outputiterator); 
 for- итератори мавзун (мустақим) (forwarditerator); 
 bi - итератор дутарафа (bidirectionaliterator); 
 ran- итератори дастрасии тасодуфӣ (randomaccessiterator); 
 pred-предикати унарӣ (шартӣ) (predicate); 
 binpred- предикати бинарӣ; 
 comp-функсияи муқоиакунӣ (compare); 
 op-амалиёти унарӣ; 
 binop-амалиёти бинарӣ. 
 Алгоритми count ва count_if() 
 Яке аз амалҳои маъмуле, ки барои ҳамаи пайдарпаиҳо иҷро карда 
 мешавад, ин ҳисоб намудани миқдори элементҳо мебошад. Барои иҷрои ин 
 амал, алгоритмҳои count ва count_if истифода бурда мешаванд. Наҳви умумии
 алгоритмҳои мазкур намуди зеринро доранд: 
 Template <class InIter, class T> Ptrdiff_t count (InIter start, InIter end, const
 T &val); 
 Template <class InIter, class UnPred> Ptrdiff_t count_if (InIter start, InIter
 end, UnPred pfn); 
 Алгоритми count миқдори элементҳоро баробари val-ро аз фосилаи 
 додашудаи пайдарпаёӣ бармегардонад. Алгоритми count_if бошад, дар фосилаи
 додашуда миқдори элементҳоеро, ки дар онҷо предикати ягонаи pfn қимати true
 дорад, бармегардонад. Навъи Ptrdiff_t монанди навъи бутун, муайян карда 
 мешавад. Мисол: 
 #include <iostream> 
 #include <algorithm.h> 
 #include <map.h> 
 #include <ctype.h> 
 #include <vector.h> 
 using namespace std; 
 bool sadonok (char ch){ 
 ch=tolower(ch); 
 if (ch==’a’ || ch==’e’ || ch==’r’ || ch==’i’ || ch==’o’ || 
 ch==’u’ || ch==’y’) 
 return false; 
 } 
 int main(int argc, char* argv[]){ 
 char str[]="Classi algorithm behtarin class meboshad!!"; 
 int i; 
 vector <char> v; 
 cout<<"str="; 
 for (i=;str[i];i++) v.push_back(str[i]); 
 for (i=;i<v.size(); i++) 
 cout<<v[i]; 
 cout<<endl; 
 int n; 
 n=count(v.begin(), v.end(),’a’ ); 
 cout<<"Miqdori harfi a="<< n<< " to "<<endl; 
 n=count_if(v.begin(), v.end(), sadonok); 
 cout<<"Miqdori harfhoi gairihamsado="<<n<< " to"<<endl; 
 return; 
 } 
 Дар ин мисол тавре ки айён аст, дар аввал библиотекаҳои зарурӣ насб 
 карда шудаанд. Баъдан функсияи аз навъи мантиқӣ муаррифӣ шудааст, ки он 
 функсия садонокҳоро дар ҷумла муайян менамояд, яъне он функсия қимати false
 бармегардонад, агар дар ҷумлаи додашуда садонок мавҷуд бошад. Дар 
 функсияи асосӣ бошад, тағйирёбандае аз навъи рамзӣ муаррифӣ шуда, ба он ба
 сифати қимати аввала, ҷумлаи « Classi algorithm behtarin class meboshad!!» бах-
 шида шудааст. Сипас, векторе муарифӣ шуда, ба он ба сифати қимат ин сатр 
 бахшида шудааст. Тағйирёбандаи n, ки аз навъи бутун аст, аввал дар даъвати
 функсияи count барои муайянкунии миқдори ҳарфи «a» истифода шудааст. Дар 
 даъвати функсияи count_if() бошад, барои дар ҷумлаи додашуда муайян 
 намудани миқдори ҳарфҳои ғайриҳамсадо истифода бурда шудааст. Функсияи 
 count_if() ҷойи холигиро низ ҳамчун як рамз ҳисоб мекунад. Натиҷаи барнома
 намуди зеринро дорад: 
 str=Classi algorithm behtarin class meboshad!! 
 Miqdori harfi a= to 
 Miqdori harfhoi gairihamsado= to 
 Алгоритми count барои ҳисоб намудани миқдори қимати додашуда, дар 
 дохили пайдарпайи истифода шуда, чунин қолаб дорад: 
 template <class In class T> 
 typename iterator_traits<In>:: difference_type 
 count (In first, In last, const T &value) 
 ин алгоритм миқдори қимати value-ро дар дохили пайдарпайи ҳисоб мекунад. 
 Мисол. Ҳисоб намудани миқдори адади дар дохили пайдарпайи бо 
 истифода аз алгоритми count. 
 #include <iostream> 
 #include <algorithm.h> 
 #include <map.h> 
 #include <vector.h> 
 using namespace std; 
 int main(int argc, char* argv[]){ 
 int x[]={,,,,,,,,, }; 
 vector <int> v; 
 for (int i=; i<; i++) { 
 cout<<x[i]<<" "; 
 v.push_back(x[i]); 
 } 
 cout<<endl; 
 cout<<count( v.begin(), v.end(),); 
 return; 
 } 
 Алгоритми find ва find_if 
 Алгоритмҳои оилаи find барои ҷустуҷӯ ва пайдо кардани элемент дар 
 дохили пайдарпайи истифода бурда мешаванд. 
 Алгоритми find барои ҷустуҷӯи қимати value дар дохили пайдарпайи 
 истифода бурда мешавад. Қолаби умумии он намуди зеринро дорад: 
 template <class In, class T> 
 In find (In first, In last, const &value); 
 Алгоритми find_if барои ҷустуҷӯи қимати додашудаи предикати pred 
 истифода бурда мешавад. Трази истифодабарии он шакли зеринро дорад: 
 template <class In, class Pred> 
 In find (In first, In last, pred pred); 
 Ин алгоритмҳо ба элементи аввалаи ёфташуда итератор бармегардонанд, 
 агар амали ҷустуҷӯ бо муваффақият анҷом пазирад. Мисол. 
 #include <iostream> 
 #include <algorithm.h> 
 #include <map.h> 
 #include <vector.h> 
 using namespace std; 
 class MyClass{ 
 public: 
 bool operator()(int x){ 
 return x>= && x<=; 
 } 
 }; 
 int main(int argc, char* argv[]){ 
 int x[]={,,,,,,,,, }; 
 vector <int> v; 
 for (int i=; i<; i++) { 
 cout<<x[i]<<" "; 
 v.push_back(x[i]); 
 } 
 cout<<endl; 
 cout<<*find(v.begin(),v.end(),)<<endl; 
 cout<<*find_if(v.begin(), v.end(), MyClass()); 
 return; 
 } 
 Натиҷа:,,,,,,,,, 
 Алгоритми abjacent_find 
 Алгоритми abjacent_find барои пайдо кардани ҷуфти қиматҳои ҳамсоя дар
 дохили пайдарпайи ба кор меравад. Қолаби умумии он намуди зеринро дорад: 
 template<class For> For adjacent_fnd(For first, For last); 
 template<class For, class BnPred> 
 For adjacent_fnd(For first, For last, BinPred pred); 
 Қолаби якуми алгоритм барои пайдо кардани ҷуфти қиматҳои якхела дар 
 пайдарпайи истифода бурда мешавад. Агар амали ҷустуҷӯ бо муваффақият 
 анҷом пазирад, ба нахустин элементҳои пайдарпайи итератор бардонида 
 мешавад, дар ҳолати акс охири пайдарпайи бармегардонида мешавад. 
 Қолаби дуввум бошад, ҷуфти элементҳоеро бармегардонад, ки шарти 
 предикати pred-ро қаноат мекунонанд. 
 Мисол. Пайдо намудани нахустин ҷуфти элемнтҳои монанд. 
 #include <iostream> 
 #include <algorithm.h> 
 #include <map.h> 
 #include <vector.h> 
 using namespace std; 
 int main(int argc, char* argv[]) 
 { 
 int Arr[]={,,,,,,,}; 
 int len= sizeof(Arr)/sizeof(Arr[]); 
 vector<int> v(Arr,Arr+len); 
 vector<int>::iterator it; 
 it = adjacent_find(v.begin(),v.end()); 
 if (it!=v.end()) cout<<*it; 
 else cout<<"No elements"; 
 return; 
 } 
 Натиҷа: 
 Мисоли дигар. Дар ин мисол ба сифати аргументи сеюм функсияи 
 мантиқӣ истифода шудааст. Ин мисол ҳамаи ҷуфти элементҳои контейнерро 
 мебарорад. 
 #include <iostream> 
 #include <vector> 
 #include <algorithm> 
 using namespace std; 
 bool myfunc(const int i,const int j) 
 { 
 return i==j; 
 } 
 int main(int argc, char* argv[]) 
 { 
 int Arr[]={,,,,,,,}; 
 int len= sizeof(Arr)/sizeof(Arr[]); 
 vector<int> v(Arr,Arr+len); 
 vector<int>::iterator it; 
 it = v.begin(); 
 int count =; 
 while(it!=v.end()) 
 { 
 it = it = adjacent_find(++it,v.end(),myfunc); 
 if (it!=v.end()) 
 { 
 count++; 
 cout<<*it<<" "; 
 } 
 else 
 if (==count) cout<<"No elements"; 
 } 
 return; 
 } 
 Натиҷа: 
 Алгоритми search ва search_n 
 Алгоритми search дар дохили як пайдарпайи пайдарпайии дигарро бо 
 таҳлили предикат ва ё бе предикат ҷустуҷӯ карда, ба элементҳои мувофиқ 
 итератор бармегардонад. Қолаби умумии он намуди зеринро дорад: 
 Template <class For, class For> 
 For search (For first, For last, For first, For last); 
 Template <class For, class For, class BinPred> 
 For search (For first, For last, 
 For first, For last, BinPred Pred; 
 Дар ҳолати номуваффақ будани амали ҷустуҷӯ last-ро бармегардонад. 
 Алгорими search_n барои дар дохили пайдарпайи ҷустуҷӯ намудани 
 зерпайдарпайии дорои n қимати value истифода мешавад. Ин алгоритм низ 
 метавонад, бе предикат ва ё бо предикат кор кунад. Қолаби умумии он намуди
 зеринро дорад: 
 Template <class For, class Size, class T> 
 For search_n (For first, For last, Size count, const t &value);
 Template <class For, class Size, class T, class BinPred > 
 For search_n (For first, For last, 
 Size count, const t &value, class BinPred Pred); 
 Алгоритми merge 
 Алгоритми merge барои ба таври баракс мураттаб кардани элементҳои 
 пайдарпайи истифода мешавад. Қолаби умумии он намуди зеринро дорад. 
 template <class In, class In, class Out> 
 Out merge (In first, In last, In first, In last,Out Result);
 template <class In, class In, class Out, class Compare> 
 Out merge (In first, In last, 
 In first, In last,Out Result, Compare comp); 
 Мисол. 
 #include <iostream> 
 #include <algorithm> 
 #include <vector> 
 using namespace std; 
 int main(int argc, char* argv[]) 
 { 
 const int m=, n=; 
 int a[n]={,,,,,,,}; 
 int b[m]={,,,,,,}; 
 int c[m+n]; 
 merge(a,a+n, b,b+m, c); 
 for (int i=; i<(n+m); i++) 
 cout<<c[i]<<" "; 
 return; 
 } 
 Натиҷа: 
 Алгоритми next_permutation() 
 Алгоритми next_permutation() барои ҷойгиркунии (переста-новка) ҳамаи
 ҳолатҳои имконпазири элементҳои котейнер истифода бурда мешавад. 
 Ҷойивазкуни аз n элемент ин баробар аст ба n!, яъне барои ҷойивазкунии n 
 элементи додашуда n ҳолати имконпазир вуҷуд дорад. Мисол, бигзор 
 тағйирёбандаи s аз навъи char буда, дорои элемент бошад, пас, барои 
 ҷойивазкунии элементҳои он!= ҳолати имконпазир вуҷуд дорад, яъне 
 S=”abc” 
 Ҳолатҳои имконпазир: abc, acb, bac, bca, cab, сba 
 Қолаби умумии алгоритми next_permutation намуди зеринро дорад: 
 template <class Bi > 
 bool next_permutation (Bi first, Bi last); 
 template <class Bi, class Compare> 
 bool next_permutation (Bi, Bi last, Compare comp); 
 Акнун ба ҳамин монанд тавассути алгоритми next_permutation() мисолро дида
 мебароем. 
 #include <iostream> 
 #include <algorithm> 
 #include <vector> 
 using namespace std; 
 int main(int argc, char* argv[]){ 
 char s[]="abcd"; 
 do{ 
 cout <<s<< " "; 
 }while (next_permutation(s, s+)); 
 cout<<endl; 
 return; 
 } 
 Натиҷаи барнома намуди зеринро дорад: 
 abcd abdc acbd acdb adbc adcb bacd badc bcad bcda bdac bdca cabd cadb 
 cbad cbda cdab cdba dabc dacb dbac dbca dcab dcba 
 Алгоритми reverse() 
 Алгоритми reverse() пайдарпайи додашударо дар фосилаи додашуда, 
 баракс мураттаб месозад. Наҳви умумии алгоритми мазкур намуди зерин 
 аст: 
 Template <class BiIter> void reverse (Biter start, Biter end); 
 Мисол: 
 #include <iostream> 
 #include <algorithm> 
 #include <vector> 
 using namespace std; 
 #define n 
 int main(int argc, char* argv[]){ 
 vector <int> v; 
 int i; 
 cout<<" Elementhoi vectir pesh az davati function-I 
 reverse:"<<endl; 
 for (i=;i<=n;i++) 
 v.push_back(*i); 
 for (i=;i<v.size(); i++) 
 cout<<v[i]<<« «; 
 cout<<endl; 
 cout<<"Elementhoi vectir pas az davati function-I 
 reverse:"<<endl; 
 reverse (v.begin(), v.end() ); 
 for (i=;i<v.size(); i++) 
 cout<<v[i]<<" "; 
 cout<<endl; 
 return; 
 } 
 Дар ин ҷо тавре ки дида мешавад, дар аввал бо номи v векторе 
 муаррифӣ гардида, сипас, бо он адади аввалаи бутун бахшида мешавад.
 Баъд аз амали бахшиш, элементҳои вектор ба чоп бароварда шуда, 
 функсияи reverse() даъват карда шудааст. Пас аз даъвати функсияи мазкур,
 элементҳои вектор аз сари нав ба чоп бароварда мешаванд. Натиҷаи 
 барнома намуди зеринро дорад: 
 Elementhoi vectir pesh az davati function-I reverse: 
 Elementhoi vectir pas az davati function-I reverse: 
 Алгоритми sort 
 Барои мураттаб намудани элементҳои контейнерҳо алгоритми sort 
 истифода бурда шавад. Алгоритми мазкур дар ду намуд истифода бурда 
 мешавад: 
 Қолаби якум фосилаи додашудаи элементҳои контейнерро мураттаб 
 мекунад ва қолаби дуюм бошад, элементҳои фосилаи нишондодашударо аз рӯи 
 шарти гузошташуда мураттаб месозад. Мисол: 
 #include <iostream> 
 #include <algorithm> 
 #include <ctype> 
 #include <vector> 
 using namespace std; 
 #define n 
 int main(int argc, char* argv[]) 
 { 
 vector <int> v; 
 int i; 
 for (i=;i<n;i++) 
 v.push_back(random()); 
 cout<<"Elementhoi vector:"<<endl; 
 for (i=; i<v.size(); i++) 
 cout<<v[i]<<" "; 
 cout<<"\nElementhoi vector pas az murattabkuni:"<<endl; 
 sort(v.begin(), v.end() ); 
 for (i=; i<v.size(); i++) 
 cout<<v[i]<<" "; 
 cout<<endl; 
 return; 
 } 
 Натиҷаи барнома намуди зеринро дорад: 
 Elementhoi vector: 
 Elementhoi vector pas az murattabkuni: 
 Алгоритми swap() 
 Алгоритми swap() барои ҷойи ду адад (қимати тағйирёбанда)-ро иваз 
 намудан, истифода бурда мешавад. Қолаби умумии он намуди зеринро дорад: 
 template <class T> void swap (T& a, T& b); 
 Ҳоло истифодаи алгоритми swap-ро дар мисоли зерин дида мебароем. 
 Мисол. Барномае нависед, ки КТУ-и ду адади додашударо ҳисоб кунад. 
 Алгоритми remove_copy() ва алгоритми replace_copy() 
 Алгоритми remove() яке дигар аз алгоритмҳое мебошад, ки истифодаи 
 зиёдтар дорад. Қолаби умумии ин алгоритм намуди зеринро дорад: 
 Template <class ForIter, class OutIter, class T> OutIter remove_copy()InIter
 Start, InIter end, OutIter result, const T &val); 
 Алгоритми remove_copy() дар фосилаи додашудаи пайдарпайи қимати 
 val –ро нест намуда, элементҳои боқимондаи ба параметри result нусхабардорӣ
 мекунад. 
 Алгоритми replace_copy() низ ба алгоритми remove_copy() буда, танҳо он
 элементи нишондодашударо ба элементи додашуда иваз ме-кунад. Қолаби 
 умумии ин алгоритм намуди зеринро дорад: 
 Template <class ForIter, class OutIter, class T> OutIter replace_copy()InIter
 Start, InIter end, OutIter result, const T &old, const T &new); 
 Мисол. Барномае нависед, ки дар сатри додашуда аввал ҳарфи a-и сатри
 додашударо нест намуда, сипас, аз нав онро бо u иваз намояд. 
 #include <iostream> 
 #include <algorithm> 
 #include <ctype> 
 #include <vector> 
 using namespace std; 
 int main(int argc, char* argv[]){ 
 char str[]="Classi algorithm behtarin class meboshad!!"; 
 int i; 
 vector <char> v, v(); 
 cout<<"satri dodashuda:"<<endl; 
 for (i=;str[i];i++) 
 v.push_back(str[i]); 
 for (i=;v[i]; i++) 
 cout<<v[i]; 
 cout<<endl; 
 remove_copy(v.begin(), v.end(), v.begin(), ’a’ ); 
 cout<<"satr pas az nest kardani harfi a:"<<endl; 
 for (i=;v[i]; i++) 
 cout<<v[i]; 
 cout<<endl<<endl; 
 replace_copy(v.begin(), v.end(), v.begin(), ’a’, ’u’); 
 cout<<"satr pas az ivaz kardani harfi a ba u:"<<endl; 
 for (i=;v[i]; i++) 
 cout<<v[i]; 
 cout<<endl<<endl; 
 return; 
 } 
 Дар ин ҷо авввал бо номи str сатре аз навъи char муаррифӣ гар-дидааст.
 Баъд элементҳои сатр бо вектори символӣ бахшида шуда, ба чоп бароварда 
 шудаанд. Барои ҳарфи a-ро нест кардан функсияи remove_copy() ба намуди 
 зерин даъват карда шудаааст 
 remove_copy(v.begin(), v.end(), v.begin(), 'a' ); 
 пас аз даъвати ин функсия, ҳарфҳои a-и вектори v нест гардида, сим-волҳои
 боқимондаи он ба вектори v бахшида мешаванд. Барои ҳарфҳои a-и вектори 
 v- ро ба u иваз кардан аз функсияи replace_copy() ба сурати зерин истифода
 карда мешавад: 
 replace_copy(v.begin(), v.end(), v.begin(), 'a', 'u'); 
 Натиҷаи барнома намуди зеринро дорад: 
 satri dodashuda: 
 Classi algorithm behtarin class meboshad!! 
 satr pas az nest kardani harfi a: 
 Clssi lgorithm behtrin clss meboshd!! 
 satr pas az ivaz kardani harfi a ba u: 
 Clussi ulgorithm behturin cluss meboshud!! 
 Алгоритми transform() 
 Алгоритми transform яке аз алгоритмҳои дигаре мебошад, ки он барои 
 табдилдиҳии пайдарпайӣ хизмат мекунад. Алгоритми мазкур дар ду қолаб 
 истифода бурда мешавад: 
 OutIter transform(InIter Start, InIter end, OutIter result, 
 func bynaryfunc); 
 OutIter transform(InIter Start, InIter end, InIter Start, 
 OutIter result, func bynaryfunc); 
 Алгоритми transform() фосилаи [start, end] –ро табдил дода, ба параметри
 result нусхабардорӣ мекунад. Дар қолаби якум фосила параметри [start, end]
 дода шудааст. Барои табдилдиҳи ба функсия параметри unaryfunc дода 
 мешавад. Функсия аргументеро ба сифати қимат қабул намуда, онро табдил 
 дода бармегардонад. Қолаби дуюм бошад, барои табдилдиҳӣ аз функсияи 
 бинарӣ истифода мебаранд, ки ба сифати аргументи аввала элемент аз 
 пайдарпайии якум ва ба сифати аргументи дуввум элемент аз пайдарпайии 
 дуюм қабул мекунад. 
 Дар мисоли зерин функсияи func() барои ҳарфи хурдро ба калон табдил 
 додан истифода бурда мешавад. 
 #include <iostream> 
 #include <algorithm> 
 #include <ctype> 
 #include <vector> 
 using namespace std; 
 char func(char s) 
 { 
 return s+; 
 } 
 int main(int argc, char* argv[]){ 
 char str[]="ABCDEFGHIKLMNOPRSTU"; 
 int i; 
 vector <char> v, v(); 
 cout<<"satri dodashuda:"<<endl; 
 for (i=;str[i];i++) 
 v.push_back(str[i]); 
 for (i=;v[i]; i++) 
 cout<<v[i]; 
 cout<<endl; 
 vector <char>::iterator p=v.begin(); 
 p=transform(v.begin(), v.end(), v.begin(), func); 
 cout<<"Satr pas az tagirdihi:"<<endl; 
 for (i=;v[i]; i++) 
 cout<<v[i]; 
 return; 
 } 
 Ин барнома ҳарфҳои хурди сатри додашударо ба бузург табдил медиҳад. 
 Натиҷаи барнома намуди зеринро доранд: 
 satri dodashuda: 
 ABCDEFGHIKLMNOPRSTU 
 Satr pas az tagirdihi: 
 abcdefghiklmnoprstu 
 Алгоритми random_shuffle() 
 Алгоритми мазкур барои ба таври тасодуфӣ ҷойҳои элементҳои 
 контейнерро иваз намудан, истифода бурда мешавад. Қолаби умумии 
 иналгоритм намуди зеринро дорад: 
 void random_shuffle (RandomAccessInIter first, RandomAccess last); 
 Мисол: 
 #include <iostream> 
 #include <algorithm> 
 #include <ctype.h> 
 #include <vector> 
 using namespace std; 
 #define n 
 int main(int argc, char* argv[]) 
 { 
 vector <int> v; 
 int i; 
 for (i=;i<n;i++) 
 v.push_back(random()); 
 cout<<"Elementhoi vector:"<<endl; 
 for (i=; i<v.size(); i++) 
 cout<<v[i]<<" "; 
 cout<<"Elementhoi vector pas az ivazkunii joi onho: "<<endl; 
 random_shuffle(v.begin(), v.end() ); 
 for (i=; i<v.size(); i++) 
 cout<<v[i]<<" "; 
 cout<<endl; 
 return; 
 } 
 Натиыаи барнома: 
 Elementhoi vector: 
 Elementhoi vector pas az ivazkunii joi onho: 
 Алгоритми accumulate () 
 Алгоритми accumulate() барои ҳисоб намудани суммаи эле-ментҳои 
 контейнер дар фосилаи додашуда истифода бурда мешавад. Алгоритми мазкур 
 аз библиотекаи <algorithm> набуда, балки он аз библиотекаи <numeric.h> 
 мебошад. Мисол: 
 #include <iostream> 
 #include <algorithm> 
 #include <ctype.h> 
 #include <vector> 
 #include <numeric> 
 using namespace std; 
 #define n 
 int main(int argc, char* argv[]){ 
 vector <int> v; 
 int i; 
 for (i=;i<n;i++) 
 v.push_back(random()); 
 cout<<"Elementhoi vector:"<<endl; 
 for (i=; i<v.size(); i++) 
 cout<<v[i]<<" "; 
 cout<<endl; 
 double sum=accumulate(v.begin(), v.end(),.); 
 cout<<"sum="<<sum<<endl; 
 return; 
 } 
 Натиҷаи барнома шакли зеринро дорад: 
 Elementhoi vector: 
 sum= 
 Алгоритмҳои copy() ва copy_backward() 
 Алгоритмҳои copy() ва copy_backward() барои як векторро ба вектори 
 дигар нусхабардорӣ кардан, истифода бурда мешаванд. 
 Қолаби умумии алгоритми copy () намуди зеринро дорад: 
 template <class In, class Out> 
 Out copy (Inp first, In last, Out result); 
 Қолаби умумии алгоритми copy_backward() бошад, намуди зеринро 
 дорад: 
 template <class Bi, class Bi> 
 Bi copy_backward (Bi first, Bi last, Bi result); 
 Мисол: 
 #include <iostream> 
 #include <algorithm> 
 #include <ctype.h> 
 #include <vector> 
 #include <numeric> 
 using namespace std; 
 int main(int argc, char* argv[]){ 
 int x[]={,,,,}; 
 int y[]={,,,,}; 
 vector <int> v(x, x+), v(y, y+), v(y, y+); 
 cout << " Vectory yakum v"<<endl; 
 for (int i=; i<v.size(); i++) 
 cout<<v[i]<<" "; 
 cout<<endl; 
 cout << " Vectory duvum v"<<endl; 
 for (int i=; i<v.size(); i++) 
 cout<<v[i]<<" "; 
 cout<<endl; 
 cout << " Vectory seyum v"<<endl; 
 for (int i=; i<v.size(); i++) 
 cout<<v[i]<<" "; 
 cout<<endl; 
 cout << " Nuskhabardori kardani vectory yakum v ba duyum 
 v"<<endl; 
 copy( v.begin(), v.end(),v.begin()); 
 for (int i=; i<v.size(); i++) 
 cout<<v[i]<<" "; 
 cout<<endl; 
 cout << "Nuskhabardori kardani vectory duyum v ba seyum 
 v"<<endl; 
 copy_backward( v.begin(), v.end(),v.begin() ); 
 for (int i=; i<v.size(); i++) 
 cout<<v[i]<<" "; 
 return; 
 } 
 Дар ин мисол Тавре ки дида мешавад, ду массив бо номи х ва у, ки 
 андозаашон ба баробар аст, муаррифӣ шудаанд. Сипас, се вектор бо номҳои v,
 v ва v муаррифӣ шуда, ба сифати қимати вектори аввала, қиматҳои массиви
 якум ва ба сифати ду вектори дигар, қимати массиви дуюм бахшида шудаааст.
 Дар даъвати алгоритми copy() ҳамаи элементҳои вектори якум ба вектори
 дувум нусхабардорӣ шудаанд. Даъвати алгоритми copy_backward() бошад, 
 ҳамаи элементҳои вектори якумро ба сеюм нусхабардорӣ мекунад. Дар ин 
 даъват параметри сеюм, ки ба охири контейнер ишора мекунад, барои аз охир ба
 аввал нусхабардорӣ кардани элементҳои вектор истифода мешавад. Натиҷаи 
 барнома намуди зеринро дорад: 
 Vectory yakum v 
 Vectory duvum v 
 Vectory seyum v 
 Nuskhabardori kardani vectory yakum v ba duyum v 
 Nuskhabardori kardani vectory duyum v ba seyum v 
 Алгоритмҳои стандартӣ болои ҳама намуд контейнерҳо амал мекунанд. 
 Дар поён истифодаи алгоритми copy()-ро барои нусха-бардори намудани 
 элементҳои вектор ба List оварда шудааст. 
 #include <iostream> 
 #include <algorithm> 
 #include <ctype.h> 
 #include <vector> 
 #include <numeric> 
 using namespace std; 
 int main(int argc, char* argv[]){ 
 int x[]={,,,,}; 
 vector <int> v(x, x+); 
 list <int> L, L, L; 
 copy(v.begin(), v.end(), back_inserter(L)); 
 cout<<"Guzoshtani elementhoi vector dar ruyhat "<<endl; 
 list <int>::iterator p; 
 p=L.begin(); 
 while (p!=L.end() ){ 
 cout<<*p<<" "; 
 p++; 
 } 
 cout<<endl; 
 cout<<"Guzoshtani elementhoi vector dar ruyhat bo ravishi 
 digar"<<endl; 
 copy(v.begin(), v.end(), inserter(L, L.begin() )); 
 p=L.begin(); 
 while (p!=L.end() ){ 
 cout<<*p<<" "; 
 p++; 
 } 
 cout<<endl; 
 cout<<"Guzoshtani elementhoi vector dar ruyhat (baraks)"<<endl; 
 copy(v.begin(), v.end(), front_inserter(L)); 
 p=L.begin(); 
 while (p!=L.end() ) 
 { 
 cout<<*p<<" "; 
 p++; 
 } 
 return; 
 } 
 Дар ин мисол аввал як массив ва се list аз навъи бутун муаррифӣ 
 гардидаанд. Дар даъвати якум ва дуюми алгоритми copy() элементҳои вектор ба
 List-ҳои якум ва дуюм нусхабардорӣ шудаанд. Дар даъвати сеюм бошад, 
 элементҳои вектор ба list-и L бо тартиби баръакс нусхабардорӣ шудаанд. Пас
 аз ҳар даъват элементҳои List дар саҳифаи намоиш бароварда мешаванд. 
 Натиҷаи барнома намуди зеринро дорад: 
 Guzoshtani elementhoi vector dar ruyhat 
 Guzoshtani elementhoi vector dar ruyhat bo ravishi digar 
 Guzoshtani elementhoi vector dar ruyhat (baraks) 
 Алгоритми replace, replace_if, replace_copy ва replace_copy_if 
 Алгоритмҳои оилаи replace барои иваз намудани қимати элементи 
 додашударо бо қимати нав ё предикат хизмат мекунанд. Қолаби умумии 
 алгоритмҳои ин оила намуди зеринро доранд: 
 template <class For, class T> 
 void replace (For first, For last, 
 cost T &old_value, const T &new_value); 
 template <class For, class Pred, class T> 
 void replace_if (For first, For last, 
 Pred pred, const T &new_value); 
 template <class In, class Out, class T> 
 Out replace_copy (In first, In laset, Out result, 
 cost T &oldvalue, const T &newvalue); 
 template <class Iterator, class Out, class Pred, class T> 
 Out replace_copy_if (Iterator first, Iterator last, Out result, 
 Pred pred, const T &newvalue); 
 Мисолеро дида мебароем, ки дар он вектори а бо вектори b бо истифода
 аз итератори гузориш ва иваз кардани ҳамаи элементҳои тоқ ба адади 
 нусхабардорӣ карда мешавад. 
 #include <iostream> 
 #include <algorithm> 
 #include <ctype.h> 
 #include <vector> 
 #include <numeric> 
 using namespace std; 
 bool odd(int x){ 
 return x%!=; 
 } 
 int main(int argc, char* argv[]) 
 { 
 vector <int> a, v; 
 vector<int>::iterator i; 
 for (int k=; k<=; k++) 
 v.push_back(k); 
 for (i=v.begin(); i!=v.end();i++) 
 cout<<*i<<" "; 
 cout<<endl; 
 replace_copy_if(v.begin(), v.end(), inserter(a, a.begin()), odd, 
 ); 
 for (i=a.begin(); i!=a.end();i++) 
 cout<<*i<<" "; 
 return; 
 } 
 Натиҷаи барнома шакли зеринро дорад: 
 Алгоритми generate ва generate_n 
 Алгоритми generate барои ба натиҷаи амалиёт иваз намудани ҳамаи 
 элементҳои контейнер истифода бурда мешавад. Ин имконият фароҳам меорад, 
 ки контейнеррро аз қиматҳои ягона (уникалӣ ) пур кунем. Қолаби умумии он 
 намуди зеринро дорад: 
 template <class For, classs Generator> 
 void generate (For first, For last, Generator gen); 
 template <class Out, class Size, classs Generator> 
 void generate _n(Out first, Size n, Generator gen); 
 Мисол. Истифодаи алгоритмҳои generate ва generate_n. 
 #include <iostream> 
 #include <algorithm> 
 #include <ctype.h> 
 #include <vector> 
 #include <numeric> 
 #include <сmath> 
 using namespace std; 
 int func(){ 
 static x=; 
 return powl(++x,); 
 } 
 int main(int argc, char* argv[]) 
 { 
 int a[], i; 
 generate( a,a+, func); 
 for (i=; i<; i++) 
 cout<<a[i]<<" "; 
 return; 
 } 
 Натиҷаи барнома намуди зеринро дорад: 
 Алгоритми fill ва fill_n 
 Алгоритми fiil барои ба қимати value иваз намудани ҳамаи элементҳои 
 пайдарпайӣ, ки онҳоро итераторҳои first ва last муайян кардаанд, хизмат 
 мекунад. Алгоритми fill_n бошад, ин амалро танҳо барои n элемент иҷро 
 мекунад. Қолаби умумии он намуди зеринро дорад: 
 template <class For, class T> 
 void fill (For first, For last, const T &value); 
 template <class Out, class Size, class T> 
 void fill_n (Out first, Size n, const T &value); 
 Мисол. 
 #include <iostream> 
 #include <algorithm> 
 #include <ctype.h> 
 #include <vector> 
 #include <numeric> 
 #include <сmath> 
 using namespace std; 
 int main(int argc, char* argv[]) 
 { 
 int a[], i; 
 fill(a,a+, ); 
 for (i=; i<; i++) 
 cout<<a[i]<<" "; // 
 cout<<endl; 
 fill_n(a+,, ); 
 for (i=; i<; i++) 
 cout<<a[i]<<" "; // 
 return; 
 } 
 Алгоритми partial_sort ва partial_sort_copy 
 Алгоритми partial_sort барои қисман мураттаб намудани элементҳои 
 массив ё вектор истифода бурда мешавад. Баъд аз иҷроиши ин алгоритм 
 элементҳои фосилаи аз first то last ҳолатеро соҳиб мешаванд, ки ҳангоми пурра
 мураттаб намудани массив онро аз даст намедиҳанд. 
 Алгоритми partial_sort_copy айнан амали алгоритми partial_sort бо 
 нусхабардорӣ намудани элементхои пайдарпайӣ иҷро мекунад. 
 Қолаби умумии ин алгоритмҳо намуди зеринро дорад: 
 template <class Ran> 
 void partial_sort(Ran first, Ran middle, Ran last); 
 template <classRan, class Compare> 
 void partial_sort(Ran first, Ran middle, Ran last, Compare Com); 
 template <class In,class Ran> 
 Ran partial_sort_copy(In first, In last, Ran result_first, Ran result_last);
 template <class In,class Ran, class Compare > 
 Ran partial_sort_copy(In first, In last, 
 Ran result_first, Ran result_last, class Compare); 
 Мисол. 
 #include <iostream> 
 #include <algorithm> 
 #include <ctype.h> 
 #include <vector> 
 #include <numeric> 
 using namespace std; 
 int main(int argc, char* argv[]) 
 { 
 int a[], i; 
 cout<<"Elementhoi massiv pesh az partial_sort:"; 
 for (i=; i<; i++) { 
 a[i]=rand()%; 
 cout<<a[i]<<" "; 
 } 
 vector <int> v(a,a+); 
 vector<int>::iterator ii=v.begin()+; 
 cout<<endl; 
 partial_sort(v.begin(), v.begin()+, v.end()); 
 cout<<"Elementhoi massiv pas az partial_sort:"; 
 for (i=; i<; i++) 
 cout<<v[i]<<" "; 
 cout<<endl; 
 return; 
 } 
 Натиҷаи барнома: 
 Elementhoi massiv pesh az partial_sort: 
 Elementhoi massiv pas az partial_sort: 
 Алгоритми nth_element 
 Алгоритми nth_element низ барои қисман мураттаб намудани элементҳои 
 пайдарпайи истифода бурда мешавад. Пас аз даъвати алгоритми мазкур, қимати
 элементи дар итератори nth қарордошта, ҳолатеро соҳиб мешаванд, ки ҳангоми
 пурра мураттаб намудани массив онро аз даст намудиҳад, яъне дар тарафи чапи
 он элементҳои аз он хурд ва дар тарафи рости он элементҳои аз он калон ҷойгир
 мешаванд. 
 Қолаби умумии ин алгоритм намуди зеринро дорад: 
 template <class Ran> 
 void nth_element(Ran first, Ran nth, Ran last); 
 template <classRan, class Compare> 
 void nth_element (Ran first, Ran nth, Ran last, Compare Com); 
 Мисол. 
 #include <iostream> 
 #include <algorithm> 
 #include <ctype.h> 
 #include <vector> 
 #include <numeric> 
 using namespace std; 
 int main(int argc, char* argv[]) 
 { 
 int a[], i; 
 cout<<"Elementhoi massiv pesh az nth_element:"<<endl; 
 for (i=; i<; i++) { 
 a[i]=rand()%; 
 cout<<a[i]<<" "; 
 } 
 vector <int> v(a,a+); 
 vector<int>::iterator ii=v.begin() +; 
 cout<<endl; 
 nth_element(v.begin(), ii, v.end()); 
 cout<<"Elementhoi massiv pas az nth_element:"<<endl; 
 for (i=; i<; i++) 
 cout<<v[i]<<" "; 
 cout<<endl; 
 return; 
 } 
 Натиҷаи барнома шакли зеринро дорад: 
 Elementhoi massiv pesh az nth_element: 
 Elementhoi massiv pas az nth_element: 
 Алгоритмҳои кор бо маҷмӯъҳо 
 Маҷмӯъ гуфта, гурӯҳи элементҳои яуҷинсаро меноманд. Дар забони С++ 
 контейнерҳои зиёде барои кор кардан ба гурӯҳи элементҳо мавҷуданд. Илова 
 бар ин дар STl барои кор кардан бо маҷмӯҳо алгоритмҳое махсусе мавҷуданд,
 ки ҳангоми истифодаи онҳо маҷмӯъҳо ҳамчун массивҳо ё вектор муаррифӣ 
 карда мешаванд. 
 Дар риёзи барои ишора кардани маҷмӯъҳо аз ҳарфҳои калони лотини 
 истифода бурда шуда, элементҳои маҷмӯъ дар дохили қавси фигуравӣ навишта 
 мешаванд. Барои бо маҷмӯъҳо амалҳои зеринро иҷро кардан алгоритм мавҷуд 
 аст. 
 Ҷамъ; 
 Зарб; 
 Фарқ; 
 Фарқи симметрӣ. 
 ) Ҷамъи ду маҷмӯъ гуфта, маҷмӯъеро меноманд, ки элементҳои он аз 
 якҷоякунии маҷмӯи якум ва дуюм ташкил ёфтаанд. 
 ) Зарби ду маҷмӯъ гуфта, маҷмӯъеро меноманд, ки элементҳои он аз 
 элементҳои якхелаи маҷмӯи якум ва дуюм ташкил ёфтаанд. 
 ) Фарқи ду маҷмӯъ гуфта, маҷмӯъеро меноманд, ки элементҳои он аз он 
 элементҳои маҷмӯи якум, ки дар маҷмӯъи дуюм вуҷуд надоранд ташкил 
 ёфтаанд. 
 ) Фарқи симметрии ду маҷмӯъ гуфта, маҷмӯъеро меноманд, ки элементҳои он 
 аз элементҳои гуногуни маҷмӯи якум ва дуюм ташкил ёфтаанд, яъне он 
 элементҳои маҷмӯъи якум, ки дар маҷмӯъи дуввум нестанд ва баракс. 
 Мисол. Бигзор ду маҷмӯъ додашуда бошанд: 
 S=[,,,,,]; 
 S=[,,,,]. 
 Пас, иҷрои амалҳои арифметикӣ намуди зеринро дорад: 
 S=S+S=[,,,,,,,]; 
 P=S*S=[,,]; 
 F=S-S=[,,]. 
 Бояд қайд кард, ки барои амали тарҳ дар маҷмӯъҳо амали ҷойивазкуни 
 ҷой надорад, яъне 
 А л го р и мт и i nc lu d es 
 Алгоритми includes барои санҷиши мавҷудияти як пайдарпайӣ (маҷмӯъ) 
 дар дохили пайдарпайии (маҷмӯъи) дигар истифода бурда мешавад. Агар ҳамаи
 элементҳои пайдарпайии [first, last) дар пайдарпайии [first, last) мавҷуд
 бошанд, қимати ҳақ бармегардонад. Қолаби умумии ин алгоритм намуди 
 зеринро дорад: 
 template <class In, class In> 
 bool includes ( In first, In last, In first, In last ); 
 template <class In, class In, class Compare> 
 bool includes ( In first, In last, In first, In last,
 Co mpare comp ); 
 Мисол. 
 #include <iostream> 
 #include <algorithm> 
 #include <vector> 
 using namespace std; 
 bool myfunction (int i, int j){ 
 return i<j; 
 } 
 int main(int argc, char* argv[]) 
 { 
 int x[] = {,,,,,,,,,}; 
 int y[] = {,,,}; 
 sort (x,x+); 
 sort (y,y+); 
 if (includes(x,x+,y,y+) ) 
 cout << "y dar x mekhobad!\n"; 
 if (includes(x,x+,y,y+, myfunction) ) 
 cout << "y dar x mekhobad!\n"; 
 return; 
 } 
 Натиҷаи барнома: 
 y dar x mekhobad! 
 y dar x mekhobad! 
 Алгоримти set_insersection 
 Алгоритми set_insersection аз зарби ду маҷмӯъро бо намуди 
 ғайримураттаб маҷмӯъи нав месозад. Қолаби умумии он намуди зеринро дорад:
 template <class In, class In, class Out> 
 Out set_intersection (In first, In last, In first, In last, Out result);
 template <class In, class In, class Out, class Compare> 
 Out set_intersection (In first, In last, In first, In last, 
 Out result, Compare comp); 
 Мисол. 
 #include <iostream> 
 #include <algorithm> 
 #include <ctype.h> 
 #include <vector> 
 #include <numeric> 
 using namespace std; 
 int main(int argc, char* argv[]) 
 { 
 vector<int> v(); 
 vector<int>::iterator it; 
 int x[] = {,,,,,}; 
 int y[] = {,,,,}; sort (x,x+); 
 sort (y,y+); 
 it=set_intersection (x, x+, y, y+, v.begin()); 
 v.resize(it-v.begin()); 
 cout << "majmuho doroi " << (v.size()) << " elementi monand 
 meboshand:\n"; 
 for (it=v.begin(); it!=v.end(); ++it) 
 cout << " " << *it; 
 cout << ’\n’; 
 return; 
 } 
 Натиҷаи барнома: 
 majmuho doroi elementi monand meboshand: 
 Алгоримти set_defference, set_symmetric_difference 
 Алгоритми set_difference он элементҳоеро, ки аз ду пайдарпайии 
 додашуда танҳо дар якумаш мехобанд дар Out нусхабардорӣ мекунад, яъне 
 фарқи ду маҷмӯи додашуда маҷмӯи нав месозад. Қолаби умумии он намуди 
 зеринро дорад: 
 template <class In, class In, class Out> 
 Out set_difference (In first, In last, In first, In last,
 Out result); 
 template <class In, class In, class Out, class Compare> 
 Out set_difference (In first, In last, In first, In last, Out
 result, Compare comp); 
 Алгоритми set_symmetric_difference бошад, он элементҳоеро, ки аз ду 
 пайдарпайии додашуда танҳо дар якеаш мехобанд дар Out нусхабардорӣ 
 мекунад, яъне он аз фарқи симметрии ду мавмӯъ маҷмӯъи нав месозад. Қолаби
 умумии он намуди зеринро дорад: 
 template <class In, class In, class Out> 
 Out set_symmetric_difference (In first, In last,In first,
 In last, Out result); 
 template <class In, class In,class Out, class Compare> 
 Out set_symmetric_difference (In first, In last, In first,
 In last, Out result, Compare comp); 
 Мисоли алгоритми set_difference. 
 #include <iostream> 
 #include <algorithm> 
 #include <vector> 
 using namespace std; 
 int main(int argc, char* argv[]){ 
 vector<int> v(); 
 vector<int>::iterator it; 
 int x[] = {,,,,,}; 
 int y[] = {,,,,}; 
 sort (x,x+); 
 sort (y,y+); 
 it=set_difference (x, x+, y, y+, v.begin()); 
 v.resize(it-v.begin()); 
 cout << "dar majmui yakum " << (v.size()) << " element ast,ki dar 
 majmui duyum vujud nadorand:\n"; 
 for (it=v.begin(); it!=v.end(); ++it) 
 cout << ’ ’ << *it; 
 cout << ’\n’; 
 return; 
 } 
 Натиҷаи барнома: 
 dar majmui yakum element ast,ki dar majmui duyum vujud nadorand: 
 Мисоли алгоритми set_symmetric_difference. 
 #include <iostream> 
 #include <algorithm> 
 #include <vector> 
 using namespace std; 
 int main(int argc, char* argv[]){ 
 vector<int> v(); 
 vector<int>::iterator it; 
 int x[] = {,,,,,,,,,}; 
 int y[] = {,,,, }; 
 sort (x,x+); 
 sort (y,y+); 
 it=set_symmetric_difference (x, x+, y, y+, v.begin()); 
 v.resize(it-v.begin()); 
 cout << "dar majmui yakum va duyum " << (v.size()) << " elementi 
 gunogun vujud dorad:\n"; 
 for (it=v.begin(); it!=v.end(); ++it) 
 cout << ’ ’ << *it; 
 cout << ’\n’; 
 return; 
 } 
 Натиҷаи барнома 
 dar majmui yakum va duyum elementi gunogun vujud dorad: 
 Алгоримти set_union 
 Алгоритми set_union аз суммаи ду маҷмӯъ ба намуди ғайримураттаб 
 маҷмӯъи нав месозад. Қолаби умумии он шакли зеринро дорад: 
 template <class In, class In, class Out> 
 Out set_union (In first, In last, In first, In last, Out result);
 template <class In, class In,class Out, class Compare> 
 Out set_union (In first, In last, In first, 
 In last, Out result, Compare comp); 
 Мисол. 
 #include <iostream> 
 #include <algorithm> 
 #include <ctype.h> 
 #include <vector> 
 #include <numeric> 
 using namespace std; 
 int main(int argc, char* argv[]) 
 { 
 vector<int> v(); 
 vector<int>::iterator it; 
 int x[] = {,,,,,,,,, }; 
 int y[] = {,,,,}; 
 sort (x,x+); 
 sort (y,y+); 
 it=set_union(x, x+, y, y+, v.begin()); 
 v.resize(it-v.begin()); 
 for (it=v.begin(); it!=v.end(); ++it) 
 cout << ’ ’ << *it; 
 cout << ’\n’; 
 return; 
 } 
 Натиҷа: 
 Элементҳои маҷмӯъҳо на танҳо ададҳо, инчунин метавонанд символҳо, 
 сатрҳо ва ғайра бошанд. Барои далели ин гуфтаҳо, мисоли дигареро тавассути
 алгоритми set_union дида мебароем, ки элементҳои маҷмӯъ дар он сатрҳо 
 мебошанд. 
 #include <iostream> 
 #include <algorithm> 
 #include <vector> 
 #include <cassert> 
 using namespace std; 
 int main(int argc, char* argv[]) 
 { 
 bool result; 
 string s("ABCDEFGH"); 
 string s("ABICDFKL"); 
 vector<char> v(s.begin(), s.end()); 
 vector<char> v(s.begin(), s.end()); 
 vector<char> su; 
 set_union(v.begin(), v.end(),v.begin(), v.end(), 
 back_inserter(su)); 
 for(int i=;i<su.size();i++){ 
 cout << su[i]; 
 } 
 return; 
 } 
 Натиҷаи барнома: 
 ABCDEFGHICDFKL 
 Саволҳо барои мустаҳкамкунӣ 
 мешаванд? 
 Намунаи ҳалли мисолҳо 
 ) Дар пайдарпайии ададҳои... ( аъзои якум 
 дода шудааст. Аъзоҳои боқимонда аз рӯи формулаи 
 ҳисоб к а рд а м е ша ван д. А ъзои N 
 ( -уми пайдарпайи ёфта шавад. 
 Д ох и л к у н ӣ аз ф айли input.txt дар сатри якум адади a ва N тавассути фосила
 навиш та м еш ав ад. 
 Хориҷкунӣ дар файли output.txt. Як адад - хориҷ карда мешавад. 
 Мисолҳо 
 Дохилкунии Дохилкунӣ 
 Хориҷкунӣ Хориҷкунӣ 
 Матни барнома: 
 #include <iostream> 
 #include <cstdio> 
 #include <vector> 
 using namespace std; 
 const int size =; 
 long long n; 
 vector<int> mas; 
 vector<int> mem; 
 vector<int> pos; 
 void input() 
 { 
 mas.resize(size); 
 mem.resize(size); 
 pos.resize(size); 
 cin>>mas[]>>mas[]>>mas[]; 
 mem[mas[] + *mas[] + *mas[]] =; 
 cin>>n; 
 n--; 
 } 
 void solve() 
 { 
 int base = -; 
 int len = -; 
 for (int i=;i<size;i++) 
 { 
 mas[i] = (mas[i-] + mas[i-] + mas[i-])%; 
 int value = mas[i-] + *mas[i-] + *mas[i-]; 
 if (mem[value] && i!=) 
 { 
 base = pos[value]; 
 len = i - - base; 
 break; 
 } 
 mem[value] =; 
 pos[value] = i-; 
 } 
 if (n < base + len) 
 cout<<mas[n]; 
 else 
 { 
 int index = base + (n - base) % len; 
 cout<<mas[index]; 
 } 
 } 
 int main() 
 { 
 freopen("input.txt","r",stdin); 
 freopen("output.txt","w",stdout); 
 input(); 
 solve(); 
 return; 
 } 
 ) Дар муаммои зарб бозӣ бо сафи картаҳо карда мешавад, ки ҳар яке аз онҳо
 дорои адади (рақами) бутуни мусбат мебошад. Ҳангоми ход бозингар яке аз
 картаҳоро аз саф нест карда, миқдори холҳоро соҳиб мегардад, ки баробар
 аст ба ҳосили зарби адади (рақами) картаи нестшуда ва адади (рақами) 
 картаҳои тарафи чап ва рости он. Картаҳои аввал ва охири сафро нест 
 кардан мумкин нест. Пас аз ходи охирон танҳо ду карта боқӣ мемонад. 
 Мақсади бозӣ нест намудани картаҳо бо ҳамон тартибе, ки миқдори 
 умумии холҳои наборкардашударо камтарин гардад. 
 Масалан, агар картаҳо дорои,,, ва бошанд, бозингар 
 метавонад, аввал картаи рақами ва баъд ва -ро гирифта дорои холҳои
 зерин гардад 
 ··+··+·· = ++ =. 
 Агарон картаҳоро бо тартиби баракс гирифта шаванд, яъне аввал, баъд
 ва баъд, онгоҳ миқдори холҳо ба сурати зерин ҳисоб карда мешаванд:
 ··+··+·· = ++ =. 
 Додаҳои вурудӣ 
 Дар сатри якуми файли input.txt миқдори картаҳо N навишта мешавад, 
 дар сатри дуввум бошад, бо фосила N ( ≤ N ≤ ) рақами картаҳо дохил
 карда мешавад, рақами картаҳо адади бутуни аз то мебошад. 
 Додаҳои хуруҷӣ 
 Дар файли output.txt як адади бутун, ки миқдори минималии имконияти 
 холҳоро ифода мекунад, бароварда мешавад. 
 Мисол 
 Дохилкунӣ Хориҷкунӣ 
 Матни барнома 
 #include <iostream> 
 #include <vector> 
 #include <cstdio> 
 using namespace std; 
 int n; 
 vector<int> mas; 
 vector<vector<int> > mem; 
 void input(){ 
 cin>>n; 
 mas.resize(n); 
 for (int i=;i<n;i++) 
 cin>>mas[i]; 
 mem = vector<vector<int> > (n,vector<int>(n)); 
 } 
 void solve() 
 { 
 for (int len =; len < n; len++) { 
 for (int i=;i<n;i++){ 
 int j = i + len; 
 if (j == n) 
 break; 
 int res = e; 
 for (int m = i+; m<=j-; m++) 
 { 
 int cur = mem[i][m] + mas[i] * mas[m] * mas[j] + 
 mem[m][j]; 
 res = min(res,cur); 
 } 
 mem[i][j] = res; 
 } 
 } 
 cout<<mem[][n-]; 
 } 
 int main(){ 
 freopen("input.txt","r",stdin); 
 freopen("output.txt","w",stdout); 
 input(); 
 solve(); 
 return; 
 } 
 Мисолҳо барои кори мустақилона 
 Масъала (мисол)-ҳои гурӯҳи Array ва Matrix (Боби ) -ро бо истифода 
 аз имкониятҳои STL ҳал кунед. 
 Боби. Графҳо 
 Муқаддима 
 Мавзӯи графҳо яке аз мавзӯъҳои муҳим ва асосӣ ба ҳисоб меравад, ки он дар
 риёзиёти дискретӣ, физика, алгебра, техникаи ҳисоббарор, системаи коркарди
 маълумотҳо, равандҳои технологӣ, шабакаҳои компютерӣ, системаи таъмини 
 барқӣ, иқтисодиёт, таҳлили занҷири Марков дар назарияи эҳтимолият, лоиҳакашии
 схемаҳои электронӣ, ҷомеашиносӣ, системаи сохтмони роҳҳо ва ғайра истифодаи
 васеъ дорад. 
 Граф гуфта, маҷмӯи объектҳои аз ҷиҳати навъ якхеларо меноманд. Ба ин
 мисол шуда метавонанд: маҷмӯи шаҳрҳо, маҷмӯи одамон ва ғайра. 
 Назарияи гарфҳо аввалин мартиба аз масъалаи -пули шаҳри Кенигсберг ба
 вуҷуд омад. Шакли пулҳои мазкур чунин буд: 
 Моҳияти масъала чунин буд: Оё метавон ба пулӣ шаҳри Кенигсберг 
 ҳаракат карда, ба ҷои аввала баргашт. Дар ин муддат ба ҳар як пул бояд як бор
 гузашт. Ин масъаларо математикӣ шветсариягӣ Л. Эйлер бо истифода аз графҳо
 ҳал кардааст. 
 Таърифи математикӣ ва пурраи граф чунин аст: Системаи иборат аз се 
 элемент G=(X,U,F)-ро граф меноманд. Дар ин ҷо X=X(x)-маҷмӯи қуллаҳо, U=U(u)
 маҷмӯи теғаҳо ва F инъикоси байни онҳо мебошад. 
 Бигзор якчанд маҷмӯи охирнокм нуқтаҳо дода шуда бошад. Ин маҷмӯи 
 додашударо қуллаҳои граф номида бо VG ишора мекунанд. Қуллаҳои графро 
 одатан ба маҷмӯи ҳарфҳои зернависдор ё ададҳо 
 ишора мекунанд. Дар намуди геометрӣ бошад, ин маҷмуро бо дирачаҳо
 ишора мекунанд. 
 Д и л хоҳ ҷуфти элементҳоро аз маҷмӯи VG теға (камон)-и граф номида бо EG
 ишорат мекунанд. Теға (камон)-ҳои графро одатан бо ҷуфти қуллаҳои граф ишора
 мекунанд: 
 ё. 
 Барои ба хонанда пурратар фаҳмо шудан, граферо меорем, ки дорои теға
 ва қу л ла м е б о ш а д. 
 Дар баъзе адабиётҳо ҳангоми омӯзиши графҳо ба мафҳумҳои теға ва камон
 дучор шудан мумкин аст. Бояд қайд кард, ки барои графҳо мафҳуми теға аз камон
 фарқ мекунад. Теға ин алоқаи дутарафа ё роҳи дутарафа дар байни қуллаҳо буда,
 камон роҳи яктарафа мебошад. Бо суханҳои дигар теға ду қулларо бо ҳамдигар
 пайваст мекунад ва камон бошад аз як қулла баромада ба қуллаи дигар ба охир
 мерасад. 
 Ба сифати мисоли роҳи дутарафа мардеро пеши назар меорем, ки он 
 метавонад ба хонаи ҳамсоя ба меҳмонӣ рафта, сипас бо роҳи рафтааш ба хонаи худ
 бармегардад. Ба сифати камон бошад, парашютистеро меорем, ки он худро аз 
 парашют ба замин меандозад. Пас аз оне, ки он ба замин мерасад дигар 
 наметавонад ба ҷои худ баргардад. 
 Одатан ҷуфти теғаҳоро бо ҳарфи E ва ҷуфти камонҳоро бо ҳарфи V ишора
 мекунанд. Ба сифати мисол дар поён граферо мерем, ки дорои панҷ қулла, чор
 теға ва се камон мебошад. 
 Дараҷаи қуллаҳои графҳо 
 Дараҷаи қуллаи граф гуфта, миқдори теғаҳои графро, ки ба ин қулла тааллуқ
 доранд меноманд. Дараҷаи қулларо инчунин валентност низ меноманд ва бо d(v) ё
 deg (v) ишора мекунанд. Қуллаи графро, ки барои он d(v) = аст қуллаи 
 қайдкардашуда меноманд. 
 Қуллаи граф ҷуфт номида мешавад, агар барои он d(v) адади ҷуфт бошад ва
 баракс. 
 Дар ин ҷо d()=,d()=, d()= ва d()= мебошад. 
 Шакли геометрии графҳо 
 Ба намуди графикӣ пешниҳод намудани графҳо имконияти пурратар дарк 
 намудани онҳоро фароҳам меорад. Графҳо на дар як шакл, балки бо шаклҳои 
 гуногун дода мешаванд. Ҳоло баъзе аз шаклҳои асосии ба намуди графикӣ дода
 шудани графҳоро маври-ди баҳс қарор медиҳем. 
 қуллаҳои он роҳи рафту омад вуҷуд дошта бошад. Навишти математикии чунин 
 навъ графҳо шакли G=(U,A) –ро дорад. Дар ин ҷо U-маҷмӯи қуллаҳо ва A-ро 
 равиши теғаҳоро ифода мекунад. Бо суханҳои дигар, графи беаломат гуфта, 
 граферо меноманд, ки агар қуллаҳои онро танҳо теғаҳо пайваст кунанд. Дар поён
 тасвири графикии ин навъ граф оварда шудааст. 
 Ин граф дорои қулла VG=(,,,,) ва теға EG={(, ), (, ), (, ), (,
 ), (, ), (, ), (, ), (, ), (, ), (, )} мебошад. 
 ҷуфти қуллаҳои онро на зиёда аз як теға (камон) пайваст кунад. 
 роҳи яктарафа вуҷуд дошта бошад. Навишти математикии чунин навъ графҳо 
 шакли G=(U,A) –ро дорад. Дар ин ҷо U-ро маҷмӯи қуллаҳо ва A-ро равиши теғаҳо
 меноманд. Бо суханщои дигар, графи равишдор гуфта, граферо меноманд, ки 
 қуллаҳои онро танҳо камонҳо пайваст мекунанд ё он танҳо аз камонҳо иборат
 бошад. 
 дода шуда бошаду дар баъзеашон не. Дар поён тасвири графикии ин навъ граф
 оварда шудааст. 
 Дар ин ҷо теғаҳои равишдор E 
 буда,теғаҳои беравиш E мебошанд. 
 мешавад. 
 баробар буда, шаклҳои гуногун дошта бошанд. 
 Тасдиқот. Графҳои изоморфӣ бо ҳамдигар баробаранд. 
 қуллаи дигар бе истифода аз қуллаи иловагӣ вуҷуд дошта бошад. Чунин навъ граф
 дорои N*(N-)/ теға мебошад. Дар ин ҷо N миқдори қуллаҳои графро ифода 
 мекунад. 
 истифода аз қуллаи иловагӣ роҳ мавҷуд набошад. 
 графи G-ро дошта, ҳангоми қуллаҳои онро ба графи G гузоштан, графи пурра 
 ҳосил шав ад. 
 вуҷуд дошта бошад. 
 гузошта шавад. Адади гузошташуда масофа, вазн ва ё дигар бузургиро ифода 
 мекунад. 
 баробар бошанд.Бо суханҳои дигар агар миқдори элементҳои ғайринулии ҳамаи
 сатрҳои матритсаи ҳамсоягии он байни ҳам баробар бошанд. 
 бошад. 
 қайдкардашуда меноманд. 
 қуллаи ҳамсогӣ номида мешавад. 
 мешавад. 
 Дар ин ҷо қуллаҳои ва ҳамсоя мебошанд. 
 мешаванд. 
 Дар ин ҷо теғаҳои ва ҳамсоя мебошанд. 
 қуллаи меноман д. 
 мешавад. 
 Дар ин ҷо қуллаи ҳалқа (петлей) мебошад. 
 меноманд. 
 мегузарад. 
 занҷирро ҳалқа меноманд. 
 ибтидоӣ ва интиҳоӣ гуногун бошанд. 
 Намоиши дискретии графҳо 
 Тасвири геометрии графҳо яке аз усулҳои маъмули татқиқи графҳо ба қисоб
 меравад, вале ин усулро наметавон дар мошинҳои ҳисобкунии истифода кард. Аз
 ин ҷо зарурати истифодаи усули дикретӣ пеш меояд. Тавассути ин усул метавон
 ҳалли ададии графро дар МЭҲ ба даст овард. Барои иҷрои ин амал усулҳои 
 гуногуну мавҷуд аст, ки асоситаринашон инҳо мебошанд: 
 ) Матритсаи ҳамсоягӣ; 
 ) Руйхати ҳамсоягӣ; 
 ) Руйхати қуллаҳо; 
 ) Матритсаи якзайлӣ; 
 ) Матритсаи вазнӣ; 
 ) Руйхати теғаҳо; 
 Матритсаи ҳамсоягӣ 
 Матритсаи ҳамсоягӣ аз матритсаҳои дигар фарқи кулли дорад, зеро 
 элементҳои он танҳо аз ва иборат мебошанд. Ин навъ матритсаҳо аз тасвири
 геометрии граф бо роҳи зерин ҳосил карда мешаванд: агар дар байни ду қулла роҳ
 мавҷуд бошад, онгоҳ элементи ба он мувофиқи матритса дорои қимати ва дар
 акси ҳол дорои қимати мешавад. Бо суханҳои дигар: 
 { 
 Барои пурратар б а х о н а н да ф а ҳ м о ш у д а н м и с о л е р о д и д а м ебароем. Бигзор
 графи равишдорои зерин дода шуда бошад. 
 Матритсаи ҳамсоягии ин граф шакли зеринро дорад: 
 Руйхати ҳамсоягӣ 
 Барои сохтани чунин руйхат ҷадвали дорои ду сутун тасвир намуда, дар
 сарлавҳаи сутуни якум қуллаҳои баромад ва дар сарлавҳаи сутуни дуввум 
 ҷуллаҳои даромад менависем. Дар сутуни якуми ҷадввали мазкур руйхати 
 қуллаҳоро навишта, дар сутуни дуввум ҳамаи роҳҳои баромад аз қуллаи ҷориро
 менависем. Руйхати ҳамсоягӣ барои графи қабли бо шакли зерин сохта мешавад:
 Қуллаи Қуллаи даромад 
 баромад,,, 
 Руйхати қуллаҳо 
 Руйхати қуллаҳо аз ҷуфти қуллаҳои ҳамсоягӣ сохта мешаванд. Барои иҷрои
 ин амал бояд, қуллаҳоро бо ягон ҳарф ишора карда сипас ҷадвали дорои се сатр
 месозем, ки дар сатри якуми ҷадвал қуллаҳои баромад, дар сатри дуввуми ҷадвал
 қуллаҳои даромад ва дар сатри сеюм дарозии теғаҳо (ишораи кардаамон) навишта
 мешавад. Бигзор графи равишдори зерин дода шуда бошад. 
 Руйхати қуллаҳои ин граф чунин сохта мешаванд. 
 a B c d E f g H 
 Матритсаи якзайлӣ 
 Баръакси матритсаҳои ҳамсоягӣ, ки квадрати буданд, матритсаи якзайли
 дорои n сатр ва m мебошад. Дар ин n миқдори қуллаҳои граф ва m миқдори 
 теғаҳои графро ифода мекунад. Матритсаи якзайли аз рӯи қулла ба теға сохта
 мешавад, на аз рӯи теға ба теға. 
 Тарзи сохтани матритсаи якзайлӣ барои графҳои равишдор ва беравиш фарқ
 мекунад. 
 Тарзи пур кардани матритсаи якзайли барои графи беравиш чунин аст: 
 Бигзор гра ф и беравиши зерин дода шуда бошад. 
 { 
 Матритсаи якзайлии онро месозем. 
 a b c d e 
 Матритсаи якзайли барои графҳои равишдор ба сурати зерин пур карда 
 мешавад: 
 { 
 Бигзор граф и рави ш д о р и з е р ин д о д а ш у д а б о ш ад. 
 Матритсаи якзайлии онро месозем. 
 a b C d e 
 - 
 - 
 - - 
 - 
 Матритсаи вазнӣ 
 Барои графҳои вазнӣ низ метавон матритса сохт. Матритсаи графҳои вазнӣ
 шакли -ро дорад, ки дар ин ҷо вазни теғаҳое, ки аз қуллаҳои i ва j-ро
 пайваст мекунанд мебошад. Агар дар теға вазн нишон дода нашуда бошад, онгоҳ
 ба сифати вазн вобаста аз шарти масъала ё навишта мешавад. Агар граф 
 пурра набошад, мувофиқи теорема аз риёзиёти дискретӣ (Дилхоҳ графи нопурраро
 метавон ба шакли пурра овард) он ба шак ли пурра оварда мешавад. Ба сифати
 мисол графи зеринро дида мебароем: 
 Аз сабаби он ки граф пурра нест, бинобар ин аввал онро ба намуди пурра
 меорем. Намуди пурраи он шакли зеринро дорад: 
 Пас аз оне, ки граф ба шакли пурра оварда шуд. Матритсаи вазнии онро
 месозем. 
 Барои ёфтани роҳи кутоҳт арин да р чунин графҳо аз алгоритми Прима 
 истифода мебарем. 
 Руйхати теғаҳо 
 Барои графҳои равишдор усули дигари намоиш вуҷуд дорад. Дар ин усул ду
 массив истифода бурда мешавад, ки дар массиви якум ибтидои теғаҳо ва дар 
 массиви дуввум интиҳои теғаҳо навишта мешаванд. Андозаи массивҳо ба миқдори
 теғаҳо баробар мебошанд. Ба сифати мисол, графи зеринро дида мебароем. 
 r=(,,,,,,, ); 
 t=(,,,,,,, ); 
 Дар ин ҷо r баромад (ибтидо)-и теғаҳо ва t даромад (интиҳо)-и теғаҳоро
 ифода мекунад. 
 Ҷустуҷӯ дар умқ (Depth-first search) 
 Яке аз усулҳои маъмули систематикии татқиқи ҳамаи қуллаҳои граф-методи
 ҷустуҷӯ дар умқ ба ҳисоб мебошад. Барои графи беравиши G=(X,U,F) ҷустуҷӯ дар
 умқ ба сурати зерин амали карда мешавад: 
 Агар дар қуллаи қарор дошта бошем ба яке аз теғаҳои (x,y) – е, ки ба
 қуллаи якзайлӣ мебошанд, ҳаракат мекунем. Агар қуллаи у аллакай аз назар
 гузаронида шуда боша д, ба х баргашта теғаи дигареро интихоб мекунем. Агар
 қуллаи у аз назар гузаронида нашуда бошад, ба он ҳаракат намуда ҷарайни 
 рекурсивиро барои он татбиқ мекунем. Агар ҳамаи теғаҳои ба қуллаи х якзайлӣ аз
 назар гузаронида шуда бошанд, қафо ба теғаи (s,x), ки аз онҷо ба х омада будем
 баргашта, амали татқиқро барои теғаҳои якзайлии қуллаи давом медиҳем. Ин 
 амал ҳамон вақт ба анҷом мерасад, агар ҳамаи теғаҳоро аз назаргузаронида дар
 қуллаи ибтидои баргардем. 
 Ҷустуҷӯ дар умқро инчунин метавон барои графҳои равишдор низ анҷом 
 дод. Бигзор дар гиреҳи х-и графи равиҳдор қарор дошта бошем. Теғаи (x,y) (теғае,
 ки аз х мебарояд) ро интихоб карда, ҳамаи теғаҳои аз у баромадаро татқиқ карда
 қафо ба теғаи х бармегардем. Ва онҷо теғаи дигарро интихоб карда ин амалро
 барои он низ анҷом медиҳам. Ба ҳамин монанд теғаҳои граф татқиқ карда 
 мешаванд. 
 Барои ба хонанда пурратар фаҳмо шудан мисолеро дида мебароем. Бигзор
 графи беравиши зерин дода шуда бошад. 
 Дар қадами якум ба ҳамаи қуллаҳои граф нишонаи мегузорем. 
 Ба сифати қуллаи ибтидои қуллаи -ро интихоб мекунем ва ба он нишонаи 
 мегузорем. Ин нишондиҳандаи он аст, ки татқиқ аз онҷо оғоз гардидааст. 
 Дар қадами сеюм теғае, ки ба қуллаи пайваст буда, дорои рақами тартибии
 хурдтарин мебошад интихоб мекунем. Дар ҳолати мо ин қуллаи -ум мебошад. Ба
 қуллаи мазкур нишонаи мегузорем. 
 Акнун амали ҷустуҷӯро аз қуллаи оғоз мекунем. Барои ин теғае, ки қуллаи
 -умро бо қуллаи нишонанагузоштаи рақами тартибиаш хурдтарин пайваст 
 мекунад интихоб мекунем. Дар ҳолати мо ин қуллаи мебошад. Ба қуллаи 
 интихобкардаамон нишонаи мегузорем. Пас аз ин амал теғаи (, ) 
 азназаргузаронидашуда ба ҳисоб меравад. 
 Амали ҷустуҷӯро аз қуллаи оғоз мекунем. Аз он танҳо як теға (,) 
 мебарояд. Аз дигар тараф қуллаи аллакай дорои нишона мебошад, бинобар ин
 зарур аст, ки теғаи (,) баракс гузошта шавад. Чунин теға бо тире-тире ишора
 карда мешавад. 
 Ба қуллае, ки аз онҷо ба қуллаи омада будем бармегардем. Ин қулла 
 мебошад. Аз ин қулла ягон теғаи бенишона намебарояд. Аз ин ҷо ба қуллаи 
 бармегардем. Амали татқиқро аз ин қулла оғоз мекунем. Аз онҷо танҳо як теғаи
 бенишона (, ) мебарояд. Аз ин ҷо қуллаи дорои нишонаи мегардад. 
 Амали ҷустуҷӯро аз қуллаи оғоз мекунем. Аз ин қулла танҳо як теғаи
 бенишона (, ) мебарояд. Аз ин ҷо барои қуллаи нишонаи мегузорем. 
 Аз сабаби оне, ки аз қуллаи ягон теғаи бенишона намебарояд, бинобар ин,
 ба қуллаи бармегардем. Аз қуллаи низ ягон теғаи бенишона намебарояд. Аз
 онҷо ба қуллаи ки амали ҷустуҷӯро аз он оғоз карда будем, яъне қуллаи 
 бармегардем. Ва ба ҳамин алгоритм корашро ба анҷом мерасонад. 
 Татбиқи алгоритми ҷустуҷӯ дар умқ 
 Барои татқиқи алгоритми ҷустуҷӯ дар умқ аввал матритсаи ҳамсоягии 
 графро, ки шакли зеринро дорад менависем. 
 Барои татбиқи методи ҷустуҷӯ дар умқ як массив барои нишона ва як пушта
 истифода бурда мешавад. Дар қадами нахуст массиви нишона ва пуштаро эҷод 
 мекунем. 
 Массиви нишона 
 Рақами тартибӣ 
 Элемент 
 Пушта 
 Рақами тартибӣ 
 Элемент - - - - - 
 Қаблан дар ҳолати графики мо барои татқи аз қуллаи оғоз карда будем,
 бинобар ин, рақами тартибии онро ба пушта гузошта барои он нишонаи 
 мегузорем. 
 Массиви нишона 
 Рақами тартибӣ 
 Элемент 
 Пушта 
 Рақами тартибӣ 
 Элемент - - - - 
 Дар қадами сеюм теғаеро, ки қуллаи якро пайваст намуда, дорои рақами
 тартибии хурдтарин мебошавад ва то ҳол дорои нишона намебошад интихоб 
 мекунем. Дар ҳолати мо ин қуллаи қуллаи -ум мебошад. Қуллаи -ро ба пушта
 гузошта, ба он нишонаи ду мегузорем 
 Массиви нишона 
 Рақами тартибӣ 
 Элемент 
 Пушта 
 Рақами тартибӣ 
 Элемент - - - 
 Дар ин ҳолат теғаи (,) азназаргузаронидашудаи роста ба ҳисоб рафта, дар
 бурриши сатри якум ва сутуни -уми матритсаи ҳамсоягӣ рақами якро ба ду иваз
 мекунем. 
 Амали ҷустуҷӯро аз қуллаи -ум оғоз мекунем. Сатри сифруми матритсаи
 ҳамсоягиро аз назар мегузаронем. Дар ин сатр элементи якуми ба баробарро
 пайдо мекунем. Дар ҳолати мо ин элемент дар сутуни дуюм мехобад. Аз ин ҷо
 қуллаи дуввумро ба пушта гузошта, ба он нишонаи мегузорем. 
 Массиви нишона 
 Рақами тартибӣ 
 Элемент 
 Пушта 
 Рақами тартибӣ 
 Элемент - - 
 Пас аз ин сатри сеюми (рақами ) матритсаро аз назар мегузаронем. Дар ин
 ҷо элементи Graf[][]= мебошад. Ин нишондиҳандаи теғаест, ки қуллаи ва -ро
 пайваст мекунад, вале аз сабаби оне, ки қуллаи аллакай азназар гузаронидашуда
 мебошад, бинобар ин зарур аст, ки қуллаи аз пушта нест карда шавад. Пас аз ин
 ишорагари қуллаҳо як катакча ба тарафи чап кучонида мешавад. 
 Рақами тартибӣ 
 Элемент - - - 
 Дар ин ҳолат теғаи (, ) баракс ҳисобида мешавад. Агар теғаи қуллаи i ва j-
 ро бо ҳам пайвасткунанда баракс бошад, онгоҳ элементи мувофиқи сатри i ва
 сутуни j-уми матритсаи ҳамсоягӣ ба иваз карда мешавад. 
 Ба ҳамин монанд амали ҷустуҷӯро аз қуллаи -ум оғоз мекунем. Аз сабаби
 оне, ки аз қуллаи -ум ягон теғаи бенишона намебарояд, ба қафо ба қуллаи -ум
 бармегардем. Дар ин ҳолат низ аз пушта як элементи дигарро низ нест мекунем.
 Дар натиҷаи ин амал пушта шакли зеринро мегирад. 
 Рақами тартибӣ 
 Элемент - - - - 
 Сатри якуми матритсаи ҳамсогиро аз назар мегузаронем. Дар ин сатр 
 элементи сутуни шашум ба баробар мебошад. Бинобар ин, қуллаи ба пушта
 гузошта шуда, дорои нишонаи мегардад. Пас аз ин амал граф ва пуштаамон 
 шакли зеринро мегиранд. 
 Массиви нишона 
 Рақами тартибӣ 
 Элемент 
 Пушта 
 Рақами тартибӣ 
 Элемент - - - 
 Акнун сатри сеюми матритсаи ҳамсоягиро аз назар мегузаронем. Дар ин сатр
 элементи сутуни -ум ба як баробар мебошад. Аз ин ҷо қуллаи ба пушта гузошта
 шуда, қуллаи -ум дорои нишонаи мегардад. 
 Массиви нишона 
 Рақами тартибӣ 
 Элемент 
 Пушта 
 Рақами тартибӣ 
 Элемент - - 
 Акнун қуллаи чорумро аз назар мегузаронем, аз онҷо ягон теғаи бенишона
 намебарояд, бинобар ин аз он аз пушта нест карда мешавад. 
 Пушта 
 Рақами тартибӣ 
 Элемент - - - 
 Аз қуллаҳои ва як низ ягон теғаи бенишона намебарояд, бинобар ин онҳо
 низ аз пушта нест карда мешаванд. 
 Пас аз иҷрои ин амалҳо пушта холӣ карда мешавад. Ба ҳамин монанд мо ба
 қуллаи ибтидоӣ бармегардем. Дар охир матритсаи ҳамсоягӣ шакли зеринро 
 мегирад: 
 Дар охир ба намуди ҷамъбасти алгоритми ҳосил намудани матритсаи 
 ҳамсоягии натиҷавиро меорем, ки шакли зеринро дорад: 
 Пас аз ш и нос ш у д а н б а м о ҳ и я т и а л го р и т м д а р м и с о л е т а т б и қ и о нр о меорем.
 { 
 #include <iostre a m > 
 using namespace std; 
 const int n=; 
 int i, j; 
 bool *visited=new bool[n]; 
 //матритсаи ҳамсоягии граф 
 int graph[n][n] = 
 { 
 {,,,, }, 
 {,,,, }, 
 {,,,, }, 
 {,,,, }, 
 {,,,, } 
 }; 
 void DFS(int st) { 
 int r; 
 cout<<st+<<" "; 
 visited[st]=true; 
 for (r=; r<=n; r++) 
 if ((graph[st][r]!=) && (!visited[r])) 
 DFS(r); 
 } 
 //Функсияи асосӣ 
 int main() 
 { 
 int start; 
 cout<<"матритсаи ҳамсоягии граф: "<<endl; 
 for (i=; i<n; i++) 
 { 
 visited[i]=false; 
 for (j=; j<n; j++) 
 cout<<" "<<graph[i][j]; 
 cout<<endl; 
 } 
 cout<<"теғаи ибтидоӣ” >> "; cin>>start; 
 // Массиви теғаҳое, ки тавассути онҳо ҳаракат карда шудааст.. 
 bool *vis=new bool[n]; 
 cout<<"тартиби ҷустуҷӯ: "; 
 DFS(start-); 
 delete []visited; 
 system ("pause"); 
 return; 
 } 
 Ҷустуҷӯ дар васеъгӣ 
 Ҷустуҷӯ дар васеъги яке аз методҳои маъмули тадқиқи теға ва қуллаҳои
 граф ба ҳисоб меравад. Методи мазкурро бо мисоле дида мебароем. Бигзор 
 графи беравиши зерин дода шуда бошад. 
 Пеш аз оғози татқиқи граф ба ҳар як қуллаи он ягон нишона мегузорем.
 Бигзор ин нишона бошад. Пас аз ин гарфамон шакли зеринро мегирад: 
 Пас аз ин қуллаи ибтидои (қуллае, ки бояд татқиқро аз он оғоз кунем)-ро
 интихоб мекунем. Барои намуна қуллаи нолумро интихоб мекунем. Пас аз 
 интихоби қуллаи ибтидоӣ барои он ва барои ҳамаи қуллаҳои аз бароянда 
 нишонаи мегузорем. Дар натиҷа графамон шакли зеринро мегирад: 
 Пас аз ин амал қуллаҳои ва дорои нишонаи мегарданд. Акнун 
 падарпай қуллаҳои дорои нишонаи -ро аз назар гузаронида барои қуллаҳои аз
 онҳо бароянда нишонаи мегузорем. Пас аз анҷоми ин амал графамон шакли 
 зеринро мегирад. 
 Пас аз иҷрои ин амал қуллаҳои ва дорои нишонаи мешаванд. Баъд аз
 ин қуллаҳои аз ва баромадаро татбиқ мекунем. Аз сабаби оне, ки ҳамаи 
 қуллаҳо аллакай аз назар гузаронида шудаанд, алгоритм корашро ба охир 
 мерасонад. 
 Пас аз анҷоми кори алгоритм ҳар як қулла дорои нишонаи худ мегардад.
 Амалисозии ин алгоритм дар барнома ба сурати зерин аст: 
 ) Матритсаи ҳамсоягии графи додашударо месозем, ки он шакли зеринро
 дорад: 
 ) Барои нигоҳ доштани нишонаи қуллаҳои граф вобаста ба миқдори 
 қуллаҳо як массив муаррифӣ мекунем. Тавре ки аз расмҳо дидам дар қадами 
 нахустин ба ҳамаи қуллаҳои граф нишонаи бахшида шуда буд. Ба ҳамин 
 монанд ҳангоми амалисозии алгоритм дар қадами нахустин ба сифати қимати 
 ибтидои барои элементҳои массив ягон адади ба қадри кифоя калонро 
 мебахшем. 
 Массиви нишона 
 Рақами тартибӣ 
 Элемент 
 Илова бар ин як саф низ мураррифӣ мекунем, ки нишонаи қуллаи ҷориро 
 дар худ нигоҳ дорад. Дар ибтидо сафро холӣ мегузорем. 
 Рақами тартибӣ 
 Элемент - - - - - 
 Пас аз ин амал зарур аст, ки қуллаи ибтидоиро барои татқиқ интихоб кунем. Ба
 сифати қуллаи ибтидоӣ метавон дилхоҳ қулларо интихоб кард. Барои намуна 
 қуллаи нолумро интихоб мекунем. Пас аз интихоб намудани қуллаи ибтидоӣ, ба
 он нишонаи гузошта, рақами тартибии онро ба саф мегузорем. 
 Массиви нишона 
 Рақами тартибӣ 
 Элемент 
 саф 
 Рақами тартибӣ 
 Элемент - - - - 
 Акнун сатри сифруми матритсаи ҳамсоягиро аз назар мегузаро-нем. Агар 
 дар ин сатр ягон элементи ғайринулӣ пайдо шавад, онгоҳ рақами тартибии он ба
 саф гузошта мешавад. Барои ҳолати мо ин қуллаҳои ва ба саф гузошта шуда,
 дорои нишонаи мегарданд. Аз ин ҷо массиви нишона ва саф шакли зеринро 
 мегиранд. 
 саф 
 Рақами тартибӣ 
 Элемент 
 Массиви нишона 
 Рақами тартибӣ 
 Элемент 
 Пас аз ин амал элементи аз саф нест карда шуда, ишорагари элементи
 якум як катакча ба пеш кӯчонида мешавад. Акнун атрофи қуллаҳои ва –ро аз
 назар мегузаронем. Агар ягон элементи сатри якуми матритсаи ҳамсоягӣ ба нул
 баробар набошад, онгоҳ рақами тартибии он ба саф гузошта мешавад. Дар 
 ҳолати мо қуллаҳои, ва ба саф гузошта шуда, дорои нишонаи мегарданд.
 саф 
 Рақами тартибӣ 
 Элемент 
 Массиви нишона 
 Рақами тартибӣ 
 Элемент 
 Пас аз ин амал элементи аз саф нест карда шуда, ишорагари саф як хона
 ба тарафи пеш кӯчонида мешавад. 
 Акнун қуллаи дуюми матритсаро аз назар мегузаронем. Аз сабаби оне, ки
 дар атрофи он ягон қуллаи бе нишона вуҷуд надорад, элементи аз саф нест
 карда мешавад ва ишорагари элементи якум як катакча ба тарафи рост кӯчонида
 мешавад. Ба ҳамин монанд атрофи қуллаҳои ва низ аз назар гузаронида 
 мешаванд. Аз сабаби оне, ки дар атрофи ин қуллаҳо қуллаи бенишона вуҷуд 
 надорад, пайдарпай ин қуллаҳо аз саф нест карда мешаванд. 
 Пас аз назаргузаронии ҳамаи теғаҳо саф холӣ гардида кори алгоритм ба
 охир мерасад. 
 Барои ба хонанда пурратар фаҳмо шудан барномаи ин равиш дар поён 
 оварда шуддааст. 
 #include <iostream> 
 using namespace std; 
 const int n=; 
 int i, j; 
 //матритсаи ҳамсоягии граф 
 int GM[n][n] = 
 { 
 {,,,,}, 
 {,,,,}, 
 {,,,,}, 
 {,,,, }, 
 {,,,,}, 
 }; 
 void BFS(bool *passed, int unit) 
 { 
 //навбат 
 int *queue=new int[n]; 
 //ишорагари навбат 
 int count, head; 
 for (i=; i<n; i++) queue[i]=; 
 count=; head=; 
 queue[count++]=unit; 
 passed[unit]=true; 
 while (head<count) { 
 unit=queue[head++]; 
 cout<<unit+<<" "; 
 for (i=; i<n; i++) 
 if (GM[unit][i] &&!passed[i]) { 
 queue[count++]=i; 
 passed[i]=true; 
 } 
 } 
 delete []queue; 
 } 
 //Функсияи асосӣ 
 int main(){ 
 int start; 
 cout<<"Қуллаи ибтидоиро дохил кунед >> "; cin>>start; 
 // Массиви теғаҳое, ки тавассути онҳо ҳаракат карда шудааст.. 
 bool *vis=new bool[n]; 
 cout<<"матритсаи ҳамсоягии граф: "<<endl; 
 for (i=; i<n; i++) 
 { 
 vis[i]=false; 
 for (j=; j<n; j++) 
 cout<<" "<<GM[i][j]; 
 cout<<endl; 
 } 
 cout<<" тартиби ҷустуҷӯ: "; 
 BFS(vis, start-); 
 delete []vis; 
 return; 
 } 
 Сохтони роҳи кутоҳтарин 
 Масъалаҳои сохтани роҳи кутоҳтарин, яке аз масъалаҳои муҳиме ба ҳисоб
 меравад. Масалан бигзор N шаҳр мавҷуд аст. Барои ҳар ҷуфти шаҳрҳо (I,J) 
 метавон роҳ сохт, ки ин шаҳрҳоро бо ҳамдигар бе гузаштан аз шаҳри дигар 
 пайваст кунад. Нархи чунин роҳ ба A(I,J) баробар мебошад. 
 Барномае нависед, ки аз ҳама роҳи арзонтаринро муайян кунад. Ин 
 алгоритм иҷозати аз дилхоҳ шаҳр гузаштан ба шаҳри дигарро бе истифода аз 
 шаҳри дигар фароҳам орад. Барои ҳалли чунин масъала, зарур аст, ки аз 
 графҳои вазндор истифода бурда шавад. 
 Барои ёфтани роҳи кутоҳтарин аз алгоритми Дейскри истифода мекунем. 
 Барои пурратар ба моҳияти ин масъала шинос шудан, аввал ин шаҳрҳоро 
 ба сурати граф тасвир мекунем. 
 Бигзор зарурати муайян намудани роҳи кутоҳтарини байни қуллаҳои ва
 пеш ояд. Барои ин аввал матритсаи вазнии (ҳамсоягии) графро месозем, ки
 шакли зеринро дорад: 
 Ин масъаларо бо истифода аз алгоритми Дейскри ҳал мекунем. Барои ин 
 алгоритм аз ду массив бо номҳои Label ва Active истифода мебарем. Ба сифати
 элемент дар массиви Label[i] масофа аз қуллаи ибтидоӣ то қуллаи i-юмро нигоҳ
 медорем. Дар массиви Active бошад, нишонаи қуллаҳои аз 
 назаргузаронидашуда нигоҳ дошта мешаванд. Аз сабаби онки қуллаи ибтидои
 мебошад, пас сифати элементи якум дар массиви Active нишонаи мегузорем.
 Массиви Active 
 Рақами тартибӣ 
 Элемент 
 Массиви Label 
 Рақами тартибӣ 
 Элемент 
 Аз қуллаи се теға мебарояд: (, ), (, ) ва (, ). Агар барои ягонто аз
 қуллаҳои ёфташуда шарти Label[j]>Label[i]+Graf[i][j] иҷро гардад, пас ин қулла
 азназаргузаронидашуда ба ҳисоб рафта,элементҳои массифаи нишона чунин 
 пур карда мешаванд: 
 Label[j]=Label[i]+Graf[i][j]; 
 Барои ҳолати мо: 
 ) Label[]>Label[]+Graf[[] => > +. Пас аз ин ҷо 
 Label[]=Label[]+Graf[[]=+=. 
 ) Label[]>Label[]+Graf[[] => > +. Пас аз ин ҷо 
 Label[]=Label[]+Graf[[]=+=. 
 ) Label[]>Label[]+Graf[[] => > +. Пас аз ин ҷо 
 Label[]=Label[]+Graf[[]=+=. 
 Пас аз ин амал массивҳои мо шакли зеринро мегиранд: 
 Массиви Active 
 Рақами тартибӣ 
 Элемент 
 Массиви Label 
 Рақами тартибӣ 
 Элемент 
 Пас аз ин амал графамон шакли зеринро мегирад. 
 Амали ҷустуҷӯ аз қуллае, ки нишонаи хурдтарин дорад, оғоз карда 
 мешавад. Ин қуллаи -юм мебошад. Аз ин қуллаи се теға (, ), (, ), (, )
 мебарояд. Барои ин қуллаҳо низ шарти 
 Label[j]>Label[i]+Graf[i][j]-ро месанҷем. 
 ) Label[]>Label[]+Graf[[] => < +. Аз сабаби оне, ки шарт иҷро
 намегардад, бинобар ин, қуллаи бетағйир гузошта мешавад. 
 ) Label[]>Label[]+Graf[[] => > +. Пас аз ин ҷо 
 Label[]=Label[]+Graf[[]=+=. 
 ) Label[]>Label[]+Graf[[] => > +. Аз сабаби оне, ки шарт иҷро
 намегардад, бинобар ин, қуллаи бетағйир гузошта мешавад. 
 Пас аз ин амал массивҳои мо шакли зеринро мегиранд: 
 Массиви Active 
 Рақами тартибӣ 
 Элемент 
 Массиви Label 
 Рақами тартибӣ 
 Элемент 
 Пас аз ин амал графамон шакли зеринро мегирад. 
 Амали ҷустуҷӯро аз қуллаи оғоз мекунем. Аз ин қулла се теға(, ), (,
 ) ва (, ) мебарояд.. Агар барои ягонто аз қуллаҳои ёфташуда шарти 
 Label[j]>Label[i]+Graf[i][j] иҷро гардад, пас ин қулла азназаргузаронидашуда ба
 ҳисоб рафта, элементҳои массиви нишона чунин пур карда мешаванд: 
 Label[j]=Label[i]+Graf[i][j]; 
 Барои ҳолати мо: 
 ) Label[]>Label[]+Graf[[] => > +. Аз сабаби оне, ки шарт иҷро
 намегардад, бинобар ин, қуллаи бетағйир гузошта мешавад. 
 ) Label[]>Label[]+Graf[[] => > +. Аз сабаби оне, ки шарт иҷро
 намегардад, бинобар ин, қуллаи бетағйир гузошта мешавад. 
 ) Label[]>Label[]+Graf[[] => > +. Аз сабаби оне, ки шарт иҷро
 намегардад, бинобар ин, қуллаи бетағйир гузошта мешавад. 
 Ба ҳамин монанд дар массиви Label ҳеҷ тағйирот ба вуҷуд намеояд, вале
 массиви Active шакли зеринро мегирад: 
 Массиви Active 
 Рақами тартибӣ 
 Элемент 
 Амали ҷустуҷӯро аз қуллаи аз назаргузарондашудаи дорои қимати 
 хурдтарин оғоз мекунем, ин қуллаи -юм мебошад. Аз ин қуллаи ду теға (,) ва
 (,) мебарояд. Барои ин қуллаҳо низ шарти Label[j]>Label[i]+Graf[i][j]-ро
 месанҷем. 
 ) Label[]>Label[]+Graf[[] => >+. Аз сабаби оне, ки шарт иҷро
 намегардад, бинобар ин, қуллаи бетағйир гузошта мешавад. 
 ) Label[]>Label[]+Graf[[] => > +. Аз сабаби оне, ки шарт иҷро
 намегардад, бинобар ин, қуллаи бетағйир гузошта мешавад. 
 Ба ҳамин монанд дар массиви Label ҳеҷ тағйирот ба вуҷуд намеояд, вале
 массиви Active шакли зеринро мегирад: 
 Массиви Active 
 Рақами тартибӣ 
 Элемент 
 Амали ҷустуҷӯро аз қуллаи аз назаргузарондашудаи дорои қимати 
 хурдтарин оғоз мекунем, ин қуллаи -юм мебошад. Аз ин қуллаи се теға (, ),
 (, ), (, ) мебарояд. Барои ин қуллаҳо низ шарти Label[j]>Label[i]+Graf[i][j]-
 ро месанҷем. 
 ) Label[]>Label[]+Graf[[] => >+. Аз сабаби оне, ки шарт иҷро
 намегардад, бинобар ин, қуллаи бетағйир гузошта мешавад. 
 ) Label[]>Label[]+Graf[[] => > +. Аз сабаби оне, ки шарт иҷро
 намегардад, бинобар ин, қуллаи бетағйир гузошта мешавад. 
 ) Label[]>Label[]+Graf[[] => > +. Пас аз ин ҷо 
 Label[]=Label[]+Graf[[]=+=. 
 Ба ҳамин монанд дар массиви Label ҳеҷ тағйирот ба вуҷуд намеояд, вале
 массиви Active шакли зеринро мегирад: 
 Массиви Active 
 Рақами тартибӣ 
 Элемент 
 Амали ҷустуҷӯро аз қуллаи аз назаргузарондашудаи дорои қимати 
 хурдтарин оғоз мекунем, ин қуллаи -юм мебошад. Аз ин қуллаи се теға (,),
 (,), (,) мебарояд. Барои ин қуллаҳо низ шарти Label[j]>Label[i]+Graf[i][j]-ро
 месанҷем. 
 ) Label[]>Label[]+Graf[[] => >+. Аз сабаби оне, ки шарт иҷро
 намегардад, бинобар ин, қуллаи бетағйир гузошта мешавад. 
 ) Label[]>Label[]+Graf[[] => >+. Аз сабаби оне, ки шарт иҷро
 намегардад, бинобар ин, қуллаи бетағйир гузошта мешавад. 
 ) Label[]>Label[]+Graf[[] => > +. Аз сабаби оне, ки шарт иҷро
 намегардад, бинобар ин, қуллаи бетағйир гузошта мешавад. 
 Пас аз ин амал массивҳои мо шакли зеринро мегиранд: 
 Массиви Active 
 Рақами тартибӣ 
 Элемент 
 Массиви Label 
 Рақами тартибӣ 
 Элемент 
 Пас аз ин амал графамон шакли зеринро мегирад. 
 Амали ҷустуҷӯро аз қуллаи аз назаргузарондашудаи дорои қимати 
 хурдтарин оғоз мекунем, ин қуллаи -юм мебошад. Аз ин қуллаи ду теға (,) ва
 (,) мебарояд. Барои ин қуллаҳо низ шарти Label[j]>Label[i]+Graf[i][j]-ро
 месанҷем. 
 ) Label[]>Label[]+Graf[[] => >+. Аз сабаби оне, ки шарт иҷро
 намегардад, бинобар ин, қуллаи бетағйир гузошта мешавад. 
 ) Label[]>Label[]+Graf[[] => >+. Аз сабаби оне, ки шарт иҷро
 намегардад, бинобар ин, қуллаи бетағйир гузошта мешавад. 
 Ба ҳамин монанд дар массиви Label ҳеҷ тағйирот ба вуҷуд намеояд, вале
 массиви Active шакли зеринро мегирад: 
 Массиви Active 
 Рақами тартибӣ 
 Элемент 
 Аз сабаби оне, ки дар массиви Active ягон элементи ба баробар боқӣ
 намонд, бмноба ин, алгоритм дар ин ҷо корашро ба анҷом мерасонад ва роҳи 
 кутоҳтарин баробар аст ба Label[]=. 
 #include <iostream> 
 using namespace std; 
 int min(int x, int y){ 
 return ((x)<(y)?(x):(y)); 
 } 
 int mass[][]; // массиви вазн 
 int i,j,N,M,W; 
 int a,b,c; 
 int start,end; 
 //массиве, ки дар он роҳи кутоҳтарин нигоҳ дошта мешавад (Label). 
 int D[]; 
 int used[]; 
 int short_way (int start, int end); 
 int main() { 
 cin>>N>>M; // миқдори теға ва қуллаҳои граф 
 //дар аввал матритсаро бо ададҳои калон пур мекунем 
 for ( i =; i <=N; i++) 
 for ( j =; j <= N; j++) { 
 mass[i][j]=; 
 mass[j][i]=; 
 } 
 //дохил намудани рақами теғаҳо ва масофаи байни онҳо. 
 for (i =; i <= M; i ++ ) { 
 cin>>a>>b>>c; 
 mass[a][b]=c; 
 mass[b][a]=c; 
 } 
 //Хориҷ намудани матритсаи ҳамсоягӣ. 
 cout<<" Matrix hamsoya:"<<endl; 
 for ( i =; i <= N; i++){ 
 for ( j =; j <= N; j++) 
 cout<<mass[i][j]<<" "; 
 cout<<endl; 
 } 
 cout<<"Enter the first and the last point: "; 
 cin>>start>>end; 
 cout<<"\The shortest way is: \n"<<short_way(start,end); 
 getch (); 
 return; 
 } 
 //Зербарнома, барои ёфтани роҳи кутоҳтарин бо истифода аз 
 // алгоритми Дейскрӣ 
 int short_way (int start, int end) 
 { 
 /* Истифодаи алгоритми Дейскрӣ*/ 
 for ( i =; i <= N; i++) 
 used[i]= 
 for( i =; i <=N; i++) 
 D[i] = mass[start][i];// массив барои нигоҳ доштани роҳи 
 // кутоҳтарин аз қуллаи start то қуллаи i 
 used[start] =; //; // истодан дар аввали роҳ. 
 for( i =; i <= N-; i++) 
 { 
 int min_v =; 
 for (j =; j <= N; j++ ) 
 if (used[j]== && D[j]< min_v) /*агар ҳанӯз дар қуллаи 
 j ҳаракат накарда бошем ва қимати қуллаи j хурд аз қимати пешина 
 бошад, онгоҳ ба min_v қимати хурдтарин ва ба W рақами қуллаи дорои 
 қимати хурдтаринро мебахшем.*/ 
 { 
 min_v = D[j]; 
 W = j; 
 } 
 used[W]=; 
 for( j =; j <= N; j++) 
 if (used[j]==) 
 // роҳи кутоҳтаринро интихоб мекунем. 
 D[j]=min( D[j], D[W] + mass [W][j]; 
 if (start == end) 
 D[end]=; 
 return D[end]; 
 } 
 return; 
 } 
 Намунаи ҳалли мисолҳо 
 ) Барномае нависед, ки пурра будани графро муайян кунад. 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 int **graf; 
 int n, k, i, j; 
 cin>>n; 
 graf=new int *[n]; 
 for( i=; i<n; i++) 
 graf[i]=new int[n]; 
 for( i=; i<n; i++) 
 for ( j=; j<n; j++) 
 graf[i][j]=; 
 for (k=; k<n; k++) 
 { 
 cin>>i>>j; 
 graf[i][j]=; 
 } 
 k=; 
 for( i=; i<n; i++) 
 for ( j=; j<n; j++) 
 if (graf[i][j]!=) 
 k++; 
 if (k==(n*(n-)/)) 
 cout<<"graf purra meboshad"; 
 else 
 cout<<"graf nopurra meboshad"; 
 cout<<"graf eileri nameboshad"; 
 return; 
 } 
 ) Барномае нависед, ки эйлери будани графро муайян кунад. 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 int **graf; 
 int n, k, i, j, one=; 
 cin>>n; 
 graf=new int *[n]; 
 for( i=; i<n; i++) 
 graf[i]=new int[n]; 
 for( i=; i<n; i++) 
 for ( j=; j<n; j++) 
 graf[i][j]=; 
 for (k=; k<n; k++) 
 { 
 cin>>i>>j; 
 graf[i][j]=; 
 } 
 k=; 
 for( i=; i<n; i++) 
 for ( j=; j<n; j++) 
 if (graf[i][j]==) 
 one; 
 if (one %==) 
 { 
 cout<<"graf eileri meboshad"; 
 return; 
 } 
 cout<<"graf eileri nameboshad"; 
 return; 
 } 
 Графи зерин дода шудааст. Барномае нависед, ки дар он занҷири Эйлерро
 муайян кунад. 
 Дарахтҳо 
 Дарахтҳо низ яке аз шаклҳои графи бе ҳалқа мебошанд, ки дар аксар 
 фаъолиятҳои компютерӣ корбурди зиёд доранд. Бо суханҳои дигар графи 
 алоқанок дарахт номида мешавад, агар барои он шарти Р-А= иҷро градад. Дар
 ин ҷо Р-миқдори қуллаҳо, А-миқдори теғаҳо мебошад. Дилхоҳ графи дорои n 
 қулла, ҳатман n--то теға дорад. Ҳар як гиреҳи дарахт метавонад дорои якчанд
 ишорагар бошад. Намунае аз дарахтҳо дар поён оварда шудааст. 
 Дар ин ҷо ҳар як доира як гиреҳ ва ҳар як хат як пайванд (ишорагар) ном
 дорад. Дар ин дарахт баъзе гиреҳҳо дорои як пайванд ва баъзеашон дорои ду ва
 баъзеашон дорои се пайванд мебошанд. 
 Дарахтҳое, ки ҳар як гиреҳи онҳо дорои ду пайванд мебошад, дарахтҳои
 дӯӣ номида мешаванд. 
 Дар ин ҷо мо фақат дарахтҳои дӯиро мавриди баҳс қарор медиҳем. 
 Дарахтҳои дӯӣ 
 Дарахтҳои дӯӣ дарахтҳое ҳастанд, ки ҳар гиреҳи он ҳадди аксар дорои ду
 пайванд мебошад. Асоси бисёр бозиҳои компютерӣ дар асоси ин навъ дарахтҳо
 сохта мешаванд. Намунаи дарахти дӯӣ шакли зеринро дорад: 
 Дарахтҳои компютерӣ баракси дарахтҳои маъмулӣ мебошанд, бинобар ин 
 реша дар боло нишон дода мешавад. Аз ин ҷост, ки аввалин гиреҳи дарахтро 
 решаи дарахт меноманд. Яке аз намуди маъмули дарахтҳои дӯӣ ин дарахтҳои 
 дӯии ҷустуҷӯи мебошанд. Дар дарахтҳои дӯӣ додаҳо аз рӯи қоидаи зерин нигоҳ
 дошта мешаванд: 
 ) Аввалин додои дохилкардашуда дар реша қарор мегирад; 
 ) Додаи дуюми бо реша муқоиса карда мешавад, чунончи агар аз реша 
 калон бошад дар тарафи рости он, вагарна дар тарафи чапи он қарор мегирад.
 ) Иттилооти баъдӣ монанди додаи дуввум бо реша муқоиса карда 
 мешавад, чунончи агар аз он калон бошад, дар тарафи рости реша ва дар акси
 ҳол дар тарафи чап қарор мегирад. 
 ) Элементҳои баробар дар дарахти дӯӣ қарор намегиранд. 
 Ҳар гиреҳе, ки дорои ду шоха мебошад, ҳамчун реша фаҳмида мешавад. 
 Барои ошнои бо ин шева, равиши дар дарахт нигоҳ доштани ададҳои зеринро 
 дида мебароем. 
 Амали гузоштани ададҳо дар дарахти дӯӣ аз ин расм баръало маълум 
 буда, ҳоҷат ба шарҳу тавзеҳ нест. 
 Сохтори гиреҳи дарахти дӯӣ 
 Ҳар гиреҳи дарахти дӯӣ монанди гиреҳи листи дупайвандӣ аз як бахши 
 иттилоот ва ду бахши ишорагар ташкил шудааст, ки як пайванд ба зердарахти
 тарафи чап ва як пайванд ба зердарахти тарафи рост ишорага мекунад. Сохтори
 умумии як гиреҳи дарахти дӯӣ шакли зеринро дорад: 
 Дар ин ҷо tree_name –номи дарахт, type- дилхоҳ навъ ва information_name
 номи додаи вобаста ба type буда, *left ва *right ишорагари пайванди рост ва
 чап мебошанд. 
 struct tree_name { 
 type information_name; 
 tree_name *left; 
 tree_name *right; 
 } 
 Мисол муарифии дарахтии дӯи барои ададҳои бутун: 
 struct tree { 
 int data; 
 tree *left; 
 tree *right; 
 } 
 Пас аз муаррифии гиреҳи дарахти дӯӣ, зарурати барои он ҷудо намудани
 ҳофиза пеш меояд. Ин амал тавассути оператори new иҷро карда мешавад. 
 Тавре ки қаблан зикр карда будем, аввалин гиреҳи дарахт реша маҳсуб шуда,
 гиреҳҳои баъди ба тарафи чап ва ё рости он қарор мегиранд. Бигзор a ва b ду
 ишораге аз навъи дарахти tree буда, а ба решаи дарахи ишора мекунад. Ин 
 тағйирёбандаҳо ба сурати зерин ба ҳамдигар пайваст карда мешаванд. 
 a->right=NULL; 
 a->left=NULL; 
 if (b==NULL) 
 b=a; 
 else if(a->data>b->data) 
 b->right=a; 
 else 
 b->left=a; 
 Мисол. Барномае нависед, ки амали (зербарномаи) гузоштан ва хориҷ 
 намудани элементҳои дарахти дӯиро доро бошад. 
 #include <iostream> 
 #include<windows.h> 
 using namespace std; 
 struct TreeNode 
 { 
 int Data; //қимати гиреҳ 
 TreeNode *left; //ишорагар ба шохаҳои қаблӣ ва баъдӣ 
 TreeNode *right; 
 }; 
 //Иловакунии гиреҳ 
 void Add(int aData, TreeNode *&aTreeNode) 
 { 
 //Агар шоха мавҷуд набошад, онро сохта ба он қимат мебахшем 
 if (!aTreeNode) 
 { 
 aTreeNode = new TreeNode; 
 aTreeNode->Data = aData; 
 aTreeNode->left =; 
 aTreeNode->right =; 
 return; 
 } 
 else //дар ҳолати акс 
 if (aTreeNode->Data>aData) 
 { // Агар он қимати он аз қимати шохаи ҷори хурд бошад, 
 //дар тарафи чап навишта мешавад. 
 Add(aData, aTreeNode->left); 
 } 
 else 
 { //Дар ҳолати акс дар тарафи рост 
 Add(aData, aTreeNode->right); 
 }; 
 } 
 void FreeTree(TreeNode *aTreeNode) 
 { 
 if (!aTreeNode) return; 
 FreeTree(aTreeNode->left); 
 FreeTree(aTreeNode->right); 
 delete aTreeNode; 
 return; 
 } 
 //Барои мавқеи курсорро тағйир додан функсияи зеринро менависем 
 void gotoxy(short x, short y) 
 { 
 COORD pos ={x,y}; 
 SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), pos); 
 } 
 //Хориҷкунии дарахт 
 void print_tree(TreeNode *idx, unsigned int pos, unsigned int pos_mod, 
 unsigned int y) { 
 if(idx==NULL) return; 
 gotoxy(pos, y); 
 cout<<idx->Data<<endl; 
 print_tree(idx->left, pos-pos_mod, pos_mod/, y+); 
 print_tree(idx->right, pos+pos_mod, pos_mod/, y+); 
 } 
 //Функсияи асосӣ 
 int main() 
 { 
 TreeNode *Root =; 
 int x[] = {,,,,,,,, }; 
 for (int i =; i<; i++) 
 { 
 Add(x[i], Root); 
 } 
 print_tree(Root,,, ); 
 FreeTree(Root); 
 return; 
 } 
 Натиҷаи барнома шакли зеринро дорад: 
 Дарахти ҷустуҷӯи дӯӣ 
 Барои ҷустуҷӯӣ гиреҳе дар дарахтҳои дӯӣ метавон аз ҳалқаҳои такрорӣ ё
 алгоритмҳои бозгашти истифода кард. Дар поён зарбарномаеро, ки дар он 
 гиреҳи k-ум аз дарахти дӯи ҷустуҷӯ карда мешавад меорем........ 
 TreeNode *Treesearch(TreeNode *root, int k){ 
 TreeNode *curr = root; 
 while (curr) { 
 if (k == curr->Data) 
 return curr; 
 if (k < curr->Data) 
 curr = curr->left; 
 else 
 curr = curr->right; 
 } 
 return; 
 } 
 //Функсияи асосӣ 
 int main() 
 { 
 TreeNode *Root =; 
 int k; 
 cout<<"k="; cin>>k; 
 int x[] = {,,,,,,,, }; 
 for (int i =; i<; i++) 
 { 
 Add(x[i], Root); 
 } 
 TreeNode *h=Treesearch(Root, k); 
 if (h!=NULL) 
 cout<<h->Data; 
 FreeTree(Root); 
 return; 
 } 
 Ҷустуҷӯ (паёмиш)-и дарахти дӯӣ 
 Мақсади ҷустуҷӯи дарахт-ин азназаргузаронидани ҳамаи элементҳои 
 дарахт мебошад. Роҳҳои гуногуни паёмиши дарахтҳои дӯӣ вуҷуд дорад, ки аз 
 ҳама асоситаринашон дар поён оварда шудаанд: 
 ) Inorder; 
 ) Postorder; 
 ) Preorder. 
 Ҳоло ҳар яке аз ин роҳҳоро дар алоҳидагӣ дида мебароем. 
 Паёмиши inorder 
 Алгортими ин паёмиш шакли зеринро дорад: 
 ) Азназар гузаронидани шохаҳои тарафи чап; 
 ) Аз назар гузаронидани реша; 
 ) Аз назар гузаронидани шохаҳои тарафи рост. 
 Бинобар ин амали ин паёмиш ба сурати зерин аст: аз реша оғоз карда, ба
 самти чап то расидан ба охирон гиреҳ ҳаракат карда мешавад. Пас аз расидан ба
 охирон гиреҳ муҳтавои он навишта шуда, сипас ба тарафи рост ҳаракат карда
 мешавад. Пас аз расидан ба қуллаи тарафи рост онро ҳамчун реша ба назар 
 гирифта, ба самти чапи он ҳаракат идома дода мешавад. Пас аз расидан ба 
 охирон гиреҳи самти чап, муҳтавои он навишта шуда, боз ба самти рост ҳаракат
 карда мешавад. Ин раванд то мулоқот кардани ҳамаи гиреҳҳо идома дода 
 мешавад. Барои моҳияти ин амалро пурра дарк кардан, дар поён ба намуди 
 графикӣ оварда шудааст. 
 Натиҷаи амали паёмиши imorder дар ин дарахт чунин аст: 
 FTUAPNLKBHJXVQY. 
 Амали ин навъ паёмиш ба намуди бозгаштӣ анҷом дода мешавад. Аз инрӯ 
 барои иҷрои ин амал ба намуди бозгаштӣ функсияи ба шакли зерин навишта 
 мешавад: 
 void inorder(TreeNode *root) { 
 if (root == NULL) // Ҳолати базавӣ 
 { 
 return; 
 } 
 inorder(root->left); 
 cout<<root->Data<<" "; 
 inorder(root->right); 
 } 
 Паёмиши postorder 
 Алгортими ин паёмиш шакли зеринро дорад: 
 ) Мулоқоти реша; 
 ) Мулоқоти шохаҳои тарафи чап; 
 ) Мулоқоти шохаҳои тарафи рост. 
 Аз расми зерин амали ин навъ паёмиш аён буда, ҳоҷат ба шарҳу тавзеҳ 
 намебошад. 
 Натиҷаи амали паёмиши preorder дар ин дарахт чунин аст: 
 KATFUNPLXHBJQVY 
 Амали ин навъ паёмиш ба намуди бозгаштӣ анҷом дода мешавад. Аз инрӯ 
 барои иҷрои ин амал ба намуди бозгаштӣ функсияи ба шакли зерин навишта 
 мешавад: 
 void preorder(TreeNode *root){ 
 if (root == NULL) // Ҳолати базавӣ 
 { 
 return; 
 } 
 cout<<root->Data<<" "; 
 preorder(root->left); 
 preorder(root->right); 
 } 
 Паёмиши postorder 
 Алгортими ин паёмиш шакли зеринро дорад: 
 ) Мулоқоти зердарахтҳои тарафи чап; 
 ) Мулоқоти шохаҳои тарафи рост. 
 ) Мулоқоти реша; 
 Аз расми зерин амалкарди ин алгоритм аён буда, ҳоҷат ба шарҳу тавзеҳ
 нест. 
 Натиҷаи амали паёмиши postorder дар ин дарахт чунин аст: 
 FUTPLNABJHVYQXK 
 Амали ин навъ паёмиш ба намуди бозгаштӣ анҷом дода мешавад. Аз инрӯ 
 барои иҷрои ин амал ба намуди бозгаштӣ функсияи ба шакли зерин навишта 
 мешавад: 
 void postorder(TreeNode *root) { 
 if (root == NULL) // Ҳолати базавӣ 
 { 
 return; 
 } 
 postorder(root->left); 
 postorder(root->right); 
 cout<<root->Data<<" "; 
 } 
 Мисол. Барномае нависед, ки миқдори такроршавии ҳар як калимаи 
 матни додашударо ҳисоб кунад. 
 Азбаски руйхаи калимаҳо пешкаи маълум нест, бинобар ин, наметавон 
 пешаки онҳоро мураттаб кард. Агар усули хаттии ҷустуҷӯиро истифода кунем,
 барнома хело суст кор мекунад. 
 Яке аз усулҳои сода- мураттаб нигоҳ доштани калимаҳои алакай ба даст
 омада мебошад. Барои ин, аз дарахтҳои дӯӣ истифода мекунем, яъне мисоли 
 қаблан навиштаамонро мукаммал мекунем. Ҳар як шохаи дарахт дорои 
 элементҳои зерин мебошад: 
  ишорагар ба матни калима; 
  ҳисобкунаки миқдори такроршавии калима; 
  ишорагар ба шохаи чап; 
  ишорагар ба шохаи рост. 
 Мисол. Миқдори такроршавии ҳар як калимаи ду мисраъ шеъри зеринро 
 муайян карда,натиҷаро ба намуди дарахти дӯӣ тасвир мекунем. 
 odami odam nabinad az kujo odam shavad, 
 sham` agar otash nabinad az kuzo ravshan shavad. 
 Матни барнома: 
 #include <iostream> 
 #include<windows.h> 
 using namespace std; 
 struct TreeNode{ 
 char *Data; //ишорагар баа сатр (калима) 
 int count; //қимати гиреҳ 
 TreeNode *left; //ишорагар ба шохаҳои қаблӣ ва баъд? 
 TreeNode *right; 
 }; 
 // Функсия барои иловакунии гиреҳ ба дарахт 
 TreeNode *addTree(TreeNode *p, char *w) { 
 int cond; 
 if(p == NULL) { 
 p = new TreeNode[sizeof(TreeNode)]; 
 p->Data= strdup(w); 
 p->count =; 
 p->left = p->right = NULL; 
 } else if((cond = strcmp(w, p->Data)) == ) 
 p->count++; 
 else if(cond < ) 
 p->left = addTree(p->left, w); 
 else 
 p->right = addTree(p->right, w); 
 return p; 
 } 
 //Озод кардани ҳофиза 
 void FreeTree(TreeNode *aTreeNode) 
 { 
 if (!aTreeNode) return; 
 FreeTree(aTreeNode->left); 
 FreeTree(aTreeNode->right); 
 delete aTreeNode; 
 return; 
 } 
 //Барои мавқеи курсорро тағйир додан функсияи зеринро //менависем 
 void gotoxy(short x, short y) 
 { 
 COORD pos ={x,y}; 
 SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), pos); 
 } 
 //Хориҷкунии дарахт 
 void print_tree(TreeNode *idx, unsigned int pos, unsigned int pos_mod, 
 unsigned int y) { 
 if(idx==NULL) return; 
 gotoxy(pos, y); 
 cout<<idx->Data<<"="<<idx->count<<endl; 
 print_tree(idx->left, pos-pos_mod, pos_mod/, y+); 
 print_tree(idx->right, pos+pos_mod, pos_mod/, y+); 
 } 
 //Функсияи асосӣ 
 int main() 
 { 
 TreeNode *root; 
 char word[MAXWORD]; 
 root=NULL; 
 do { 
 cin>>word; 
 if(isalpha(word[])) 
 root = addTree(root, word); 
 }while(word[]!=’’); // нишонаи ба охирраси мебошад 
 print_tree(root,,, ); 
 FreeTree(root); 
 return; 
 } 
 Натиҷаи кори барнома: 
 Мисоли. Барномае нависед, ки элементҳои дарахти дӯӣро мураттаб 
 намояд. 
 #include <iostream> 
 using namespace std; 
 #include <ctype.h> 
 struct TreeNode{ 
 int Data; 
 TreeNode *left; //ишорагар ба шохаҳои қаблӣ ва баъдӣ 
 TreeNode *right; 
 }; 
 struct TreeNode * addTree(int x, TreeNode *tree) { 
 if (tree == NULL) // Агар дарахт мавҷуд набошад, шохаҳояшро месозем 
 { 
 tree = new TreeNode; //ҳофиза барои гиреҳ 
 tree->Data = x; //майдон барои қимат 
 tree->left = NULL; 
 tree->right = NULL; //ба шохаҳо аввл қимати холӣ мебахшем 
 } 
 else // дар ҳолати акс 
 if (x < tree->Data) //агар элементи x аз элементи реша 
 //хурд бошад, ба тарафи чап меравем. 
 tree->left = addTree(x, tree->left); 
 //Ба таври рекурсивӣ элемент илова мекунем. 
 else //вагарна ба тарафи рост меравем 
 tree->right = addTree(x, tree->right); 
 // Ба таври рекурсивӣ элемент илова мекунем. 
 return tree; 
 } 
 // хориҷкунии элементҳои дарахт 
 void treeprint(TreeNode *tree){ 
 if (tree!= NULL) { //то расидан ба шохаи холӣ 
 treeprint(tree->left); 
 //Ба таври рекурсивӣ хориҷ кардани зершохаи чап 
 cout << tree->Data << " "; // Намоиш додани решаи зер шоха 
 treeprint(tree->right); 
 // Ба таври рекурсивӣ хориҷ кардани зершохаи рост 
 } 
 } 
 void FreeTree(TreeNode *aTreeNode){ 
 if (!aTreeNode) return; 
 FreeTree(aTreeNode->left); 
 FreeTree(aTreeNode->right); 
 delete aTreeNode; 
 return; 
 } 
 //Функсияи асосӣ 
 int main(){ 
 TreeNode *root=NULL; 
 int n, t; 
 cin>>n; 
 for (int i=; i<n; i++){ 
 t=rand()%+; 
 root = addTree(t, root); 
 } 
 treeprint(root); 
 FreeTree(root); 
 return; 
 } 
 Саволҳо барои мустаҳкамкунӣ 
 ) Граф чист? 
 ) Графҳо дар куҷо истифода бурда мешаванд? 
 ) Масъалаи назарияи графҳо кай пайдо шуд? 
 ) Граф чанд хел мешавад? 
 ) Графи Эйлери чи гуна граф аст? 
 ) Кадом намуди алгоритмҳои татқиқи графҳоро медонед? 
 ) Алгортми Дейскрӣ чи гуна алгоритм аст? 
 ) Ҷустуҷӯ дар умқ аз ҷустуҷӯ дар васеъгӣ чи фарқият дорад? 
 ) Дараҷаи граф чист? 
 ) Занҷир гуфта чиро меноманд? 
 ) Дарахт гуфта чиро меноманд? 
 ) Дарахт аз граф чӣ фарқият дорад? 
 ) Оё метавон элементи додашударо дар дарахти дӯӣ ҷустуҷӯ кард? 
 ) Дарахтҳои дӯӣ чи гуна дарахтанд? 
 ) Паёмиш чист ва чанд навъи паёмиши дарахҳои дӯӣ вуҷуд дорад? 
 ) Оё метавон, амали мураттабсозии додаҳоро тавасути дарахтҳои дӯӣ анҷом
 дод? 
 Мисолҳо барои кори мустақилона 
 ) Функсияе нависед, ки суммаи элементҳои дарахти дӯӣ ро ҳисоб кунад.
 ) Барномае нависед, ки дар дохили элементҳои дарахти дӯӣ қимати 
 додашударо ҷучтуҷӯ кунад. 
 ) Барномае нависед, ки ду дарахти дӯӣро муқоиса кунад. 
 ) Барномае, нависед, ки баландии максималии дарахтро муайян кунад. 
 ) Матне дода шудааст. Барномае нависед, ки миқдори такрор-шавии ҳар
 як калимаи онро муайян кунад. 
 ) Барномае нависед, ки аз дарахти дӯӣ ҳамаи элементҳои тоқро нест 
 кунад. 
 ) Барномае нависед, ки миқдори элементҳои палиндроми дарахти дӯӣро 
 ҳисоб кунад. 
 ) Дар расми зерин системаи шаҳрҳои A, B, C, D, E, F, J, H, K, L, M дода
 шудааст. Муайян кунед, аз шаҳри А то шаҳри L чанд роҳ мавҷуд аст. 
 ) Дар байни маҳаллаҳои аҳолинишини A, B, C, D, E роҳ мавҷуд аст, ки
 дарозии роҳҳо дар ҷадвали зерин оварда шудаанд. Муайян кунед, ки кадом 
 шаҳр ба шаҳри А наздиктар воқеъ гардидааст. 
 A B C D E F 
 A 
 B 
 C 
 D 
 ) Дар байни E маҳаллаҳои аҳолинишини 
 A, B, C, D, E роҳ мавҷуд F аст, ки дарозии роҳҳо дар 
 ҷадвали зерин оварда шудаанд. Роҳи 
 дарозтарини аз шаҳри А то шаҳри Е ро муайян кунед. 
 A B C D E 
 A 
 B 
 C 
 D 
 E 
 ) Дар олимпиада N иштирокчӣ вуҷуд дорад, ки якчандтои онҳо бо ҳам 
 шинос мебошанд. Оё метавон онҳоро ғаримустақим (опосредованно) бо 
 ҳамдигар шинос кард?. 
 ) N ҳалқаи бо ҳамдигар пайваст дода шудааст. (матритсаи A[n][n] дода
 шудааст, ки A[i][j]= аст агар ҳалқаҳои i ва j бо ҳамдигар пайваст бошаед ва
 дар акси ҳол A[i][j]= мебошад). Миқдори минималии ҳалқаҳоро нест кунед, ки
 аз ҳалқаҳои боқимонда занҷир ҳосил шавад. 
 ) Гурӯҳ аз N студент иборат мебошад, ки ҳар яки онҳо дорои N/ дӯст
 буда, на зиёда аз K душман дорад. Яке аз онҳо дорои китобе мебошад, ки ҳама
 хоҳиши онро хонда, сипас бо якчанд нафари боқимонда баҳс карданро дорад. 
 Барномае нависед, ки: 
 ) Усули тақсим кардани китобро барои ҳамаи донишҷуён муайян кунед, 
 ки ба дасти ҳар яки онҳо танҳо як бор расида, охир ба соҳибаш баргардад. 
 ) Донишҷӯёнро ба S гуруҳ тавре тақсим кунед, ки китобро бо ҳам баҳс
 кунанд ва дар байни онҳо на зиёда аз P душман вуҷуд дошта бошад. 
 Эзоҳ: фарз карда мешавад, ки S*P>=K аст. 
 ) N одам ва ҷадвали квадратшакли А[N][N] дода шудааст. Агар 
 элементи A[i][j] ба баробар бошад, маънои онро доад, ки одами i бо одами j
 шинос аст, А[i][j] = =А[j][i]. Оё метавон одамонро бо ду гуруҳ тавре тақсим
 кард, ки дар ҳар ду гуруҳ танҳо одамони ношинос вуҷуд дошта бошанд. 
 ) донишҷӯйро ба ду гуруҳ тавре тақсим кунед, ки шумораи онҳо аз
 ҳамдигар на зиёда аз маротиба фарқ кунад, агар маълум бошад, ки дар дилхоҳ
 гуруҳ танҳо донишҷӯёни бо ҳамдигар шинос вуҷуд дорад. Давраи шиносоӣ дар 
 намуди матритсаи x[][] дода мешавад, ки элементҳои шакли зеринро дорад.
 ) N лифоф а ( к о н в е р ти ) ш а кл и р о с т ку н ҷ аш а к л в а N р у қъ а и (откриткаи)
 { 
 росткунҷаи андоза и г у н о гу н в у ҷ у д д о р а д. О ё м е т а в о н ҳ а м а и р у қ ъаҳоро дар
 конвертҳо ҷойгир кард, ки дар ҳар як лифофа танҳо як руқъа ҷойгир шавад. 
 Эзоҳ. Руқъаро наметавон қат кард ва ё бо таври кунҷи дар лифофа ниҳод.
 Масалан руқъаи андозаи тарафҳояш ба: баробар метавонад дар лифофаҳои 
 андозаашон ба:,:,.:. баробар ҷойгир карда шавад, аммо наметавонад
 дар лифофаҳои андозаашон ба:,:.,.:. баробар ҷойгир гардад. 
 ) N дастгоҳ гуногуни бо ҳамдигар пайвасте, ки дорои N коргар 
 мебошанд дода шудааст. Матритсаи C[N][N] дода шудааст, ки C[i,j] маҳсули 
 коргари i-юмро дар дастгоҳи j-юм ифода мекунад. Муайян кунед: 
 а) Дар кадом дастгоҳ коргар бояд кор кунад, ки маҳсулнокиаш бисёртар
 бошад. 
 б) ба а) монанд, аммо дастгоҳҳо параллел ҷойгир буда, амали якхела иҷро
 карда шавад. 
 ) N – то хона ва К – то роҳ дода шудааст. Хонаҳо то N рақамгузорӣ
 карда шудаанд. Ҳар як роҳро се адад, ки дутоаш рақами хона ва яктоаш дарозии
 роҳро муайян мекунад. Дар ҳар хона як одам зиндагӣ мекунад. Ҷойи вохурии 
 ҳамаи одамҳоро ёбед, ки масофа аз онҷо то ҳамаи хонаҳо кутоҳтарин бошад. 
 Агар нуқта дар роҳ хобад, онгоҳ рақами хона, охири роҳ ва масофаи хонаи
 якумро ифода мекунад. Агар нуқта ба хона мувофиқ ояд, онгоҳ рақами ин 
 хонаро ифода мекунад. 
 Қайд: дарозии роҳ – адади бутуни мусбат мебошад.