Почетак језика Ц++ догодио се далеке 1983. године, убрзо након тога 'Бјаре Строуструп' радио са класама у језику Ц укључујући и неке додатне функције као што је преоптерећење оператора. Екстензије датотека које се користе су „.ц“ и „.цпп“. Ц++ је проширив и не зависи од платформе и укључује СТЛ што је скраћеница од Стандард Темплате Либрари. Дакле, у основи познати језик Ц++ је заправо познат као компајлирани језик који има изворну датотеку која је састављена заједно да формира објектне датотеке, које када се комбинују са линкером стварају програм који се може покренути.

С друге стране, ако говоримо о његовом нивоу, он је средњег нивоа који тумачи предност програмирања ниског нивоа као што су драјвери или кернели, као и апликације вишег нивоа као што су игре, ГУИ или десктоп апликације. Али синтакса је скоро иста за Ц и Ц++.

Компоненте језика Ц++:

#инцлуде<иостреам>

Ова команда је датотека заглавља која садржи команду 'цоут'. Може постојати више од једне датотеке заглавља у зависности од потреба и преференција корисника.

инт маин()

Ова изјава је функција главног програма која је предуслов за сваки Ц++ програм, што значи да се без ове изјаве не може извршити ниједан Ц++ програм. Овде 'инт' је тип повратне променљиве која говори о типу података које функција враћа.

Декларација:

Променљиве су декларисане и имена су им додељена.

Изјава о проблему:

Ово је неопходно у програму и може бити петља „вхиле“, петља „фор“ или било који други услов.

Оператери:

Оператори се користе у Ц++ програмима и неки су кључни јер се примењују на услове. Неколико важних оператора су &&, ||, !, &, !=, |, &=, |=, ^, ^=.

Ц++ Улаз Излаз:

Сада ћемо разговарати о могућностима уноса и излаза у Ц++. Све стандардне библиотеке које се користе у Ц++-у пружају максималне улазне и излазне могућности које се изводе у облику низа бајтова или су обично повезане са токовима.

Улазни ток:

У случају да се бајтови стримују са уређаја у главну меморију, то је улазни ток.

Излазни ток:

Ако се бајтови стримују у супротном смеру, то је излазни ток.

Датотека заглавља се користи за олакшавање уноса и излаза у Ц++. Написан је као <иоманип> који обезбеђује методе, на пример, прецизност гушења и постављања. Улазне и излазне команде су цин, цоут, церр и цлог. Овде, 'цин' означава стандардни улаз, а 'цоут' означава стандардни излазни уређај који се користи са операторима уметања тока (<<) за приказ исказа на екрану.

Пример:

Приказаћемо стринг поруку користећи стринг типа карактера.

У први ред укључујемо „иостреам“ који има скоро све основне библиотеке које би нам могле бити потребне за извршавање Ц++ програма. У следећем реду декларишемо именски простор који обезбеђује опсег за идентификаторе. Након позивања главне функције, иницијализујемо низ типа знакова који чува поруку стринга и 'цоут' је приказује спајањем. Користимо „цоут“ за приказивање текста на екрану. Такође, узели смо променљиву „А“ која има низ карактерних типова података за чување низа знакова, а затим смо додали обе поруке низа уз статичку поруку користећи команду „цоут“.

Генерисани излаз је приказан у наставку:

Пример:

У овом случају, ми бисмо представљали старост корисника у једноставној стринг поруци.

У првом кораку укључујемо библиотеку. Након тога, користимо простор имена који би обезбедио опсег за идентификаторе. У следећем кораку позивамо главни() функција. Након тога, иницијализујемо старост као 'инт' променљиву. Користимо команду 'цин' за унос и команду 'цоут' за излаз једноставне стринг поруке. „цин“ уноси вредност старости од корисника, а „цоут“ је приказује у другој статичкој поруци.

Ова порука се приказује на екрану након извршавања програма тако да корисник може да добије старост и затим притисне ЕНТЕР.

Пример:

Овде демонстрирамо како да одштампате стринг коришћењем 'цоут'.

Да бисмо одштампали стринг, у почетку укључујемо библиотеку, а затим именски простор за идентификаторе. Тхе главни() функција се зове. Даље, штампамо стринг излаз користећи команду 'цоут' са оператором уметања који затим приказује статичку поруку на екрану.

Ц++ типови података:

Типови података у Ц++ су веома важна и широко позната тема јер су основа програмског језика Ц++. Слично, свака коришћена променљива мора бити специфицираног или идентификованог типа података.

Знамо да за све варијабле користимо тип података док смо под декларацијом да бисмо ограничили тип података који је требало вратити. Или, могли бисмо рећи да типови података увек говоре променљивој коју врсту података она сама чува. Сваки пут када дефинишемо променљиву, компајлер додељује меморију на основу декларисаног типа података пошто сваки тип података има другачији капацитет меморије.

Језик Ц++ помаже разноврсности типова података тако да програмер може да изабере одговарајући тип података који би му могао бити потребан.

Ц++ олакшава употребу доле наведених типова података:

1. Кориснички дефинисани типови података
2. Изведени типови података
3. Уграђени типови података

На пример, следећи редови су дати да илуструју важност типова података иницијализацијом неколико уобичајених типова података:

Неколико уобичајених типова података: коју величину специфицирају и коју врсту информација ће њихове варијабле чувати приказано је у наставку:

• Цхар: Са величином од једног бајта, чуваће један карактер, слово, број или АСЦИИ вредности.
• Боолеан: Са величином од 1 бајт, он ће чувати и враћати вредности као тачне или нетачне.
• Инт: Са величином од 2 или 4 бајта, чуваће целе бројеве без децимале.
• Покретни зарез: Са величином од 4 бајта, он ће чувати разломке који имају једну или више децимала. Ово је довољно за чување до 7 децималних цифара.
• Двоструки плутајући зарез: Са величином од 8 бајтова, такође ће чувати разломке који имају једну или више децимала. Ово је довољно за чување до 15 децималних цифара.
• Воид: Без одређене величине, празнина садржи нешто без вредности. Стога се користи за функције које враћају нулту вредност.
• Широки карактер: Са величином већом од 8-бита, која је обично дуга 2 или 4 бајта, представљена је помоћу вцхар_т који је сличан цхар и стога такође чува вредност карактера.

Величина горе наведених варијабли може се разликовати у зависности од употребе програма или компајлера.

Пример:

Хајде да напишемо једноставан код у Ц++ који ће дати тачне величине неколико типова података описаних изнад:

У овом коду интегришемо библиотеку <иостреам>. Након тога користимо „именски простор“. У следећем реду зовемо главни() функцију у којој користимо команду 'цоут' која ће одштампати величине свих типова података наведених у програму. Да бисмо пронашли величину променљивих, морамо да применимо величина() методом.

Излаз се прима у бајтовима као што је приказано на слици:

Пример:

Овде бисмо додали величину два различита типа података.

Прво, уграђујемо датотеку заглавља која користи „стандардни простор имена“ за идентификаторе. Следеће, тхе главни() позива се функција у којој прво иницијализујемо променљиву „инт“, а затим променљиву „доубле“ да бисмо проверили разлику између величина ове две. Затим су њихове величине повезане употребом величина() функција. Излаз се приказује наредбом 'цоут'.

Постоји још један термин који се овде мора поменути и то је „Модификатори података“ . Име сугерише да се „модификатори података“ користе уз уграђене типове података да би се модификовале њихове дужине које одређени тип података може да подржи према потреби или захтеву компајлера.

Следе модификатори података који су доступни у Ц++:

1. Потписан
2. Унсигнед
3. Дуго
4. Кратак

Измењена величина и одговарајући опсег уграђених типова података су наведени у наставку када се комбинују са модификаторима типа података:

• Кратак инт: има величину од 2 бајта, има опсег модификација од -32,768 до 32,767
• Непотписани кратки инт: има величину од 2 бајта, има опсег модификација од 0 до 65,535
• Унсигнед инт: има величину од 4 бајта, има опсег модификација од 0 до 4,294,967,295
• Инт: има величину од 4 бајта, има опсег модификација од -2,147,483,648 до 2,147,483,647
• Лонг инт: Има величину од 4 бајта, има опсег модификација од -2,147,483,648 до 2,147,483,647
• Унсигнед лонг инт: има величину од 4 бајта, има опсег модификација од 0 до 4,294,967.295
• Лонг лонг инт: Има величину од 8 бајтова, има низ модификација од –(2^63) до (2^63)-1
• Унсигнед лонг лонг инт: има величину од 8 бајтова, има опсег модификација од 0 до 18,446,744,073,709,551,615
• Потписани знак: има величину од 1 бајт, има опсег модификација од -128 до 127
• Непотписани знак: Има величину од 1 бајта, има опсег модификација од 0 до 255.

Ц++ набрајање:

У програмском језику Ц++ „Енумерација“ је кориснички дефинисан тип података. Набрајање је декларисано као „ енум' у Ц++. Користи се за додељивање специфичних имена било којој константи која се користи у програму. Побољшава читљивост и употребљивост програма.

Синтакса:

Ми декларишемо набрајање у Ц++ на следећи начин:

Предности набрајања у Ц++:

Енум се може користити на следеће начине:

• Може се често користити у наредбама свитцх цасе.
• Може да користи конструкторе, поља и методе.
• Може само да прошири класу „енум“, не било коју другу класу.
• Може повећати време компајлирања.
• Може се прећи.

Недостаци набрајања у Ц++:

Енум такође има неколико недостатака:

Ако се једном наброји име, оно се не може поново користити у истом опсегу.

На пример:

Енум се не може декларисати унапред.

На пример:

Изгледају као имена, али су цели бројеви. Дакле, они могу аутоматски да се конвертују у било који други тип података.

На пример:

Пример:

У овом примеру видимо употребу Ц++ набрајања:

У овом извршавању кода, пре свега, почињемо са #инцлуде <иостреам>. <иостреам> је једна од богатих библиотека у Ц++. То је уграђена библиотека. Укључује улазне и излазне токове података . Након овога користимо стандардни простор имена. Затим смо 'енум' прогласили посебним именом као предметом и доделили три предмета који су математика, енглески и урду. Математици је додељена вредност 1. Наш циљ је да одштампамо вредности Субјецт декларисане у енум. Затим, позивамо се на главни() функција. Ин главни() имамо цоут<<, где 'ц' значи 'карактер', а оут значи 'излаз'. „Цоут“ се користи за приказ излаза . << означава оператор уметања. Коришћењем 'цоут<<', штампамо енум вредности. Затим ћемо користити команду „врати 0“. Ова команда враћа резултат који је у облику вредности.

Ево нашег резултата извршеног програма:

Дакле, као што видите да имамо вредности предмета: математика, урду, енглески; то је 1,2,3.

Пример:

Ево још једног примера кроз који чистимо наше концепте о енум-у:

У овом програму почињемо интеграцијом датотеке заглавља <иостреам>. То је уграђена библиотека. Укључује улазне и излазне токове података. Након овога, морамо да искористимо Стандардни простор имена. Затим смо доделили енум вредности константама које су играчи. Наш циљ је да прикажемо чије је преко. Затим зовемо наше главни() функција. У главни() функцији доделили смо две константе: Схадаб, чија је вредност 20 променљивој енум 'бовлер1'; и Африди, чија је вредност 25 у набројаној променљивој 'бовлер2'.

Морамо користити иф-елсе изјаву . Такође смо користили оператор поређења унутар изјаве „иф“, што значи да поредимо ако је „бовлер2“ већи од „бовлер1“. Затим се извршава блок „ако“, што значи да је крај Афридија. Затим смо унели „цоут<<“ да прикажемо излаз. Прво, штампамо изјаву „Готово је“. Затим, вредност „бовлер2“. Ако није, позива се други блок, што значи да је завршен Схадаб. Затим, применом команде 'цоут<<', приказујемо изјаву 'Готово је'. Затим, вредност „бовлер1“.

Према изјави Иф-елсе, имамо преко 25 што је вредност Афридија. То значи да је вредност енум променљиве „бовлер2“ већа од „бовлер1“ због чега се извршава наредба „иф“.

Ц++ Ако је другачије, пребаците:

У програмском језику Ц ++ користимо 'иф исказ' и 'свитцх исказ' да модификујемо ток програма. Ови искази се користе да обезбеде више скупова команди за имплементацију програма у зависности од праве вредности поменутих исказа. У већини случајева користимо операторе као алтернативе наредби „ако“. Све ове горе наведене изјаве су изјаве о избору које су познате као изјаве одлуке или условне изјаве.

Изјава „ако“:

Ова изјава се користи за тестирање датог стања кад год желите да промените ток било ког програма. Овде, ако је услов тачан, програм ће извршити писана упутства, али ако је услов нетачан, само ће се прекинути. Хајде да размотримо пример;

Ово је једноставна 'иф' изјава која се користи, где променљиву 'инт' иницијализујемо као 10. Затим се вредност узима од корисника и она се унакрсно проверава у изјави 'иф'. Ако задовољава услове примењене у наредби 'иф', онда се приказује излаз.

Пошто је изабрана цифра 40, излаз је порука.

Изјава 'Ако-иначе':

У сложенијем програму где изјава „ако“ обично не сарађује, користимо наредбу „ако-елсе“. У датом случају, користимо наредбу 'иф- елсе' да проверимо примењене услове.

Прво ћемо декларисати променљиву типа података „инт“ под називом „к“ чија је вредност преузета од корисника. Сада се користи изјава „иф“ где смо применили услов да ако је целобројна вредност коју је унео корисник 2. Излаз ће бити жељени и биће приказана једноставна порука „ЛЕПО ПОКУШАЈ“. У супротном, ако унети број није 2, излаз би био другачији.

Када корисник упише број 2, приказује се следећи излаз.

Када корисник напише било који други број осим 2, резултат који добијамо је:

Наредба Иф-елсе-иф:

Угнежђени иф-елсе-иф изрази су прилично сложени и користе се када постоји више услова примењених у истом коду. Хајде да размислимо о овоме користећи други пример:

Овде, након интеграције датотеке заглавља и простора имена, иницијализовали смо вредност променљиве 'м' као 200. Вредност 'м' се затим узима од корисника и затим се унакрсно проверава са вишеструким условима наведеним у програму.

Овде је корисник изабрао вредност 195. Због тога излаз показује да је ово стварна вредност 'м'.

Изјава за пребацивање:

Наредба „свитцх“ се користи у Ц++ за променљиву коју треба тестирати ако је једнака листи више вредности. У наредби „пребаци“ ми идентификујемо услове у облику различитих случајева и сви случајеви имају прекид укључен на крају сваке изјаве случаја. Више случајева има одговарајуће услове и на њих се примењују изјаве са наредбама бреак које прекидају наредбу свитцх и прелазе на подразумевану наредбу у случају да ниједан услов није подржан.

Кључна реч 'прекид':

Наредба свитцх садржи кључну реч „бреак“. Зауставља извршавање кода у следећем случају. Извршење наредбе свитцх се завршава када Ц++ компајлер наиђе на кључну реч „бреак“ и контрола се помери на линију која прати наредбу свитцх. Није неопходно користити наредбу бреак у прекидачу. Извршење прелази на следећи случај ако се не користи.

У првом реду заједничког кода укључујемо библиотеку. Након тога додајемо „именски простор“. Позивамо се на главни() функција. Затим, оцену типа података карактера декларишемо као „Ф“. Ова оцена би могла бити ваша жеља и резултат би се приказао респективно за одабране случајеве. Применили смо наредбу свитцх да бисмо добили резултат.

Ако одаберемо „Ф“ као оцену, резултат је „више среће следећи пут“ јер је ово изјава коју желимо да буде одштампана у случају да је оцена „Ф“.

Хајде да променимо оцену у Кс и да видимо шта ће се десити. Написао сам „Кс“ као оцену и добијени резултат је приказан испод:

Дакле, неправилна велика и мала слова у 'свитцх' аутоматски помера показивач директно на подразумевану наредбу и прекида програм.

Иф-елсе и свитцх искази имају неке заједничке карактеристике:

• Ови искази се користе за управљање начином на који се програм извршава.
• Обоје процењују стање и то одређује како програм тече.
• Упркос томе што имају различите стилове представљања, могу се користити за исту сврху.

Иф-елсе и свитцх искази се разликују на одређене начине:

• Док је корисник дефинисао вредности у исказима „свитцх” цасе, док ограничења одређују вредности у „иф-елсе” изјавама.
• Потребно је време да се утврди где треба да се изврши промена, а изазовно је модификовати изјаве „ако-елсе“. Са друге стране, „пребаци“ изјаве се лако ажурирају јер се могу лако изменити.
• Да бисмо укључили многе изразе, можемо користити бројне 'ако-иначе' изјаве.

Ц++ петље:

Сада ћемо открити како да користимо петље у Ц++ програмирању. Контролна структура позната као 'петља' понавља низ изјава. Другим речима, то се зове репетитивна структура. Сви искази се извршавају одједном у секвенцијалној структури . С друге стране, у зависности од наведеног израза, структура услова може извршити или изоставити израз. Можда ће бити потребно извршити наредбу више пута у одређеним ситуацијама.

Врсте петље:

Постоје три категорије петљи:

• За петљу
• Вхиле Лооп
• Урадите вхиле петљу

За петљу:

Петља је нешто што се понавља као циклус и зауставља се када не потврди дато стање. Петља 'фор' имплементира низ изјава више пута и сажима код који се носи са променљивом петље. Ово показује како је петља 'фор' специфичан тип итеративне контролне структуре која нам омогућава да креирамо петљу која се понавља одређени број пута. Петља би нам омогућила да извршимо „Н“ број корака користећи само код од једне једноставне линије. Хајде да разговарамо о синтакси коју ћемо користити за петљу „фор“ која ће бити извршена у вашој софтверској апликацији.

Синтакса извршавања петље 'фор':

Пример:

Овде користимо променљиву петље да регулишемо ову петљу у петљи „фор“. Први корак би био додељивање вредности овој променљивој коју наводимо као петљу. Након тога морамо дефинисати да ли је мања или већа од вредности бројача. Сада, тело петље треба да се изврши, а такође се ажурира променљива петље у случају да изјава врати тачну. Горе наведени кораци се често понављају док не дођемо до излазног стања.

• Израз за иницијализацију: Прво, морамо да подесимо бројач петље на било коју почетну вредност у овом изразу.
• Тест Екпрессион : Сада треба да тестирамо дати услов у датом изразу. Ако су критеријуми испуњени, извршићемо тело петље „фор“ и наставити са ажурирањем израза; ако не, морамо престати.
• Ажурирај израз: Овај израз повећава или смањује променљиву петље за одређену вредност након што се тело петље изврши.

Примери Ц++ програма за проверу петље „Фор“:

Пример:

Овај пример приказује штампање целобројних вредности од 0 до 10.

У овом сценарију, требало би да одштампамо целе бројеве од 0 до 10. Прво смо иницијализовали случајну променљиву и са вредношћу која је дата „0“, а затим параметар услова који смо већ користили проверава услов ако је и<=10. А када испуни услов и постане истинито, почиње извршавање петље 'фор'. Након извршења, између два параметра инкремента или декремента, извршиће се један и у коме се повећава вредност променљиве и док се наведени услов и<=10 не претвори у нетачан.

Број итерација са условом и<10:

Пример:

Следећа инстанца приказује вредност целог броја:

У горњем случају, променљива под називом 'а' се иницијализује са датом вредношћу 50. Услов се примењује где је променљива 'а' мања од 70. Затим се вредност 'а' ажурира тако да се додаје са 2. Вредност 'а' се затим покреће од почетне вредности која је била 50 и 2 се додаје истовремено кроз петљу све док услов не врати нетачно и вредност 'а' се повећа са 70 и петља се заврши.

Број итерација:

Док петља:

Док се не испуни дефинисани услов, може се извршити једна или више наредби. Када је итерација унапред непозната, веома је корисна. Прво се проверава услов, а затим улази у тело петље да би се извршила или имплементирала изјава.

У првом реду уграђујемо датотеку заглавља <иостреам> и стандардни простор имена. Ми зовемо главни() функција. Овде иницијализујемо променљиву 'а'. У следећем реду примењујемо услов вхиле. Унутар услова вхиле користимо наредбу „цоут“ да прикажемо вредност која је написана. Затим користимо оператор инкремента да повећамо број. У последњем реду користимо наредбу „ретурн 0“ да завршимо програм.

До-Вхиле Лооп:

Када је дефинисани услов задовољен, изводи се низ исказа. Прво се изводи тело петље. Након тога се проверава услов да ли је тачан или не. Дакле, изјава се извршава једном. Тело петље се обрађује у „До-вхиле“ петљи пре процене стања. Програм се покреће кад год је тражени услов задовољен. У супротном, када је услов нетачан, програм се прекида.

Овде интегришемо датотеку заглавља <иостреам>. Ми користимо главни() функција у програму. Затим иницијализујемо четири цела броја и користимо наредбу 'цин', тако да корисник може да унесе вредност. У следећем реду иницијализујемо два различита цела броја. Примењујемо изјаву „ради“. Унутар исказа користимо две аритметичке функције. Прво, користимо оператор множења и друго, користимо оператор сабирања. Затим примењујемо услов 'вхиле' у програму изван изјаве 'до'. Даље, додајемо наредбу „цоут“ за штампање резултата кроз цео број „резултат“. У последњем реду, да бисмо прекинули програм, користимо команде ретурн 0.

Ц++ Настави/прекини:

Ц++ Цонтинуе изјава:

Наредба настављања се користи у програмском језику Ц++ да би се избегла тренутна инкарнација петље, као и да се помери контрола на следећу итерацију. Током петље, наредба цонтинуе се може користити за прескакање одређених наредби. Такође се користи у оквиру петље у комбинацији са извршним изјавама. Ако је одређени услов тачан, сви изрази који следе након наредбе настављања се не примењују.

Са за петљу:

У овом случају, користимо 'фор петљу' са наредбом за наставак из Ц++-а да бисмо добили тражени резултат док пролазимо неке одређене захтеве.

Почињемо тако што ћемо укључити библиотеку <иостреам> и користити 'намеспаце стд'. Онда зовемо главни() функција. Користимо фор петљу. Унутар петље фор, декларишемо променљиву 'к' за коју се сматра да лежи између 3 и 8. Користимо услов да наставимо итерацију чак и ако је (к = = 5). Затим користите наредбу „цонтинуе“ након навођења услова. На крају. да бисмо приказали излаз, користимо команду 'цоут' заједно са командом 'ретурн 0'.

Са вхиле петљом:

Током ове демонстрације, користили смо и „вхиле петљу“ и Ц++ „цонтинуе“ наредбу, укључујући неке услове да видимо каква врста излаза може бити генерисана.

У овом примеру смо поставили услов за додавање бројева само на 40. Ако је унети цео број негативан број, онда ће петља „вхиле“ бити прекинута. С друге стране, ако је број већи од 40, онда ће тај одређени број бити прескочен из итерације.

Укључићемо библиотеку <иостреам>, користећи 'намеспаце стд', а затим позвати главни() функција. Иницијализујемо променљиву 'с'. Друга променљива „број“ је декларисана у следећем кораку. Користимо петљу 'вхиле'. Сада наводимо услов да ће тражена вредност бити већа или једнака нули. Да бисмо додали све позитивне бројеве, користимо наредбу 'с += број'. Команда „цоут“ ће бити примењена да прикаже поруку на конзоли „Унесите било који број“. Добијамо цео број од корисника коришћењем наредбе „цин“. Такође користимо изјаву „ако“. Када год је дефинисани број већи од 40, порука ће бити приказана. Затим смо користили команду „настави“. Након свих ових корака, наредба „цонтинуе“ ће бити извршена. Да бисмо приказали збир свих бројева, користимо наредбу „цоут“.

Ц++ изјава о прекиду:

Кад год се наредба бреак користи у петљи у Ц++-у, петља се тренутно завршава, као и контрола програма се поново покреће у наредби након петље. Такође је могуће завршити случај унутар изјаве 'свитцх'.

Са за петљу:

Овде ћемо користити петљу „фор“ са наредбом „бреак“ да бисмо посматрали излаз итерацијом преко различитих вредности.

Прво, уграђујемо датотеку заглавља <иостреам>. Затим користимо 'намеспаце стд'. Након позива функције маин(), користили смо за петљу. Овде бисмо иницијализовали променљиву 'м'. Применићемо услов да вредност 'м' лежи између 10 и 20. Услов 'бреак' ће се извршити као да (м == 17). Да бисмо одштампали резултат, користили смо „цоут“. Затим ће се применити команда „врати 0“.

Са вхиле петљом:

Користићемо петљу 'вхиле' заједно са наредбом бреак.

Почињемо са увозом библиотеке <иостреам>. „Стд простора имена“ ће бити укључен. Унутар методе маин(), две променљиве „нбр“ и „к“ би биле иницијализоване. Користили смо петљу 'вхиле' и проследили 'труе' као аргумент. Да бисмо добили вредност од корисника, користимо команду „цин“. Затим смо користили изјаву „ако“. Заједно са овим, примењује се услов „прекид“ да би се специфицирао услов ако (нбр < 0). Да бисмо додали све позитивне вредности, користили смо формуле 'к += нбр'. Да бисмо приказали овај збир, додали смо наредбу „цоут“.

Ц++ функције:

Функције се користе за структурирање већ познатог програма у више фрагмената кодова који се извршавају само када се позову. У програмском језику Ц++, функција је дефинисана као група исказа којима је дато одговарајуће име и које они позивају. Корисник може проследити податке у функције које називамо параметрима. Функције су одговорне за спровођење радњи када је највероватније да ће код бити поново употребљен.

Креирање функције:

Иако Ц++ пружа многе унапред дефинисане функције као што су главни(), што олакшава извршавање кода. На исти начин, можете креирати и дефинисати своје функције према вашим захтевима. Као и све обичне функције, овде вам је потребно име за вашу функцију за декларацију која се додаје са заградама после „()“.

Синтакса:

Воид је тип повратка функције. Рад је назив који му је дат, а витичасте заграде би обухватиле тело функције где додајемо код за извршење.

Позивање функције:

Функције које су декларисане у коду се извршавају само када се позову. Да бисте позвали функцију, потребно је да наведете име функције заједно са заградама иза које следи тачка-зарез ';'.

Пример:

Хајде да декларишемо и направимо кориснички дефинисану функцију у овој ситуацији.

У почетку, као што је описано у сваком програму, додељена нам је библиотека и именски простор за подршку извршавању програма. Функција коју дефинише корисник рад() се увек позива пре него што се запише главни() функција. Функција под називом рад() се декларише где се приказује порука „Рад заслужује поштовање!“. У главни() функцију са целобројним повратним типом, позивамо рад() функција.

Ово је једноставна порука која је дефинисана у кориснички дефинисаној функцији приказаној овде уз помоћ главни() функција.

Празнина:

У горе поменутом случају, приметили смо да је тип враћања кориснички дефинисане функције неважећи. Ово указује да функција не враћа никакву вредност. Ово представља да вредност није присутна или је вероватно нулл. Јер кад год функција само штампа поруке, није јој потребна повратна вредност.

Ова празнина се на сличан начин користи у простору параметара функције да се јасно каже да ова функција не узима никакву стварну вредност док се позива. У горњој ситуацији бисмо такође назвали рад() функционише као:

Стварни параметри:

Може се дефинисати параметри за функцију. Параметри функције су дефинисани у листи аргумената функције која се додаје имену функције. Кад год позовемо функцију, потребно је да проследимо праве вредности параметара да бисмо завршили извршење. Они су закључени као стварни параметри. Док су параметри који су дефинисани док је функција дефинисана познати као формални параметри.

Пример:

У овом примеру ћемо разменити или заменити две целобројне вредности кроз функцију.

У почетку узимамо датотеку заглавља. Кориснички дефинисана функција је декларисана и дефинисана именована суб(). Ова функција се користи за замену две целобројне вредности које су и и н. Затим, аритметички оператори се користе за размену ова два цела броја. Вредност првог целог броја „и“ се чува уместо вредности „н“, а вредност н се чува уместо вредности „и“. Затим се штампа резултат након промене вредности. Ако говоримо о главни() функцију, узимамо вредности два цела броја од корисника и приказујемо их. У последњем кораку, кориснички дефинисана функција суб() се позива и две вредности се замењују.

У овом случају замене два броја, можемо јасно видети да док користимо суб() функција, вредност 'и' и 'н' унутар листе параметара су формални параметри. Стварни параметри су параметар који се преноси на крају главни() функција где се позива функција замене.

Ц++ показивачи:

Поинтер у Ц++ је прилично лакши за учење и одличан за употребу. У језику Ц++ се користе показивачи јер нам олакшавају рад и све операције раде са великом ефикасношћу када су укључени показивачи. Такође, постоји неколико задатака који се неће извршити осим ако се показивачи не користе као динамичка алокација меморије. Говорећи о показивачима, главна идеја коју треба схватити је да је показивач само променљива која ће чувати тачну меморијску адресу као своју вредност. Широка употреба показивача у Ц++-у је због следећих разлога:

• Да пренесе једну функцију другој.
• Да доделите нове објекте на гомилу.
• За понављање елемената у низу

Обично се оператор '&' (амперсанд) користи за приступ адреси било ког објекта у меморији.

Показивачи и њихови типови:

Показивач има неколико типова:

• Нулл показивачи: Ово су показивачи са вредношћу нула ускладиштени у Ц++ библиотекама.
• Аритметички показивач: Укључује четири главна аритметичка оператора којима се може приступити, а то су ++, –, +, -.
• Низ показивача: То су низови који се користе за чување неких показивача.
• Показивач на показивач: То је место где се показивач користи преко показивача.

Пример:

Размислите о следећем примеру у коме су одштампане адресе неколико променљивих.

Након укључивања датотеке заглавља и стандардног простора имена, иницијализујемо две променљиве. Једна је целобројна вредност представљена са и’, а друга је низ типа знакова „И“ величине 10 карактера. Адресе обе променљиве се затим приказују коришћењем команде 'цоут'.

Излаз који смо добили приказан је у наставку:

Овај исход показује адресу за обе варијабле.

С друге стране, показивач се сматра променљивом чија је сама вредност адреса друге променљиве. Показивач увек указује на тип података који има исти тип који је креиран са (*) оператором.

Декларација показивача:

Показивач је декларисан на овај начин:

Основни тип показивача је означен са 'типе', док је име показивача изражено са 'вар-наме'. А за давање права променљивој на показивач користи се звездица (*).

Начини додељивања показивача променљивим:

Скоро увек постоји дугачак хексадецимални број који представља меморијску адресу која је у почетку иста за све показиваче без обзира на њихове типове података.

Пример:

Следећа инстанца би показала како показивачи замењују оператор '&' и чувају адресе променљивих.

Интегрисаћемо подршку за библиотеке и директоријуме. Затим бисмо позвали на главни() функцију где прво декларишемо и иницијализујемо променљиву 'н' типа 'инт' са вредношћу 55. У следећем реду иницијализујемо променљиву показивача под називом 'п1'. Након овога, додељујемо адресу променљиве 'н' показивачу 'п1', а затим приказујемо вредност променљиве 'н'. Приказује се адреса 'н' која је сачувана у показивачу 'п1'. Након тога, вредност „*п1“ се штампа на екрану коришћењем команде „цоут“. Излаз је следећи:

Овде видимо да је вредност 'н' 55, а адреса 'н' која је сачувана у показивачу 'п1' је приказана као 0к6ффе14. Пронађена је вредност променљиве показивача и она је 55 што је исто као и вредност целобројне променљиве. Према томе, показивач чува адресу променљиве, а такође и * показивач има сачувану вредност целог броја који ће резултирати вратити вредност првобитно сачуване променљиве.

Пример:

Хајде да размотримо још један пример где користимо показивач који чува адресу стринга.

У овом коду прво додајемо библиотеке и именски простор. У главни() функцију морамо да декларишемо стринг под називом „шминка“ који у себи има вредност „Маскара“. Показивач типа стринга „*п2“ се користи за чување адресе променљиве шминке. Вредност променљиве „шминка“ се затим приказује на екрану користећи наредбу „цоут“. Након тога се штампа адреса променљиве 'макеуп', а на крају се приказује променљива показивача 'п2' која показује меморијску адресу променљиве 'макеуп' са показивачем.

Излаз добијен из горњег кода је следећи:

У првом реду је приказана вредност променљиве „шминка“. Други ред приказује адресу променљиве „шминка“. У последњем реду је приказана меморијска адреса варијабле „макеуп“ са употребом показивача.

Ц++ управљање меморијом:

За ефикасно управљање меморијом у Ц++, многе операције су корисне за управљање меморијом док радите у Ц++. Када користимо Ц++, најчешће коришћена процедура алокације меморије је динамичка алокација меморије где се меморије додељују променљивим током времена извршавања; не као у другим програмским језицима где би компајлер могао да додели меморију променљивим. У Ц++ је неопходна делокација променљивих које су динамички додељене, тако да се меморија ослобађа када променљива више није у употреби.

За динамичку алокацију и делокацију меморије у Ц++-у радимо „ Нова' и 'избриши' операције. Кључно је управљати меморијом тако да се меморија не троши. Алокација меморије постаје лака и ефективна. У било ком Ц++ програму, Меморија се користи у једном од два аспекта: или као хрпа или као стек.

• Гомила : Све променљиве које су декларисане унутар функције и сваки други детаљ који је међусобно повезан са функцијом се чува у стеку.
• Гомила : Било која врста неискоришћене меморије или део одакле додељујемо или додељујемо динамичку меморију током извршавања програма је позната као гомила.

Док користите низове, алокација меморије је задатак где једноставно не можемо одредити меморију осим времена извођења. Дакле, додељујемо максималну меморију низу, али ово такође није добра пракса јер у већини случајева меморија остаје неискоришћена и некако се троши, што једноставно није добра опција или пракса за ваш лични рачунар. Због тога имамо неколико оператора који се користе за доделу меморије из гомиле током времена извршавања. Два главна оператора „нев“ и „делете“ се користе за ефикасну алокацију и делокацију меморије.

Ц++ нови оператор:

Нови оператер је одговоран за алокацију меморије и користи се на следећи начин:

У овај код укључујемо библиотеку <иостреам> и именски простор. Затим смо иницијализовали показивач са 'инт' типом података. У следећем реду, овом показивачу је додељен оператор „нови“.

Меморија је успешно додељена променљивој 'инт' уз коришћење показивача.

Ц++ оператор брисања:

Кад год завршимо са коришћењем променљиве, морамо да ослободимо меморију коју смо јој некада доделили јер се више не користи. За ово користимо оператор 'делете' да ослободимо меморију.

Пример који ћемо сада прегледати је да су укључена оба оператера.

Израчунавамо просек за три различите вредности преузете од корисника. Променљиве показивача су додељене оператором „нев“ за чување вредности. Примењена је формула просека. Након тога, користи се оператор „делете“ који брише вредности које су сачуване у променљивим показивача користећи оператор „нев“. Ово је динамичка алокација где се алокација врши током времена извођења, а затим се додељивање дешава убрзо након што се програм заврши.

Употреба низа за доделу меморије:

Сада ћемо видети како се користе оператори 'нев' и 'делете' док се користе низови. Динамичка алокација се дешава на исти начин као што се десило за варијабле јер је синтакса скоро иста.

У датом примеру разматрамо низ елемената чија је вредност преузета од корисника. Елементи низа се узимају и променљива показивача се декларише, а затим се додељује меморија. Убрзо након доделе меморије, покреће се процедура уноса елемената низа. Затим, излаз за елементе низа је приказан коришћењем петље „фор“. Ова петља има услов итерације елемената који имају величину мању од стварне величине низа који је представљен са н.

Када се сви елементи искористе и нема даљег захтева да се поново користе, меморија додељена елементима ће се ослободити помоћу оператора 'делете'.

У излазу смо могли да видимо скупове вредности штампане два пута. Прва петља „фор“ је коришћена за записивање вредности за елементе, а друга „фор“ петља се користи за штампање већ написаних вредности показујући да је корисник написао ове вредности ради јасноће.

Предности:

Оператори 'нев' и 'делете' су увек приоритет у Ц++ програмском језику и широко се користе. Када се има темељна дискусија и разумевање, примећује се да „нови“ оператер има превише предности. Предности 'нев' оператора за доделу меморије су следеће:

• Нови оператер може бити преоптерећен са већом лакоћом.
• Док се меморија додељује током времена извођења, кад год нема довољно меморије, аутоматски ће бити избачен изузетак, а не само прекид програма.
• Ужурбаност коришћења процедуре превођења типа овде није присутна јер оператор „нев“ има исти тип као меморија коју смо доделили.
• Оператор „нев“ такође одбацује идеју коришћења оператора сизеоф() јер ће „нев“ неизбежно израчунати величину објеката.
• Оператор „нев“ нам омогућава да иницијализујемо и декларишемо објекте иако спонтано генерише простор за њих.

Ц++ низови:

Имаћемо детаљну дискусију о томе шта су низови и како су декларисани и имплементирани у Ц++ програму. Низ је структура података која се користи за чување више вредности у само једној променљивој, чиме се смањује гужва око независног декларисања многих варијабли.

Декларација низова:

За декларисање низа, прво треба дефинисати тип променљиве и дати одговарајуће име низу које се затим додаје дуж угластих заграда. Ово ће садржати број елемената који показују величину одређеног низа.

На пример:

Ова променљива је декларисана показујући да садржи пет стрингова у низу под називом „шминка“. Да бисмо идентификовали и илустровали вредности за овај низ, потребно је да користимо витичасте заграде, при чему је сваки елемент засебно затворен двоструким обрнутим зарезима, од којих је сваки одвојен једним зарезом између.

На пример:

Слично томе, ако желите да креирате још један низ са другачијим типом података који би требало да буде „инт“, онда би процедура била иста, само треба да промените тип података променљиве као што је приказано у наставку:

Док се низу додељују целобројне вредности, оне не смеју да се налазе у обрнутим зарезима, што би функционисало само за стринг променљиву. Дакле, коначно, низ је колекција међусобно повезаних ставки података са изведеним типовима података који су ускладиштени у њима.

Како приступају елементима у низу?

Сви елементи укључени у низ имају посебан број који је њихов индексни број који се користи за приступ елементу из низа. Вредност индекса почиње са 0 до један мање од величине низа. Прва вредност има вредност индекса 0.

Пример:

Размотримо веома једноставан и једноставан пример у коме ћемо иницијализовати променљиве у низу.

У првом кораку, уграђујемо датотеку заглавља <иостреам>, која ће аутоматски додати све потребне библиотеке у програм. Простор имена „стд“ ће обезбедити опсег за директоријуме. У трећем реду зовемо главни() функција. Витичаста заграда означава почетак функције. Након уласка у функцију, декларисаћемо низ типа „инт“ под називом „цифре“. Садржи величину 4, што значи да може садржати само 4 целобројне вредности одједном. Сваком елементу у низу је додељена јединствена и другачија цифра посебно. Цео низ се затим приказује са сваком ставка која се позива појединачно.

Ово је резултат добијен из горњег кода. Кључна реч „ендл“ аутоматски помера другу ставку у следећи ред.

Пример:

У овом коду користимо петљу „фор“ за штампање ставки низа.

У горњем случају, додајемо основну библиотеку. Стандардни простор имена се додаје. Тхе главни() функција је функција у којој ћемо извршити све функционалности за извршавање одређеног програма. Затим декларишемо низ типа инт под називом 'Нум', који има величину 10. Вредност ових десет променљивих се преузима од корисника коришћењем петље 'фор'. За приказ овог низа, поново се користи петља „фор“. 10 целих бројева ускладиштених у низу се приказује уз помоћ наредбе „цоут“.

Ово је излаз који смо добили од извршења горњег кода, који приказује 10 целих бројева различитих вредности.

Пример:

У овом сценарију, предстоји нам да сазнамо просечан резултат ученика и проценат који је добио у разреду.

Прво, потребно је да додате библиотеку која ће пружити почетну подршку Ц++ програму. Затим наводимо величину 5 низа под називом „Сцоре“. Затим смо иницијализовали променљиву „збир“ типа података флоат. Резултати сваког предмета се преузимају од корисника ручно. Затим се користи петља „за“ да би се сазнао просек и проценат свих укључених субјеката. Збир се добија коришћењем низа и 'фор' петље. Затим се просек налази помоћу формуле за просек. Након што сазнамо просек, преносимо његову вредност у проценат који се додаје формули да бисмо добили проценат. Затим се израчунавају и приказују просек и проценат.

Ово је коначни резултат где се резултати узимају од корисника за сваки предмет појединачно и израчунавају се просек и проценат.

Предности коришћења низова:

• Ставкама у низу је лако приступити због индексног броја који им је додељен.
• Лако можемо извршити операцију претраживања преко низа.
• У случају да желите сложеност у програмирању, можете користити 2-димензионални низ који такође карактерише матрице.
• За складиштење више вредности које имају сличан тип података, низ се може лако користити.

Недостаци коришћења низова:

• Низови имају фиксну величину.
• Низови су хомогени што значи да се чува само један тип вредности.
• Низови чувају податке у физичкој меморији појединачно.
• Процес уметања и брисања није лак за низове.

Ц++ објекти и класе:

Ц++ је објектно оријентисани програмски језик, што значи да објекти играју виталну улогу у Ц++. Када говоримо о објектима, прво треба размотрити шта су објекти, тако да је објекат било која инстанца класе. Како се Ц++ бави концептима ООП-а, главне ствари о којима треба разговарати су објекти и класе. Класе су у ствари типови података које дефинише сам корисник и намењене су да инкапсулирају чланове података и функције које су доступне само када је инстанца за одређену класу креирана. Чланови података су променљиве које су дефинисане унутар класе.

Другим речима, класа је оквир или дизајн који је одговоран за дефиницију и декларацију чланова података и функција додељених тим члановима података. Сваки од објеката који су декларисани у класи могао би да дели све карактеристике или функције које класа демонстрира.

Претпоставимо да постоји класа која се зове птице, сада у почетку све птице могу да лете и имају крила. Дакле, летење је понашање које ове птице усвајају и крила су део њиховог тела или основна карактеристика.

Дефинисање класе:

Да бисте дефинисали класу, морате пратити синтаксу и ресетовати је према вашој класи. Кључна реч 'цласс' се користи за дефинисање класе, а сви остали чланови података и функције су дефинисани унутар витичастих заграда након којих следи дефиниција класе.

Декларисање објеката:

Убрзо након дефинисања класе, потребно је да креирамо објекте за приступ и дефинисање функција које су одређене од стране класе. За то морамо да напишемо име класе, а затим и име објекта за декларацију.

Приступ члановима података:

Функцијама и члановима података се приступа уз помоћ једноставне тачке „.“ оператора. Члановима јавних података се такође приступа преко овог оператера, али у случају чланова приватних података, једноставно им не можете директно приступити. Приступ члановима података зависи од контрола приступа које им дају модификатори приступа који су или приватни, јавни или заштићени. Ево сценарија који показује како декларисати једноставну класу, чланове података и функције.

Пример:

У овом примеру ћемо дефинисати неколико функција и приступити функцијама класе и члановима података уз помоћ објеката.

У првом кораку, интегришемо библиотеку након чега треба да укључимо пратеће директоријуме. Класа је експлицитно дефинисана пре позивања главни() функција. Ова класа се назива „возило“. Чланови података били су „име возила и „ид” тог возила, што је број таблице за то возило које има низ, односно инт тип података. Две функције су декларисане за ова два члана података. Тхе ид() функција приказује ИД возила. Пошто су подаци чланови класе јавни, можемо им приступити и ван класе. Стога, позивамо на име() функцију изван класе, а затим преузима вредност за „ВехицлеНаме“ од корисника и штампа је у следећем кораку. У главни() функцију, декларишемо објекат потребне класе који ће помоћи у приступу члановима података и функцијама из класе. Даље, иницијализујемо вредности за име возила и његов ИД, само ако корисник не да вредност за име возила.

Ово је резултат који се добија када корисник сам унесе име за возило и регистарске таблице су статичка вредност која му је додељена.

Говорећи о дефиницији функција чланова, мора се разумети да није увек обавезно дефинисати функцију унутар класе. Као што видите у горњем примеру, дефинишемо функцију класе ван класе јер су чланови података јавно декларисани и то се ради уз помоћ оператора резолуције опсега приказаног као '::' заједно са именом класа и име функције.

Ц++ конструктори и деструктори:

Ову тему ћемо детаљно сагледати уз помоћ примера. Брисање и креирање објеката у Ц++ програмирању су веома важни. Због тога, кад год креирамо инстанцу за класу, аутоматски позивамо методе конструктора у неколико случајева.

Конструктори:

Као што име каже, конструктор је изведен из речи 'конструкт' која специфицира стварање нечега. Дакле, конструктор је дефинисан као изведена функција новокреиране класе која дели име класе. И користи се за иницијализацију објеката укључених у класу. Такође, конструктор нема повратну вредност за себе, што значи да ни његов тип враћања неће бити неважећи. Аргументе није обавезно прихватити, али се по потреби могу додати. Конструктори су корисни у додељивању меморије објекту класе и у постављању почетне вредности за променљиве члана. Почетна вредност се може пренети у облику аргумената у функцију конструктора када се објекат иницијализује.

Синтакса:

Врсте конструктора:

Параметризовани конструктор:

Као што је раније речено, конструктор нема ниједан параметар, али се може додати параметар по свом избору. Ово ће иницијализовати вредност објекта док се креира. Да бисте боље разумели овај концепт, размотрите следећи пример:

Пример:

У овом случају, креирали бисмо конструктор класе и декларисали параметре.

Ми укључујемо датотеку заглавља у првом кораку. Следећи корак коришћења именског простора је подршка директоријумима за програм. Класа под називом „цифре“ је декларисана где се прво променљиве јавно иницијализују тако да им се може приступити кроз програм. Декларисана је променљива под називом „диг1“ са целим бројем података. Затим смо декларисали конструктор чије је име слично имену класе. Овај конструктор има целобројну променљиву која му је прослеђена као „н“, а променљива класе „диг1“ је постављена као н. У главни() функција програма, креирају се три објекта за класу 'цифре' и додељују неке насумичне вредности. Ови објекти се затим користе за позивање варијабли класе којима се аутоматски додељују исте вредности.

Целобројне вредности се приказују на екрану као излаз.

Конструктор копирања:

То је тип конструктора који објекте разматра као аргументе и дуплира вредности чланова података једног објекта другом. Стога се ови конструктори користе за декларисање и иницијализацију једног објекта од другог. Овај процес се назива иницијализација копирања.

Пример:

У овом случају, конструктор копирања ће бити декларисан.

Прво, интегришемо библиотеку и директоријум. Декларисана је класа под називом „Ново“ у којој су цели бројеви иницијализовани као „е“ и „о“. Конструктор се објављује када се двема променљивим додељују вредности и ове променљиве се декларишу у класи. Затим се ове вредности приказују уз помоћ главни() функција са 'инт' као типом враћања. Тхе приказ() функција се позива и дефинише након тога где се бројеви приказују на екрану. Унутар главни() функције, објекти се праве и ови додељени објекти се иницијализују насумичним вредностима, а затим приказ() метода се користи.

Излаз добијен употребом конструктора копирања је приказан у наставку.

разарачи:

Као што име дефинише, деструктори се користе за уништавање објеката креираних од стране конструктора. Упоредиво са конструкторима, деструктори имају идентично име као класа, али са додатном тилдом (~).

Синтакса:

Деструктор не узима никакве аргументе и чак нема повратну вредност. Компајлер се имплицитно позива на излазак из програма ради чишћења складишта којем више није приступачно.

Пример:

У овом сценарију користимо деструктор за брисање објекта.

Овде се прави час „ципеле“. Креира се конструктор који има слично име као и класа. У конструктору се приказује порука где је објекат креиран. Након конструктора, прави се деструктор који брише објекте креиране конструктором. У главни() функција, креира се објекат показивача под називом „с“ и кључна реч „делете“ се користи за брисање овог објекта.

Ово је излаз који смо добили од програма где деструктор чисти и уништава креирани објекат.

Разлика између конструктора и деструктора:

Ц++ наслеђивање:

Сада ћемо научити о Ц++ наслеђивању и његовом опсегу.

Наслеђивање је метода помоћу које се генерише нова класа или потиче од постојеће класе. Садашња класа се назива „основна класа“ или такође „родитељска класа“, а нова класа која се креира назива се „изведена класа“. Када кажемо да је подређена класа наслеђена од родитељске класе, то значи да дете поседује сва својства родитељске класе.

Наслеђе се односи на (је а) однос. Сваки однос називамо наслеђем ако се користи 'ис-а' између две класе.

На пример:

• Папагај је птица.
• Компјутер је машина.

Синтакса:

У Ц++ програмирању користимо или пишемо наслеђивање на следећи начин:

Начини наслеђивања Ц++-а:

Наслеђивање укључује 3 начина наслеђивања класа:

• Јавно: У овом режиму, ако је декларисана класа подређена, онда се чланови надређене класе наслеђују од подређене класе као исте у надређеној класи.
• Заштићено: И У овом режиму, јавни чланови родитељске класе постају заштићени чланови подређене класе.
• Приватни : У овом режиму, сви чланови родитељске класе постају приватни у подређеној класи.

Типови Ц++ наслеђивања:

Следе типови Ц++ наслеђивања:

1. Појединачно наслеђе:

Са оваквом врстом наслеђа, класе су настале из једне основне класе.

Синтакса:

2. Вишеструко наслеђе:

У овој врсти наслеђивања, класа може да потиче из различитих основних класа.

Синтакса:

3. Наслеђивање на више нивоа:

Подређена класа потиче од друге подређене класе у овом облику наслеђивања.

Синтакса:

4. Хијерархијско наслеђе:

Неколико подкласа се креира из једне основне класе у овом методу наслеђивања.

Синтакса:

5. Хибридно наслеђе:

Код ове врсте наслеђивања комбинује се више наслеђа.

Синтакса:

Пример:

Покренућемо код да бисмо демонстрирали концепт вишеструког наслеђивања у Ц++ програмирању.

Пошто смо започели са стандардном библиотеком улазно-излазних података, тада смо основној класи дали назив „Бирд“ и учинили је јавном тако да њени чланови могу бити доступни. Затим, имамо основну класу „Рептиле“ и такође смо је објавили. Затим имамо „цоут“ за штампање излаза. Након овога, направили смо 'пингвина' за децу. У главни() функцију коју смо направили објектом класе пингвин 'п1'. Прво ће се извршити класа „Птица“, а затим класа „Рептиле“.

Након извршења кода у Ц++, добијамо излазне изјаве базних класа „Бирд“ и „Рептиле“. То значи да је класа „пингвин“ изведена из основних класа „птица“ и „гмизавац“ јер је пингвин и птица као и рептил. Може да лети као и да пузи. Отуда је вишеструко наслеђивање доказало да једна подређена класа може бити изведена из више основних класа.

Пример:

Овде ћемо извршити програм који ће показати како да се користи вишестепено наслеђивање.

Наш програм смо започели коришћењем улазно-излазних токова. Затим смо прогласили родитељску класу „М“ која је постављена да буде јавна. Позвали смо приказ() функцију и команду „цоут“ за приказ изјаве. Затим смо креирали подређену класу „Н“ која је изведена из родитељске класе „М“. Имамо нову подређену класу 'О' изведену из подређене класе 'Н' и тело обе изведене класе је празно. На крају, позивамо се на главни() функција у којој морамо да иницијализујемо објекат класе 'О'. Тхе приказ() функција објекта се користи за демонстрирање исхода.

На овој слици имамо исход класе 'М' која је родитељска класа јер смо имали а приказ() функција у њему. Дакле, класа „Н“ је изведена из родитељске класе „М“, а класа „О“ из родитељске класе „Н“ која се односи на наслеђе на више нивоа.

Ц++ полиморфизам:

Термин „полиморфизам“ представља збирку две речи 'поли' и ' морфизам' . Реч „Поли“ представља „много“, а „морфизам“ представља „облике“. Полиморфизам значи да се објекат може различито понашати у различитим условима. Омогућава програмеру да поново користи и прошири код. Исти код се понаша различито у зависности од услова. Реализација објекта се може применити у време извођења.

Категорије полиморфизма:

Полиморфизам се углавном јавља на два начина:

1. Полиморфизам времена компајлирања
2. Полиморфизам времена рада

Хајде да објаснимо.

6. Полиморфизам времена компајлирања:

За то време, унети програм се мења у извршни програм. Пре постављања кода, грешке се откривају. Постоје пре свега две његове категорије.

• Функција преоптерећења
• Преоптерећење оператера

Погледајмо како користимо ове две категорије.

7. Преоптерећење функције:

То значи да функција може да обавља различите задатке. Функције су познате као преоптерећене када постоји неколико функција са сличним именом, али различитим аргументима.

Прво, користимо библиотеку <иостреам> као и стандардни простор имена. Затим бисмо кориснички дефинисану класу прогласили „Додај“. Унутар класе дефинишемо функцију АДД() са два параметра као публиц. Опет, прогласите нову функцију унутар тела класе са истим именом, али ова функција нема параметар. Овде иницијализујемо три стринга. Прва два низа имају неку вредност и последњи низ се користи за спајање прва два низа. Користимо команду „цоут“ за штампање резултата. Затим зовемо главни() метода ван часа. Конструишемо објекат потребне класе „Додај“. Сада позивамо прву функцију са два параметра, а затим позивамо и другу функцију. У последњем кораку укључујемо наредбу „ретурн 0“ да завршимо програм.

Преоптерећење оператера:

Процес дефинисања вишеструких функционалности оператора назива се преоптерећење оператора.

Горњи пример укључује датотеку заглавља <иостреам>. Затим смо користили стандардни именски простор. Дефинишемо класу „Интегер“. Унутар ове класе наводимо цео број као приватни члан класе. Затим, декларишемо Параметеризовани конструктор као јавни члан и иницијализујемо вредност целог броја у њему. Дефинишемо конструктор са оператором префикса преоптерећења. Унутар овог конструктора вршимо операцију префикса. Штавише, креирамо функцију која приказује вредност прираштаја користећи наредбу „цоут“. У међувремену, позивамо се на главни() функција. Овде креирамо два објекта класе. Први објекат прослеђује вредност целог броја. Затим употребите наредбу „цоут“ да одштампате ред „Пре повећања вредности је“. Следеће, зовемо приказ() функција за први објекат. Други објекат користи оператор пре-инкремента. Користимо команду „цоут“ да прикажемо ред „Након претходног повећања вредности је“. Затим користимо приказ() функција за други објекат.

8. Полиморфизам времена рада:

То је временски распон у којем се код покреће. Након употребе кода, грешке се могу открити.

Замена функције:

То се дешава када изведена класа користи сличну дефиницију функције као једна од функција члана основне класе.

У првом реду уграђујемо библиотеку <иостреам> за извршавање улазних и излазних операција. Даље, додајемо стандардни простор имена. У следећем реду проглашавамо родитељску класу 'Ман'. Унутар класе дефинишемо функцију са два параметра као публиц. Затим користимо изјаву „цоут“ да прикажемо текст „Валкинг“. Изван класе креирамо подређену класу „Анимал“ која је изведена из родитељске класе. Овде креирамо функцију која има слично име као оно које је раније декларисано у надређеној класи. Затим употребите изјаву „цоут“ да бисте приказали текст „Једење“. Користимо главни() функција. У међувремену, креирамо објекат класе „м“. Затим, позивамо функцију родитељске класе као и функцију подређене класе. Користите команду „врати 0“.

Ц++ стрингови:

Сада ћемо открити како да декларишемо и иницијализујемо стринг у Ц++. Стринг се користи за складиштење групе знакова у програму. Он складишти абецедне вредности, цифре и посебне симболе типа у програму. Он је резервисао знакове као низ у Ц++ програму. Низови се користе за резервисање колекције или комбинације знакова у Ц++ програмирању. За завршетак низа користи се посебан симбол познат као нулти карактер. Представљен је излазном секвенцом (\0) и користи се за одређивање краја стринга.

Добијте стринг помоћу команде 'цин':

Користи се за унос променљиве низа без икаквог празног простора у њој. У датом примеру имплементирамо Ц++ програм који добија име корисника помоћу команде „цин“.

У првом кораку користимо библиотеку <иостреам>. У међувремену, укључили смо стандардни простор имена. Затим, проглашавамо главни() функција. Иницијализујемо стринг типа карактера унутар тела главни() функција. Затим користимо изјаву „цоут“ да одштампамо „Унесите своје име“. Користимо команду 'цин' да тражимо стринг од корисника. Команда 'цоут' се примењује за штампање имена које би корисник написао. Наредба ретурн 0 се додаје да прекине програм.

Корисник уноси име „Ахмед Цхаудри“. Али добијамо само „Ахмед“ као излаз, а не комплетан „Ахмед Цхаудри“ јер команда „цин“ не може да ускладишти стринг са празним размаком. Чува само вредност пре размака.

Добијте стринг помоћу функције цин.гет():

Тхе добити() функција команде цин се користи за добијање стринга са тастатуре који може да садржи празна места.

Горњи пример укључује библиотеку <иостреам> за обављање улазних и излазних операција. Затим смо користили стандардни именски простор. Тхе главни() функција се зове. Након тога, иницијализујемо стринг под називом 'с'. У следећем кораку, команда 'цоут' се користи за приказ изјаве 'Унесите стринг'. Тхе цин.гет() се примењује за добијање стринга од корисника. Коришћењем цин.гет() функцију прослеђујемо вредност стринга и наводимо величину стринга као параметар. Команда 'цоут' се поново користи за приказ излаза програма. На крају додајемо повратну 0.

Корисник уноси стринг „Моје име је Али“. Добијамо комплетан стринг „Моје име је Али“ као резултат јер функција цин.гет() прихвата стрингове који садрже празна места.

Коришћење 2Д (дводимензионалног) низа низова:

У овом случају, узимамо унос (име три града) од корисника коришћењем 2Д низа низова.

Прво, интегришемо датотеку заглавља <иостреам> и стандардни простор имена. Позивамо се на главни() функција. Затим иницијализујемо дводимензионални низ знакова са три реда и петнаест колона. У следећем кораку, фор петља се користи за бројање променљиве 'и' за понављање преко потребног низа док се не идентификује нулти карактер. Унутар тела „фор“ петље користимо команду „цоут“ да прикажемо ред „Унесите име града“. Затим користите изјаву „цин“ да бисте добили име града. Поново користимо другу „фор“ петљу и „цоут“ наредбу да прикажемо називе градова у низу док се петља не заврши. Затим се користи команда 'ретурн 0'.

Овде корисник уноси назив три различита града. Програм користи индекс реда да би добио три вредности низа. Свака вредност се задржава у свом реду. Први низ се чува у првом реду и тако даље. Свака вредност низа се приказује на исти начин коришћењем индекса реда.

Стандардна библиотека Ц++:

Библиотека Ц++ је кластер или група многих функција, класа, константи и свих сродних ставки које су готово у једном одговарајућем скупу, увек дефинишући и декларишући стандардизоване датотеке заглавља. Имплементација ових укључује две нове датотеке заглавља које Ц++ стандард не захтева под називом <хасх_мап> и <хасх_сет>. Присутна је дуга листа обавезних датотека заглавља која зависи од захтева компајлера. Датотеке заглавља садрже листу заглавља која садржи сав садржај из Ц++ стандардне библиотеке, укључујући и специфичне датотеке заглавља за шаблон стандардне библиотеке (СТЛ).

Стандардна библиотека уклања гужву око поновног писања инструкција током програмирања. Ово има много библиотека унутар себе које имају ускладиштени код за многе функције. Да бисте добро искористили ове библиотеке, обавезно их је повезати уз помоћ датотека заглавља. Када увозимо улазну или излазну библиотеку, то значи да увозимо сав код који је ускладиштен у тој библиотеци и на тај начин можемо да користимо и функције које су у њој затворене тако што ћемо сакрити сав основни код који вам можда неће требати види.

Стандардна библиотека Ц++ подржава следећа два типа:

• Хостована имплементација која обезбеђује све основне датотеке заглавља стандардне библиотеке описане Ц++ ИСО стандардом.
• Самостална имплементација која захтева само део датотека заглавља из стандардне библиотеке. Одговарајући подскуп је:

Неколико датотека заглавља је жалосно откако је дошло 11 Ц++: то су <цисо646>, <цстдалигн> и <цстдбоол>.

Разлике између хостованих и самосталних имплементација су као што је илустровано у наставку:

• У хостованој имплементацији, морамо да користимо глобалну функцију која је главна функција. Док је у самостојећој имплементацији, корисник може самостално декларисати и дефинисати почетну и завршну функцију.
• Имплементација хостинга има једну нит која се обавезно покреће у време подударања. Док, у самостојећој имплементацији, имплементатори ће сами одлучити да ли им је потребна подршка истовремене нити у њиховој библиотеци.

Врсте:

Ц++ подржава и самостојећи и хостовани. Датотеке заглавља су подељене у следеће две:

• Иостреам делови
• Ц++ СТЛ делови (Стандардна библиотека)

Кад год пишемо програм за извршавање у Ц++, увек позивамо функције које су већ имплементиране унутар СТЛ-а. Ове познате функције ефикасно преузимају улаз и излаз користећи идентификоване операторе.

Узимајући у обзир историју, СТЛ се у почетку звао Стандардна библиотека шаблона. Затим су делови СТЛ библиотеке стандардизовани у Стандардној библиотеци Ц++ која се данас користи. То укључује ИСО Ц++ рунтиме библиотеку и неколико фрагмената из библиотеке Боост укључујући неке друге важне функционалности. Повремено СТЛ означава контејнере или чешће алгоритме Ц++ стандардне библиотеке. Сада, ова СТЛ или Стандардна библиотека шаблона у потпуности говори о познатој Ц++ стандардној библиотеци.

стд именски простор и датотеке заглавља:

Све декларације функција или променљивих се раде унутар стандардне библиотеке уз помоћ датотека заглавља које су равномерно распоређене међу њима. Декларација се неће десити осим ако не укључите датотеке заглавља.

Претпоставимо да неко користи листе и низове, мора да дода следеће датотеке заглавља:

Ове угаоне заграде '<>' означавају да се мора потражити ову конкретну датотеку заглавља у директоријуму који се дефинише и укључује. У ову библиотеку можете додати и екстензију „.х“, што се ради по потреби или жељи. Ако изузмемо библиотеку „.х“, потребан нам је додатак „ц“ непосредно пре почетка имена датотеке, само као индикација да ова датотека заглавља припада Ц библиотеци. На пример, можете писати (#инцлуде <Цардс.х> или #инцлуде <цЦард>).

Говорећи о именском простору, цела стандардна библиотека Ц++ лежи унутар овог именског простора означеног као стд. То је разлог зашто корисници морају компетентно дефинисати стандардизоване називе библиотека. На пример:

Ц++ вектори:

Постоји много начина за чување података или вредности у Ц++. Али за сада тражимо најлакши и најфлексибилнији начин чувања вредности док пишемо програме на језику Ц++. Дакле, вектори су контејнери који су правилно секвенцирани у низу чија величина варира у време извршења у зависности од уметања и одузимања елемената. То значи да је програмер могао да промени величину вектора по својој жељи током извршавања програма. Они подсећају на низове на такав начин да такође имају преносиве позиције за складиштење својих укључених елемената. За проверу броја вредности или елемената присутних унутар вектора, треба да користимо „ стд::цоунт’ функција. Вектори су укључени у стандардну библиотеку шаблона Ц++-а тако да има дефинитивну датотеку заглавља коју прво треба укључити, а то је:

Декларација:

Декларација вектора је приказана испод.

Овде је вектор кључна реч која се користи, ДТ приказује тип података вектора који се може заменити са инт, флоат, цхар или било којим другим сродним типовима података. Горња изјава се може преписати као:

Величина вектора није наведена јер се величина може повећати или смањити током извршавања.

Иницијализација вектора:

За иницијализацију вектора, постоји више од једног начина у Ц++.

Техника број 1:

У овој процедури директно додељујемо вредности за оба вектора. Вредности додељене обема су потпуно сличне.

Техника број 2:

У овом процесу иницијализације, 3 диктира величину вектора, а 15 је податак или вредност која је у њему ускладиштена. Вектор типа података 'инт' са датом величином 3 који чува вредност 15 је креиран што значи да вектор 'в3' складишти следеће:

Главне операције:

Главне операције које ћемо имплементирати на векторима унутар векторске класе су:

• Додавање вредности
• Приступ вредности
• Промена вредности
• Брисање вредности

Додавање и брисање:

Додавање и брисање елемената унутар вектора врши се систематски. У већини случајева, елементи се убацују при завршетку векторских контејнера, али такође можете додати вредности на жељено место које ће на крају померити остале елементе на њихове нове локације. Док, у брисању, када се вредности избришу са последње позиције, то ће аутоматски смањити величину контејнера. Али када се вредности унутар контејнера насумично избришу са одређене локације, нове локације се аутоматски додељују другим вредностима.

Коришћене функције:

Да бисте променили или променили вредности ускладиштене унутар вектора, постоје неке унапред дефинисане функције познате као модификатори. Они су следећи:

• Инсерт(): Користи се за додавање вредности унутар векторског контејнера на одређеној локацији.
• Ерасе(): Користи се за уклањање или брисање вредности унутар векторског контејнера на одређеној локацији.
• Свап(): Користи се за замену вредности унутар векторског контејнера који припада истом типу података.
• Ассигн(): Користи се за додељивање нове вредности претходно ускладиштеној вредности унутар векторског контејнера.
• Бегин(): Користи се за враћање итератора унутар петље која адресира прву вредност вектора унутар првог елемента.
• Цлеар(): Користи се за брисање свих вредности ускладиштених унутар векторског контејнера.
• Пусх_бацк(): Користи се за додавање вредности при завршетку векторског контејнера.
• Поп_бацк(): Користи се за брисање вредности при завршетку векторског контејнера.

Пример:

У овом примеру, модификатори се користе дуж вектора.

Прво, укључујемо датотеке заглавља <иостреам> и <вецтор>. Након овога, стд простора имена је интегрисан да би се све класе додале одједном. За писање целокупне логике програма, позивамо функцију маин() где се иницијализује вектор назван „цифре“. Додељивање овог вектора се врши у следећем кораку где су 'цифре' дале вредност 6 и 24, што значи да је 6 елемената ускладиштено унутар векторског контејнера, сваки са вредношћу 24. Ове вредности се затим приказују помоћу 'цоут' ' команда. Петља „фор“ се користи за функцију модификатора пусх_бацк() за додавање елемената унутар контејнера. Сада се цифрама на крају додаје 3 вредност. Ми иницијализујемо променљиву 'к' за чување записа о величини векторског контејнера. Сада је приказана вредност последњег елемента и поп_бацк() функција би избрисала број '3' ускладиштен унутар контејнера. За приказ свих елемената, поново користимо петљу 'фор' са инсерт() модификатор који ће уметнути вредности. Овде ће 4 бити уметнуто на почетак векторског контејнера и приказано на екрану. Тхе јасно() модификатор ће тада обрисати или избрисати све вредности ускладиштене унутар контејнера. Величина вектора је тада приказана након што је чишћење завршено.

Излаз је приказан испод.

Ц++ датотеке Улаз Излаз:

Датотека је скуп међусобно повезаних података. У Ц++, датотека је низ бајтова који се скупљају заједно хронолошким редом. Већина датотека постоји унутар диска. Али и хардверски уређаји као што су магнетне траке, штампачи и комуникационе линије су такође укључени у датотеке.

Улаз и излаз у датотекама карактеришу три главне класе:

• Класа 'истреам' се користи за унос података.
• Класа „остреам“ се користи за приказивање излаза.
• За улаз и излаз користите класу 'иостреам'.

Датотеке се у Ц++ обрађују као токови. Када узимамо улаз и излаз у датотеци или из датотеке, следеће су класе које се користе:

• Оффстреам: То је класа стрима која се користи за писање у датотеку.
• Ифстреам: То је класа стрима која се користи за читање садржаја из датотеке.
• Стрим: То је класа стрима која се користи и за читање и за писање у датотеку или из датотеке.

Класе 'истреам' и 'остреам' су преци свих класа које су горе поменуте. Токови датотека су једноставни за коришћење као и команде „цин“ и „цоут“, само са разликом у повезивању ових токова датотека са другим датотекама. Хајде да видимо пример да укратко проучимо класу 'фстреам':

Пример:

У овом случају, уписујемо податке у датотеку.

У првом кораку интегришемо улазни и излазни ток. Затим се додаје датотека заглавља <фстреам> јер ћемо писати и читати податке из датотеке. Након овога, класе се позивају уз помоћ именског простора. Тхе главни() функција се позива за тело програма где се користи „офстреам“ који уписује податке у датотеку, датотека се креира као Нев_Филе. У следећем кораку отварамо текстуалну датотеку под називом „пример“ користећи отвори ( ) метода. У датотеку уписујемо текст уз помоћ угаоних заграда. Сваки фајл је предодређен да се затвори након што се ухвати у коштац. Због тога се датотека затвара уз помоћ Близу() функција.

„Пример“ датотеке се отвара са персоналног рачунара и текст написан у датотеци се утискује у ову текстуалну датотеку као што је приказано изнад.

Отварање датотеке:

Када се датотека отвори, она је представљена током. За датотеку је креиран објекат као што је Нев_Филе креиран у претходном примеру. Све улазне и излазне операције које су обављене у току аутоматски се примењују на саму датотеку. За отварање датотеке, функција опен() се користи као:

Овде режим није обавезан.

Затварање датотеке:

Када се заврше све операције уноса и излаза, морамо затворити датотеку која је отворена за уређивање. Од нас се тражи да запослимо а Близу() функција у овој ситуацији.

Када се ово уради, датотека постаје недоступна. Ако под било којим околностима објекат буде уништен, чак и ако је повезан са датотеком, деструктор ће спонтано позвати функцију цлосе().

Текстуалне датотеке:

Текстуалне датотеке се користе за чување текста. Стога, ако се текст или унесе или прикаже, он ће имати неке измене у форматирању. Операција писања унутар текстуалне датотеке је иста као што изводимо команду „цоут“.

Пример:

У овом сценарију уписујемо податке у текстуалну датотеку која је већ направљена на претходној илустрацији.

Овде уписујемо податке у датотеку под називом „пример“ користећи функцију Нев_Филе(). Отварамо датотеку „пример“ користећи опен() методом. „Офстреам“ се користи за додавање података у датотеку. Након што обавите сав рад унутар датотеке, потребна датотека се затвара коришћењем Близу() функција. Ако се датотека не отвори, приказује се порука о грешци „Датотека није подржана, грешка при учитавању датотеке“.

Датотека се отвара и текст се приказује на конзоли.

Читање текстуалне датотеке:

Читање датотеке је приказано уз помоћ следећег примера.

Пример:

'ифстреам' се користи за читање података ускладиштених унутар датотеке.

Пример укључује главне датотеке заглавља <иостреам> <фстреам> <стринг> на почетку. Затим користите „ифстреам“ унутар главни() функција. Уз помоћ 'ифстреам', читаћемо податке са датотеком 'Нев_Филе' која приказује текст ускладиштен унутар текстуалне датотеке 'екампле'. Ми запошљавамо опен() метод за отварање датотеке. Затим ћемо користити петљу 'вхиле'. Након читања података из текстуалне датотеке „пример“, Близу() функција се користи за затварање потребне датотеке. Ако систем нема одређену датотеку, добијамо поруку „Није могуће отворити датотеку“.

Све информације ускладиштене унутар текстуалне датотеке се приказују на екрану као што је приказано.

Закључак

У горњем водичу смо детаљно научили о језику Ц++. Уз примере, свака тема је демонстрирана и објашњена, а свака радња је разрађена.