В C++, когато работим с операторите, има последователност, в която се изпълняват всички операции. Приоритетът на оператора се използва при работа с множество оператори в израза на нашия код. Например, докато работите с оператори за събиране, изваждане, умножение и деление, операциите за умножение и деление се изпълняват първо отляво надясно, тъй като имат висок приоритет, а операциите за събиране и изваждане се извършват следващи отляво надясно, както имат нисък приоритет от умножението и делението. Но ако изразът съдържа само операторите за събиране и изваждане, операцията просто се изпълнява отляво надясно. Тук ще покажем таблицата на приоритета на оператора и примерите за приоритет на оператора.
Предимство на оператора на аритметичните операции
| Операция | Оператори | Предимство |
|---|---|---|
| скоби | () | Тези скоби се оперират. |
| умножение, деление, модул | *, /, % | Тези операции се извършват и редът им е отляво надясно. |
| събиране, изваждане | +, – | Тези операции се извършват накрая и последователността им е отляво надясно. |
Пример 1:
Нека започнем нашия код, като включим заглавния файл с име „iostrem“. Много функции са декларирани в този заглавен файл „iostream“, който ще използваме в нашия код. Под него въвеждаме „namespace std“ и извикваме „main()“ напред. Тук в “main()” декларираме променливите с имена “i”, “j” и “k” с “int” и стойностите, които предаваме тук са “10”, “37” и “29”, съответно. Ние също така декларираме променливата „r“, където се запазва резултатът.
След това въвеждаме израз с помощта на операторите „+, „/“ и „-“. Както вече обяснихме, тези операции се извършват в последователност. Изразът, който поставихме тук, е „i + j / k – j“, в който първо се извършва делението, а след това се извършват операциите събиране и изваждане. Той показва резултата в цели числа, тъй като декларираме променливата „r“ като цяло число. По-долу показваме изчисления резултат с помощта на „cout“.
Код 1:
#includeизползвайки пространство от имена std ;
вътр основен ( )
{
вътр i = 10 , дж = 37 , к = 29 , r ;
r = i + й / к - й ;
cout << 'Резултатът от дадения израз е = ' << r ;
връщане 0 ;
}
Изход:
Изходът е “-26” след извършване на всички операции. Този резултат се изчислява според приоритета на оператора, предоставен от езика C++.
Пример 2:
В този код, след като включим заглавния файл и извикаме „main()“, ние инициализираме променлива „int“ с име „val1“ и поставяме израза, в който въвеждаме „9 + 18 * 7“. Тук той първо извършва умножението и след това добавя „9“ към умножената стойност. По-долу инициализираме „int val2“ с „9 + (18 * 7)“.
Тук първо се решават скобите. След това се извършва добавянето. След това инициализираме „int val3“ с израза „(9 + 18) * 7“. В този израз първо се оперират със скобите и след това се извършва умножението. Стойностите на израза са еднакви, но предоставят уникални резултати поради приоритета на оператора. Сега продължаваме напред и отпечатваме всички резултати, които се съхраняват в променливите „val1“, „val2“ и „val3“ с помощта на „cout“.
Код 2:
#includeизползвайки пространство от имена std ;
вътр основен ( ) {
вътр избор1 = 9 + 18 * 7 ;
вътр val2 = 9 + ( 18 * 7 ) ;
вътр val3 = ( 9 + 18 ) * 7 ;
cout << 'Първият резултат показва = ' << избор1 << endl ;
cout << 'Вторият резултат показва = ' << val2 << endl ;
cout << 'Третият резултат показва = ' << val3 << endl ;
връщане 0 ;
}
Изход:
Резултатът, който получаваме след изчисляването на дадения израз е следният. Можем да видим, че третият резултат не е същият като другите два, въпреки че стойностите са еднакви. Това се дължи на приоритета на оператора, който се прилага към оператора на израза.
Пример 3:
Тук инициализираме различни променливи с различни стойности и типът данни на всички тези променливи е „int“. Имаме целочислените променливи „a“, „b“, „c“ и „d“ със стойности съответно „14“, „9“, „15“ и „29“. След това инициализираме „int R1“ и изразът, който поставяме тук, е „a + b) * c / d“. Първо се решават скобите. След това се извършват операциите умножение и деление. Ние също показваме резултата под това. След това имаме „int R2“ с израза „a – b * (d + a) + c“. Тук също решава скобите и след това изваждането и събирането се извършват според приоритета на оператора. Ние също така отпечатваме неговия резултат и инициализираме „int R3“, където е въведен изразът „b – d + c * a“. В този израз първо се извършва умножението, след това изваждането и събирането. Резултатът от този израз също е показан по-долу. Сега имаме последния израз, “d + (a * b) / a”, чийто резултат се съхранява в променливата “R4”. В този израз първо се решават скобите и след това се разделят. В края се извършва добавяне. Резултатът от този израз е показан по следния начин:
Код 3:
#includeизползвайки пространство от имена std ;
вътр основен ( ) {
вътр а = 14 ;
вътр b = 9 ;
вътр ° С = петнадесет ;
вътр д = 29 ;
вътр R1 = ( а + b ) * ° С / д ;
cout << '(a + b) * c / d' << 'дава =' << R1 << endl ;
вътр R2 = а - b * ( д + а ) + ° С ;
cout << 'a - b (d + a) + c' << 'дава =' << R2 << endl ;
вътр R3 = b - д + ° С * а ;
cout << 'b - d + c * a' << 'дава =' << R3 << endl ;
вътр R4 = д + ( а * b ) / а ;
cout << 'd + (a * b) / a' << 'дава =' << R4 << endl ;
връщане 0 ;
}
Изход:
Следното е резултатът от изчисляването на споменатите по-горе изрази. Получаваме този резултат, защото операторите в израза имат операторен приоритет, приложен към тях:
Пример 4:
Инициализираме променливите „a1“, „b1“, „c1“, „d1“, „e1“ и „f1“ тук с целите стойности на „64“, „90“, „11“, „27“, „34“ и „98“, съответно. Инициализираме „int result1“ тук с израза „a1 + b1 – c1) * d1 / f1“ и резултатът се съхранява в променливата „result1“. Тук първо се решават скобите. След това останалите операции се изчисляват последователно. След това отпечатваме „result1“. По същия начин изчисляваме изразите и ги съхраняваме в различни променливи. След това отпечатваме всички резултати отделно, показвайки как работи приоритетът на оператора.
Код 4:
#includeизползвайки пространство от имена std ;
вътр основен ( ) {
вътр a1 = 64 ;
вътр b1 = 90 ;
вътр c1 = единадесет ;
вътр d1 = 27 ;
вътр e1 = 3. 4 ;
вътр f1 = 98 ;
вътр резултат1 = ( a1 + b1 - c1 ) * d1 / f1 ;
cout << 'Резултатът 1 е' << резултат1 << endl ;
вътр резултат2 = a1 + ( f1 * b1 ) / e1 ;
cout << 'Резултатът 2 е' << резултат2 << endl ;
вътр резултат3 = e1 + d1 + a1 - c1 * b1 / a1 ;
cout << 'Резултатът 3 е' << резултат3 << endl ;
вътр резултат4 = a1 - f1 + ( b1 - d1 ) * c1 ;
cout << 'Резултатът 4 е' << резултат4 << endl ;
вътр резултат5 = ( f1 + ( a1 * ( b1 + a1 ) - f1 ) * a1 + e1 ) ;
cout << 'Резултатът 5 е' << резултат5 << endl ;
връщане 0 ;
}
Изход:
Резултатът от дадения код се изобразява тук, което показва резултата от всички изрази, които сме въвели преди това. Всички изрази се изчисляват, като се следва правилото за приоритет на реда.
Заключение
Разгледахме „предимството на C++“ тук, в което проучихме задълбочено реда на операторите, в които те се изчисляват в програмирането на C++. Показахме и реда на операторите под формата на таблица и след това изпълнихме множество примери, в които научихме как изразите се решават според приоритета на реда в програмирането на C++.