Унарни оператор у Ц++

Unarni Operator U C



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

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

Пример 1: Оператори повећања (++) и декремента (–).

Унарни оператори инкремент (++) и декремент (–) су основни алати у Ц++ за модификацију вредности променљиве повећањем или смањењем за 1, респективно. Оператор повећања (++) додаје 1 вредности променљиве, док оператор декремента (–) одузима 1. Ови оператори се могу применити на променљиве са целим бројем, покретним зарезом и показивачем, обезбеђујући флексибилност у њиховој употреби.







Хајде да истражимо ове операторе кроз практичан пример:



#инцлуде <иостреам>
Користећи именског простора стд ;

инт главни ( )
{

инт бројач = 0 ;

// Оператор повећања
цоут << 'Почетна вредност: ' << бројач << ендл ;

бројач ++ ;
цоут << 'Вредност након повећања: ' << бројач << ендл ;

// Оператор декремента
бројач -- ;
цоут << 'Вредност после смањења: ' << бројач << ендл ;

повратак 0 ;
}

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



Након ове операције, ажурирана вредност „цоунтер“ се приказује помоћу друге „цоут“ изјаве. Након тога, користимо оператор декремента (цоунтер—) да смањимо вредност „цоунтер“ за 1. Резултат се затим приказује на конзоли. На крају, програм се завршава са „повратком 0;“ изјава која указује на успешно извршење.





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



Пример 2: Позитивни (+) и негативни (-) оператори

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

#инцлуде <иостреам>
Користећи именског простора стд ;

инт главни ( ) {
инт позитивна вредност = 10 ;
инт негативнаВалуе = - позитивна вредност ;

цоут << 'Позитивна вредност: ' << позитивна вредност << ендл ;
цоут << 'Негативна вредност: ' << негативнаВалуе << ендл ;

повратак 0 ;
}

Иницијализујемо две целобројне променљиве за овај пример кода које су „позитивна вредност“ и „негативна вредност“. “поситивеВалуе” се додељује са вредношћу 10. Након тога, декларишемо “негативну вредност” и додељујемо јој негацију “поситивеВалуе” користећи унарни минус оператор. Овај оператор ефективно мења предзнак оригиналне вредности. Затим користимо наредбу „цоут“ да прикажемо и позитиван и негативан излаз на конзоли. Коначно, програм враћа 0 што указује на успешан завршетак главне функције.

Када се изврши, овај програм даје позитивне и негативне вредности.

Пример 3: Логички НОТ (!) Оператор

Унарни оператор у Ц++, означен са '!' симбол, познат је као логички НОТ оператор. Дизајниран је да инвертује вредност истинитости датог израза. Он ради на једном операнду који је обично логички израз или услов. Логичка НОТ операција даје „тачан” исход када је операнд „лажан” и даје „лажан” исход када је операнд „тачан”.

Ево једноставног примера који показује употребу логичког НОТ оператора:

#инцлуде <иостреам>
Користећи именског простора стд ;

инт главни ( ) {
боол тачно је = истина ;
боол исФалсе = лажно ;

боол ресултНотТруе = ! тачно је ;
боол ресултНотФалсе = ! исФалсе ;

цоут << 'Оригинална вредност: ' << тачно је << ', после НЕ: ' << ресултНотТруе << ендл ;
цоут << 'Оригинална вредност: ' << исФалсе << ', после НЕ: ' << ресултНотФалсе << ендл ;

повратак 0 ;
}

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

Након извршавања овог програма, приметићемо да логички НОТ оператор мења вредност истинитости „исТруе“ (у почетку је постављена на труе), чинећи је лажном. Слично томе, он инвертује вредност истинитости „исФалсе“ (првобитно лажна), дајући истиниту.

Излаз јасно илуструје инверзију истинитих вредности које се постижу логичким НОТ оператором.

Пример 4: Битвисе НОТ (~) оператор

Битни НОТ оператор (~) у Ц++ је унарни оператор који врши негацију сваког бита свог операнда. Функционише са основним типовима података, посебно интегралним, као што су цели бројеви. Исход се постиже инвертовањем сваког појединачног бита у операнду, претварањем 0с у 1с и 1с у 0с.

Да бисте илустровали његову употребу, размотрите следећи исечак кода:

#инцлуде <иостреам>
Користећи именског простора стд ;

инт главни ( ) {
инт оригиналВалуе = 5 ;

инт ресултБитвисеНот = ~оригиналВалуе ;

цоут << 'Оригинална вредност: ' << оригиналВалуе << ', после битова НЕ: ' << ресултБитвисеНот << ендл ;

повратак 0 ;
}

У овом примеру, декларишемо целобројну променљиву „оригиналВалуе“ са вредношћу „5“. Затим користимо битни НОТ оператор (~) на овој променљивој. Резултат ове променљиве се чува у „ресултБитвисеНот“. Програм затим штампа оригиналну вредност и резултат након операције НОТ у битовима користећи наредбу „цоут“.

Када покренемо овај програм, видећемо да битовски НОТ оператор инвертује сваки бит бинарне репрезентације „оригиналВалуе“, што резултира новом вредношћу.

Пример 5: Адресни и индиректни оператори

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

Хајде да схватимо концепт на примеру:

#инцлуде <иостреам>
Користећи именског простора стд ;

инт главни ( ) {
инт вредност = 99 ;

цоут << 'Оригинална вредност: ' << вредност << ендл ;

инт * птр = & вредност ;
цоут << „Адреса меморије:“ << птр << ендл ;

инт ретриеведВалуе = * птр ;
цоут << 'Преузета вредност: ' << ретриеведВалуе << ендл ;

повратак 0 ;
}

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

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

Закључак

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