c operators types
En fullständig studie av operatörer i C ++ med exempel:
I denna Intensiv C ++ träningsserie, vi lärde oss om de olika begreppen i C ++ som variabler, lagringsklasser, typkvalificeringar osv i våra tidigare handledning. Vi lärde oss också hur vi kan ändra dessa variabler.
För att göra dessa modifieringar måste vi utföra operationer på dessa variabler och konstanter och för att utföra dessa operationer använder vi operatörer.
Operatörer är symboler som verkar på variabler eller andra enheter som kallas operander och utför matematiska eller logiska operationer för att ändra deras värden och producera resultat därefter.
Vad du kommer att lära dig:
Operatörer i C ++
Operatörer utgör grunden för alla programmeringsspråk. Utan operatörer kan vi inte modifiera eller manipulera enheterna för programmeringsspråk och kan därmed inte ge de önskade resultaten. C ++ är mycket rik på inbyggda operatörer som vi kommer att diskutera i detalj i denna handledning.
I C ++ är de flesta operatörer binära operatörer, dvs. dessa operatörer kräver två operander för att utföra en operation. Få operatörer som ++ (inkrement) -operatören är den enhetliga operatören, vilket innebär att de bara fungerar på en operand.
Det finns också en ternär operatör i C ++ som kallas villkorlig operatör som tar tre operander. Vi kommer att lära oss mer om detta i den senare delen av handledningen.
Typer av operatörer i C ++
Operatörer i C ++ klassificeras enligt nedan:
Låt oss utforska varje typ av C ++ - operatör i detalj !!
Aritmetiska operatörer
Aritmetiska operatorer används för att utföra grundläggande matematiska operationer på operander.
C ++ stöder följande aritmetiska operationer:
| Operatör | Binär / unary | Beskrivning |
|---|---|---|
| - | Unary | Minskningsoperatör - minskar operandens värde med 1 |
| + | Binär | Tillägg av två operander |
| - | Binär | Subtraktion av två operander |
| * | Binär | Multiplikation av två operander |
| / | Binär | Uppdelning av två operander |
| % | Binär | Modulusoperatör - resultatet är resten av uppdelningen |
| ++ | Unary | Inkrementoperatör - ökar värdet på operand med 1 |
Nedanstående exempel visar de första fem aritmetiska operatorerna i C ++
#include #include using namespace std; int main() { int op1=3,op2=4; float op3=10.1,op4=5.4; cout<<'Operands are op1 = '< Vi kan förstå detta bättre med följande exempel. #include #include using namespace std; int main() { int x=4,y; y = ++x; cout<<'PreIncrement:Value of x = '<Logiska operatörer Logiska operatorer används för att utvärdera en kombination av villkor / begränsningar för att få ett resulterande värde. Resultatet av utvärderingen av ett booleskt uttryck är booleskt vilket antingen är sant eller falskt.
C ++ stöder följande logiska operatörer:
Operatör Beskrivning 7 L-> R <<
>> Bitvis förskjutning åt vänster
Bitvis förskjutning åt höger && Logisk AND: returnerar true om båda villkoren är sanna annars returnerar false. || Logisk ELLER: returnerar sant om något av villkoren är sant. Returnerar falskt när båda villkoren är falska. ! Logiskt INTE: upphäver villkoret.
C ++ använder en kortslutningsmetod för att utvärdera logiska uttryck. I detta måste C ++ endast utvärdera det första uttrycket / operanden av det logiska uttrycket för att ge resultatet. Till exempel, för logisk AND (&&) operatör utvärderar C ++ endast det första uttrycket. Om det är falskt blir resultatet falskt även om det andra villkoret är sant.
På samma sätt utvärderar den endast det första uttrycket för logisk ELLER (||). Om det första uttrycket är sant, blir resultatet sant så det behöver inte utvärdera det andra uttrycket.
Nedan följer ett exempel som visar användningen av logiska operatörer.
#include #include using namespace std; int main() int a=10, b=8,c=12,d=14; if(!(a==0)) cout<<'a is not zero'< Produktion:
a är inte noll
Logiskt OCH är sant
Logiskt ELLER är sant
I ovanstående program har vi använt alla de tre logiska operatörerna för att utvärdera uttryck och skriva ut resultaten.
Relationsoperatörer
Relations- eller jämförelsesoperatorer används för att jämföra två operander. Resultatet av utvärderingen är antingen sant eller falskt.
C ++ stöder följande relationsoperatörer:
Operatör Beskrivning !FEL! oväntad operatör '=' Utvärderar om två operander är lika. Returnerar sant om lika annat returnerar falskt. ! = (inte lika med) Kompletterar 'lika med' operatören. Returnerar sant om operander inte är lika. Falskt annars. <(less than) Returnerar sant om den första operanden är mindre än andra. Falskt annars. <=(less than equal to) Returnerar sant om den första operanden är mindre än eller lika med den andra operanden. Falskt annars. > (större än) Returnerar sant om den första operanden är större än andra. Falskt annars. > = (större än lika med) Returnerar sant om den första operanden är större än lika med den andra. Falskt annars.
Se nedanstående exempelprogram för att förstå relationsoperatörerna.
#include #include using namespace std; int main() { int a=10, b=8,c=12,d=14; if(a==b) cout<<'a is equal to b'< Produktion:
a är inte lika med b
c är inte lika med d
(a + b) mindre än / lika med (c + d)
(a-b) större än / lika med (d-c)
I ovanstående program ser vi användningen av relationsoperatörer och hur de utvärderar uttrycken.
Observera att vi inte bara kan tillhandahålla värden utan även variabler och uttryck i villkorliga uttalanden.
Bitvisa operatörer
Bitvisa operatorer i C ++ arbetar på bitar av de tillhandahållna operanderna. Bitvis operatörer tillämpas endast på integraltyper som heltal, tecken etc. och inte på datatyper som flyt, dubbel, etc.
Följande är de bitvisa operatörerna som stöds av C ++:
Operatörer Beskrivning & (Binär OCH) Utför OCH-operation på bitar av operand 1 och operand 2. | (Binär ELLER) Utför ELLER-operation på bitar av operand 1 och operand 2. ^ (Binär XOR) Utför XOR-operation på bitar av operand 1 och operand 2. ~ (Binärt komplement) Tar en operand och inverterar dess bitar. <<( Binary left shift operator) Skiftar bitar av den första operanden till vänster till ett antal bitar som anges av den andra operanden. >> (Binär höger skiftoperatör) Skiftar bitar av den första operanden till höger till ett antal platser som anges av den andra operanden.
Dessa bitvisa operatörer arbetar på operander på bit-för-bit-sätt. Sanningstabellerna för AND-, OR- och XOR-operationer ges nedan.
Betrakta a och b som två bitar på vilka AND-, OR- och XOR-operationer ska utföras.
Sanningstabellerna för samma är som anges nedan:
till b a & b a | b a ^ b 0 0 0 0 0 1 0 0 1 1 0 1 0 1 1 1 1 1 1 0
Låt oss ta ett exempel för att förstå bitvisa operationer.
Låt a = 8 och b = 4
Den binära representationen av a och b är som följer:
a = 8 1000
a = 4 0100
a & b 0000 = 0
a | b 1100 = 12
a ^ b 1100 = 12
I exemplet ovan ser vi att bitvis OCH av 8 och 4 är 0. Bitvis ELLER av 8 och 4 är 12 och bitvis XOR av 8 och 4 är också 12.
Detta är det sätt på vilket bitvisa operationer utförs av de bitvisa operatörerna.
Ett exempel som visar bitvisa operatörer.
#include #include using namespace std; int main() int a=8,b=4,c; c = a&b; cout<<'Result of & : '< Produktion:
Resultat av &: 0
Resultat av | : 12
Resultat av ^: 12
Resultat av<< by 2 bits: 32
Resultat av >> med 2 bitar: 1
Resultat av ~: -4
I ovanstående program demonstrerade vi användningen av bitvisa operatörer och skrev också ut resultatet för var och en av operationerna.
Uppdragsoperatörer
Tilldelningsoperatören “=” används för att tilldela ett värde till en variabel. Tilldelningsoperatörens LHS är en variabel och RHS är det värde som ska tilldelas variabeln. Värdet på höger sida måste vara av samma typ som variabeln på vänster sida.
Notera skillnaden mellan '=' och '==' operatörer. Den förra är uppdragsoperatören och den senare är likhetsoperatören.
Uppdragsoperationen sker från höger till vänster. Förutom tilldelningsoperatören '=' finns det andra variationer av tilldelningsoperatören som kallas 'sammansatta tilldelningsoperatörer'. Dessa operatörer utför en operation utöver uppdraget.
Tabellen nedan ger oss en beskrivning av dessa uppdragsoperatörer.
Operatör Beskrivning = Tilldelar värdet på RHS-operand till LHS-operand + = Lägger till RHS-operand till LHS-operand och tilldelar resultatet i LHS-operand. - = Subtraherar RHS-operand till LHS-operand och tilldelar resultatet till LHS-operand * = multiplicerar RHS-operand till LHS-operand och tilldelar resultatet till LHS-operand / = delar RHS-operand till LHS-operand och tilldelar resultatet till LHS-operand
Som visas i ovanstående tabell, om x och y är operander, motsvarar x + = y x = x + y.
Liknande,
x - = y motsvarar x = x-y.
x * = y motsvarar x = x * y.
x / = y motsvarar x = x / y.
Nedanstående programmeringsexempel visar dessa uppdragsoperatörer.
#include #include using namespace std; int main() { int x,y; cout<>y; x = y; cout<<'
Value of x = '< Produktion:
Ange inmatningsvariabel y: 4
Värde på x = 4
a + = b: 8
c - = b: 3
a * = b: 40
b / = c: 1
I exemplet ovan har vi demonstrerat tilldelning såväl som sammansatta tilldelningsoperatörer.
Notera: Vi kan också kombinera andra binära operatörer som%,<>, &, |, ^, etc. i sammansatta tilldelningsuttalanden utöver de som redan visas.
Andra operatörer
Hittills har vi utforskat alla större operatörer i C ++. Det finns ytterligare några C ++ - operatörer som behöver vår uppmärksamhet.
Dessa operatörer inkluderar:
hur man skriver automatiserade testfall
(i) operatörens storlek
sizeof är en unary operatör som används i stor utsträckning i C och C ++. Sizeof returnerar storleken på sin operand. Returvärdet är vanligtvis en osignerad integraltyp betecknad med 'size_t'.
Sizeof-operatören har många användningsområden i C- och C ++ - språk. Den kan användas för att ta reda på storleken på variabler, matriser eller uttryck och till och med för att fördela minnesblocken.
(ii) Villkorlig ternär operatör
Den villkorliga operatören i C ++ kan användas som en ersättning för if-else-uttalande.
Den allmänna syntaxen för den villkorliga operatören är:
Tillstånd? expression1: expression2;
Om villkoret är sant utvärderas uttryck 1. Om villkoret är falskt utvärderas expression2.
Observera att expression1 och expression2 måste ha samma datatyper för att undvika potentiella fel.
Föreslagen läsning => Ternär operatör i C #
(iii) Kommaoperatör
Kommaoperatör som representeras som en token ',' kan användas som en operator såväl som en separator.
Som operatör används ett komma när det finns mer än ett uttryck som ska utvärderas. Endast det längsta uttrycket tilldelas LHS.
Till exempel,överväga följande uttryck.
x = (y = 4, y + 1);
I detta uttryck har vi två uttryck på höger sida åtskilda med ett komma. Här fungerar komma som operatör. Först utvärderas uttrycket y = 4. Därefter utvärderas nästa uttryck y + 1 genom att använda resultatet av det första uttrycket, dvs. y = 4. Således blir värdet på y + 1 5 och detta värde tilldelas x.
Som separator kan ett komma användas var som helst för att separera definitioner, parameterlista etc.
(iv) Operatör för medlemsåtkomst
Det finns två operatörer som används för att komma åt de enskilda medlemmarna i klasser, strukturer eller fackföreningar i C ++. Dessa är punktoperatören (.) Och pilen (->). Vi kommer att lära oss dessa operatörer i detalj när vi lär oss objektorienterad programmering i C ++.
Nedanstående exempel visar användningen av storlek på, kommatecken och villkorlig operatör.
#include #include using namespace std; int main() { int x,y; x = (y=3,y+4); cout<<'Value of x = '< Produktion:
Värde på x = 7
Variabel x är större än 5
sizeof (x): 4 sizeof (y): 4
Skärmdumpen för detsamma ges nedan.
Som visas i ovanstående program har vi först två variabler deklarerade och separerade med ett komma. (komma som separator). Därefter har vi en kommaoperatör med två uttryck. Som vi kan se från utdata tilldelas uttrycket längst till höger variabeln x. Därefter visar vi den villkorliga operatören för att utvärdera om x är mindre än 5.
Slutligen visar vi användningen av operatörens storlek. Här använder vi sizeof-operatören för att få storleken på variablerna x och y. Eftersom båda är heltalvariabler är storleken som returneras 4 byte.
(v) Operator Precedence and Associativity
Vi har redan sett nästan alla C ++ -operatörer och vi vet att de kan användas i uttryck för att utföra specifika operationer. Men de uttryck vi har sett i exempel är enkla och enkla. Beroende på våra krav tenderar uttryck dock att bli mer och mer komplexa.
Sådana komplexa uttryck kommer att ha mer än en operatör och många operander. I en sådan situation måste vi utvärdera vilken operatör som ska utvärderas först.
Till exempel, överväga följande uttryck.
x = 4 + 5/3;
Här har vi + och / operatorer och vi måste bestämma vilket uttryck som ska utvärderas först. I matematiska termer vet vi att delning kommer att genomföras före tillägg. Således blir uttrycket x = 4 + (5/3) = 5.
Men när kompilatorn står inför en sådan situation måste vi också ha en liknande mekanism för att bestämma ordningsföljden, så att den korrekt kan utvärdera uttrycket.
Denna ordning i vilken operatörerna i ett sammansatt uttryck utvärderas kallas operatörens 'företräde'. C ++ har definierat företräde för alla operatörer och operatörerna med högre prioritet utvärderas först.
Vad händer när vi har två operatörer sida vid sida i ett uttryck med samma företräde? Det är där en operatörs associativitet kommer in i bilden.
Associativitet berättar för kompilatorn huruvida ett uttryck ska utvärderas i vänster till höger eller höger till vänster sekvens. På så sätt kan vi med hjälp av en operatörs företräde och associativitet effektivt utvärdera ett uttryck och få önskat resultat.
C ++ tillhandahåller en tabell som består av företräde och associativitet hos olika operatörer den använder.
Denna tabell ges nedan.
Prioritet / associativitet Operatör Beskrivning 1 Ingen ::
:: Omfattningsupplösningsoperatör
(unary)
(binär) 2 L-> R ()
()
()
{}
typ()
typ{}
()
.
->
++
––
typid
const_cast
dynamic_cast
reinterpret_cast
static_cast Parentes
Funktionssamtal
Initiering
Uniform initialisering (C ++ 11)
Funktionell rollbesättning
Funktionell rollbesättning (C ++ 11)
Array prenumeration
Medlemsåtkomst från objektet
Medlemsåtkomst från objekt ptr
Efter inkrement
Efter minskning
Information om körningstyp
Kasta bort konst
Runtid typkontrollerad roll
Casta en typ till en annanCompile-time typ-checkad cast 3 R-> L. +
-
++
––
!
~
(typ)
storlek av
&
*
ny
ny()
radera
radera() Unary mer
Unary minus
Förökning
Pre-decrement
Logiskt INTE
Bitvis INTE
C-stilbesättning
Storlek i byte
Adress till
Störning
Dynamisk minnestilldelning
Dynamisk arrayallokering
Radering av dynamiskt minne
Radering av dynamisk matris 4 L-> R -> *
. * Pekare för medlem
Välj objekt för medlem 5 L-> R *
/
% Multiplikation
Division
Modulus 6 L-> R +
- Tillägg
Subtraktion 8 L-> R <
<=
>
> = Jämförelse mindre än
Jämförelse mindre än eller lika
Jämförelse större än
Jämförelse större än eller lika med 9 L-> R !FEL! olaglig karaktär '!' Jämlikhet
Olikhet 10 L-> R & Bitvis OCH 11 L-> R ^ Bitvis XOR 12 L-> R | Bitvis ELLER 13 L-> R && Logiskt OCH 14 L-> R || Logiskt ELLER 15 R-> L. ?:
=
* =
/ =
% =
+ =
- =
<<=
>> =
& =
| =
^ = Villkorligt (se anmärkning nedan)
Uppdrag
Multiplikationstilldelning
Divisionsuppdrag
Moduluppdrag
Tilläggsuppgift
Subtraktionstilldelning
Bitvis skift vänster uppgift
Bitvis förskjutning till höger
Bitvis OCH uppdrag
Bitvis ELLER tilldelning
Bitvis XOR-tilldelning 16 R-> L. kasta Kasta uttryck 17 L-> R , Kommaoperatör
Anmärkningar:
- Prioritetsnivå 1 är den högsta prioritetsnivån och nivå 17 är den lägsta. Operatörer med högre prioritetsnivå utvärderas först.
- L-> R betyder vänster till höger associativitet.
- R-> L betyder höger till vänster associativitet.
Slutsats
Det här handlar om operatörerna i C ++.
Vi har diskuterat nästan alla operatörer. Några specifika operatorer som finns i ovanstående prioritetstabell som vi inte har diskuterat kommer att diskuteras enligt de ämnen som vi täcker i våra kommande handledning.
=> Se här för att utforska listan med fullständiga C ++ -studier
Rekommenderad läsning
- Unix Shell Script Aritmetic och Boolean Operators Exempel
- Python-operatörer
- Nytt / Radera operatörer i C ++ med exempel
- Python-datatyper
- Unix villkorliga uttalanden: om sedan andra och relationsoperatörer
- Python DateTime-handledning med exempel
- HTML-injektionshandledning: Typer och förebyggande med exempel
- Klipp kommandot i Unix med exempel
