c operators types
En komplet undersøgelse af operatører i C ++ med eksempler:
I denne Intensiv C ++ træningsserie, vi lærte om de forskellige koncepter i C ++ som variabler, lagerklasser, typekvalifikatorer osv. i vores tidligere tutorials. Vi lærte også, hvordan vi kan ændre disse variabler.
For at udføre disse ændringer er vi nødt til at udføre operationer på disse variabler og konstanter, og for at udføre disse operationer bruger vi operatorer.
Operatører er symboler, der virker på variabler eller andre enheder, der kaldes operander og udfører matematiske eller logiske operationer for at ændre deres værdier og producere resultater i overensstemmelse hermed.
Hvad du lærer:
Operatører i C ++
Operatører danner det grundlæggende fundament for ethvert programmeringssprog. Uden operatører kan vi ikke ændre eller manipulere enhederne i programmeringssprog og kan derfor ikke producere de ønskede resultater. C ++ er meget rig på indbyggede operatører, som vi vil diskutere detaljeret i denne vejledning.
I C ++ er de fleste operatører binære operatører, dvs. disse operatører kræver to operander for at udføre en operation. Få operatører som ++ (inkrement) operatør er den unære operatør, hvilket betyder, at de kun opererer på en operand.
Der er også en ternær operatør i C ++ kaldet Conditional Operator, der tager tre operander. Vi vil lære mere om dette i den senere del af vejledningen.
Typer af operatører i C ++
Operatører i C ++ er klassificeret som vist nedenfor:
Lad os udforske hver type C ++ -operatør i detaljer !!
Aritmetiske operatører
Aritmetiske operatorer bruges til at udføre grundlæggende matematiske operationer på operander.
C ++ understøtter følgende aritmetiske operationer:
| Operatør | Binær / unary | Beskrivelse |
|---|---|---|
| - | Unary | Reduceringsoperatør - nedsætter værdien af operand med 1 |
| + | Binær | Tilføjelse af to operander |
| - | Binær | Subtraktion af to operander |
| * | Binær | Multiplikation af to operander |
| / | Binær | Opdeling af to operander |
| % | Binær | Modulusoperator - resultatet er resten af divisionen |
| ++ | Unary | Increment operator - øger værdien af operand med 1 |
Nedenstående eksempel viser de første fem aritmetiske operatorer 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 forstå dette bedre ved hjælp af følgende eksempel. #include #include using namespace std; int main() { int x=4,y; y = ++x; cout<<'PreIncrement:Value of x = '<Logiske operatører Logiske operatorer bruges til at evaluere en kombination af betingelser / begrænsninger for at få en resulterende værdi. Resultatet af evalueringen af et boolsk udtryk er boolsk, som enten er sandt eller falsk.
C ++ understøtter følgende logiske operatorer:
Operatør Beskrivelse 7 L-> R <<
>> Bitvis skift til venstre
Bitvis skift til højre && Logisk OG: returnerer sandt, hvis begge betingelser er sande, ellers returnerer falske. || Logisk ELLER: returnerer sandt, hvis en af betingelserne er sand. Returnerer falsk, når begge betingelser er falske. ! Logisk IKKE: ophæver tilstanden.
C ++ anvender en kortslutningsmetode til at evaluere logiske udtryk. I dette skal C ++ kun evaluere det første udtryk / operand af det logiske udtryk for at give resultatet. For eksempel, for logisk AND (&&) operator, C ++ vurderer kun det første udtryk. Hvis det er falsk, bliver resultatet forkert, selvom den anden betingelse er sand.
Tilsvarende evaluerer det kun det første udtryk for logisk OR (||). Hvis det første udtryk er sandt, vil resultatet være sandt, så det behøver ikke at evaluere det andet udtryk.
Nedenfor er et eksempel, der viser brugen af logiske operatorer.
#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 er ikke nul
Logisk OG er sandt
Logisk ELLER er sandt
I ovenstående program har vi brugt alle de tre logiske operatorer til at evaluere udtryk og udskrive resultaterne.
Relationelle operatører
Relations- eller sammenligningsoperatorer bruges til at sammenligne to operander. Resultatet af evalueringen er enten sandt eller falsk.
C ++ understøtter følgende relationsoperatører:
Operatør Beskrivelse !FEJL! uventet operatør '=' Evaluerer, om to operander er ens. Returnerer sandt, hvis lige andet returnerer falsk. ! = (ikke lig med) Suppler 'lig med' operatør. Returnerer sandt, hvis operander ikke er ens. Falsk ellers. <(less than) Returnerer sandt, hvis den første operand er mindre end anden. Falsk ellers. <=(less than equal to) Returnerer sandt, hvis den første operand er mindre end eller lig den anden operand. Falsk ellers. > (større end) Returnerer sandt, hvis den første operand er større end anden. Falsk ellers. > = (større end lig med) Returnerer sandt, hvis den første operand er større end lig med den anden. Falsk ellers.
Se nedenstående eksempelprogram for at forstå de relationelle operatører.
#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 er ikke lig med b
c er ikke lig med d
(a + b) mindre end / lig med (c + d)
(a-b) større end / lig med (d-c)
I ovenstående program ser vi brugen af relationelle operatører og den måde, hvorpå de evaluerer de angivne udtryk.
Bemærk, at vi ikke kun kan levere værdier, men også variabler og udtryk i de betingede udsagn.
Bitvise operatører
Bitvise operatorer i C ++ fungerer på bits af de leverede operander. Bitvis operatorer anvendes kun til integraltyper som heltal, tegn osv. Og ikke på datatyper som flydende, dobbelt osv.
Følgende er de bitvise operatører understøttet af C ++:
Operatører Beskrivelse & (Binær AND) Udfører OG-handling på bits af operand 1 og operand 2. | (Binær ELLER) Udfører ELLER-operation på bits af operand 1 og operand 2. ^ (Binær XOR) Udfører XOR-operation på bits af operand 1 og operand 2. ~ (Binær komplement) Tager en operand og vender sine bits om. <<( Binary left shift operator) Skifter bits fra den første operand til venstre til et antal bits, der er specificeret af den anden operand. >> (Binær højre skiftoperatør) Flytter bits fra den første operand til højre til et antal steder, der er angivet af den anden operand.
Disse bitvise operatører opererer på operander på en bit-for-bit måde. Sandhedstabellerne for AND-, OR- og XOR-operationer er angivet nedenfor.
Overvej a og b som to bits, på hvilke AND-, OR- og XOR-operationer skal udføres.
Sandhedstabellerne for det samme er som angivet nedenfor:
til 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
Lad os tage et eksempel for at forstå bitvise operationer.
Lad a = 8 og b = 4
Den binære repræsentation af a og b er som følger:
a = 8 1000
a = 4 0100
a & b 0000 = 0
a | b 1100 = 12
a ^ b 1100 = 12
I eksemplet ovenfor ser vi, at den bitvise AND på 8 og 4 er 0. Bitvis ELLER på 8 og 4 er 12 og bitvis XOR på 8 og 4 er også 12.
Dette er den måde, hvorpå bitvise operationer udføres af de bitvise operatører.
Et eksempel, der demonstrerer bitvise operatører.
#include #include using namespace std; int main() int a=8,b=4,c; c = a&b; cout<<'Result of & : '< Produktion:
Resultat af &: 0
Resultat af | : 12
Resultat af ^: 12
Resultat af<< by 2 bits: 32
Resultat af >> med 2 bit: 1
Resultat af ~: -4
I ovenstående program demonstrerede vi brugen af bitvise operatorer og udskrev også output for hver af operationerne.
Opgaveoperatører
Tildelingsoperator “=” bruges til at tildele en værdi til en variabel. Tildelingsoperatørens LHS er en variabel, og RHS er den værdi, der skal tildeles variablen. Værdien på højre side skal være af samme type som variablen på venstre side.
Bemærk forskellen mellem '=' og '==' operatorer. Førstnævnte er opdragsoperatøren og den senere er ligestillingsoperator.
Tildeling sker fra højre til venstre. Bortset fra tildelingsoperatøren '=' er der andre variationer af tildelingsoperatører, der er kendt som 'sammensatte tildelingsoperatører'. Disse operatører udfører en operation ud over opgaven.
Nedenstående tabel giver os en beskrivelse af disse tildelingsoperatører.
Operatør Beskrivelse = Tildel værdien af RHS operand til LHS operand + = Tilføjer RHS-operand til LHS-operand og tildeler resultatet i LHS-operand. - = Trækker RHS-operand til LHS-operand og tildeler resultatet til LHS-operand * = multiplicerer RHS-operand med LHS-operand og tildeler resultatet til LHS-operand / = deler RHS-operand til LHS-operand og tildeler resultatet til LHS-operand
Som vist i ovenstående tabel, hvis x og y er operander, svarer x + = y til x = x + y.
Tilsvarende
x - = y svarer til x = x-y.
x * = y svarer til x = x * y.
x / = y svarer til x = x / y.
Nedenstående programmeringseksempel viser disse tildelingsoperatører.
#include #include using namespace std; int main() { int x,y; cout<>y; x = y; cout<<'
Value of x = '< Produktion:
Indtast inputvariabel y: 4
Værdien af x = 4
a + = b: 8
c - = b: 3
a * = b: 40
b / = c: 1
I eksemplet ovenfor har vi demonstreret tildeling såvel som sammensatte tildelingsoperatører.
Bemærk: Vi kan også kombinere de andre binære operatører som%,<>, &, |, ^ osv. i sammensatte tildelingserklæringer ud over dem, der allerede er demonstreret.
Andre operatører
Indtil videre har vi udforsket alle de store operatører i C ++. Der er nogle flere yderligere C ++ - operatører, der har brug for vores opmærksomhed.
Disse operatører inkluderer:
bedste pc tune up software 2019
(i) operatørens størrelse
sizeof er en unary operator, der bruges i vid udstrækning i C og C ++. Sizeof returnerer størrelsen på sin operand. Returneringsværdien er normalt en usigneret integraltype betegnet med 'size_t'.
Sizeof-operatøren har mange anvendelser i C- og C ++ -sprog. Det kan bruges til at finde ud af størrelsen på variabler, arrays eller udtryk og endda til at allokere hukommelsesblokkene.
(ii) Betinget ternær operatør
Den betingede operatør i C ++ kan bruges som erstatning for if-else-erklæring.
Den generelle syntaks for den betingede operatør er:
Tilstand? udtryk1: udtryk2;
Hvis betingelsen er sand, vil udtryk 1 blive evalueret. Hvis betingelsen er falsk, evalueres expression2.
Bemærk, at expression1 og expression2 skal have de samme datatyper for at undgå potentielle fejl.
Foreslået læsning => Ternær operatør i C #
(iii) Kommaoperatør
Komma-operator, der er repræsenteret som et token ',' kan bruges som en operator såvel som en separator.
Som operator bruges et komma, når der er mere end et udtryk, der skal evalueres. Kun det yderste udtryk er tildelt LHS.
For eksempel,overvej følgende udtryk.
x = (y = 4, y + 1);
I dette udtryk har vi to udtryk på højre side adskilt med et komma. Her fungerer komma som operatør. Først evalueres udtrykket y = 4. Derefter evalueres det næste udtryk y + 1 ved hjælp af resultatet af det første udtryk, dvs. y = 4. Værdien af y + 1 vil således være 5, og denne værdi tildeles x.
Som en separator kan et komma bruges hvor som helst til at adskille definitioner, parameterlister osv.
(iv) Medlemsadgangsoperatør
Der er to operatorer, der bruges til at få adgang til de enkelte medlemmer af klasser, strukturer eller fagforeninger i C ++. Disse er punktoperatoren (.) Og pilen (->). Vi lærer disse operatører i detaljer, når vi lærer objektorienteret programmering i C ++.
Nedenstående eksempel viser brugen af størrelse af, komma og betinget operatør.
#include #include using namespace std; int main() { int x,y; x = (y=3,y+4); cout<<'Value of x = '< Produktion:
Værdien af x = 7
Variabel x er større end 5
størrelse af (x): 4 størrelse af (y): 4
Skærmbilledet for det samme er angivet nedenfor.
Som vist i ovenstående program har vi først to variabler erklæret og adskilt med et komma. (komma som separator). Dernæst har vi en kommaoperator med to udtryk. Som vi kan se fra output, tildeles det yderste udtryks værdi til variablen x. Dernæst demonstrerer vi den betingede operatør for at evaluere, om x er mindre end 5.
Endelig demonstrerer vi brugen af operatørens størrelse. Her bruger vi operatorens størrelse til at få størrelsen på variablerne x og y. Da begge er heltalsvariabler, er den returnerede størrelse 4 byte.
(v) Operatørens prioritet og tilknytning
Vi har allerede set næsten alle C ++ operatører, og vi ved, at de kan bruges i udtryk til at udføre specifikke operationer. Men de udtryk, vi har set i eksempler, er enkle og ligetil. Afhængigt af vores krav har udtryk imidlertid tendens til at blive mere og mere komplekse.
Sådanne komplekse udtryk vil have mere end en operator og mange operander. I en sådan situation skal vi først evaluere, hvilken operatør der skal evalueres.
For eksempel, overvej følgende udtryk.
x = 4 + 5/3;
Her har vi + og / operatorer, og vi skal beslutte, hvilket udtryk der først skal evalueres. I matematiske termer ved vi, at opdeling vil blive udført før tilføjelse. Således bliver udtrykket x = 4 + (5/3) = 5.
Men når compileren står over for en sådan situation, skal vi også have en lignende mekanisme til at bestemme rækkefølgen af operationer, så den korrekt kan evaluere udtrykket.
Denne rækkefølge, hvor operatorerne i et sammensat udtryk evalueres, kaldes operatørens 'forrang'. C ++ har defineret forrang for alle operatører, og operatører med højere prioritet evalueres først.
Hvad sker der, når vi har to operatorer side om side i et udtryk med samme forrang? Det er her, en operatørs associativitet kommer ind i billedet.
Associativitet fortæller kompilatoren, om han skal evaluere et udtryk i venstre til højre sekvens eller højre til venstre sekvens. Således kan vi ved hjælp af en operatørs forrang og associativitet effektivt evaluere et udtryk og få det ønskede resultat.
C ++ tilvejebringer en tabel bestående af forrang og associativitet for forskellige operatører, den bruger.
Denne tabel er angivet nedenfor.
Forrang / associativitet Operatør Beskrivelse 1 Ingen ::
:: Omfangsopløsningsoperatør
(unary)
(binær) 2 L-> R ()
()
()
{}
type()
type{}
()
.
->
++
––
typeid
const_cast
dynamisk_cast
genfortolke_cast
static_cast Parenteser
Funktionsopkald
Initialisering
Ensartet initialisering (C ++ 11)
Funktionel rollebesætning
Funktionel rollebesætning (C ++ 11)
Array abonnement
Medlem adgang fra objektet
Medlemsadgang fra objekt ptr
Efter inkrement
Efter dekrement
Oplysninger om driftstidstype
Kast væk konst
Kørselstypetjekket rollebesætning
Cast en type til en andenCompile-time typekontrolleret rollebesætning 3 R-> L. +
-
++
––
!
~
(type)
størrelse på
&
*
ny
ny()
slet
slet () Unary mere
Unary minus
Forhøjelse
Pre-dekrement
Logisk IKKE
Bitvis IKKE
C-stil rollebesætning
Størrelse i byte
Adresse på
Dereference
Dynamisk hukommelsesallokering
Dynamisk matrixallokering
Sletning af dynamisk hukommelse
Sletning af dynamisk matrix 4 L-> R -> *
. * Markør for medlemsmarkør
Medlem objektvælger 5 L-> R *
/
% Multiplikation
Division
Modulus 6 L-> R +
- Tilføjelse
Subtraktion 8 L-> R <
<=
>
> = Sammenligning mindre end
Sammenligning mindre end eller lig
Sammenligning større end
Sammenligning større end eller lig 9 L-> R !FEJL! ulovlig karakter '!' Lighed
Ulighed 10 L-> R & Bitvis OG 11 L-> R ^ Bitvis XOR 12 L-> R | Bitvis ELLER 13 L-> R && Logisk OG 14 L-> R || Logisk ELLER 15 R-> L. ?:
=
* =
/ =
% =
+ =
- =
<<=
>> =
& =
| =
^ = Betinget (se note nedenfor)
Opgave
Multiplikationstildeling
Division opgave
Modulusopgave
Tilføjelsesopgave
Subtraktionstildeling
Bitvis skift til venstre opgave
Bitvis skift til højre
Bitvis OG opgave
Bitvis ELLER opgave
Bitvis XOR-tildeling 16 R-> L. kaste Kast udtryk 17 L-> R , Kommaoperatør
Bemærkninger:
- Prioritetsniveau 1 er det højeste prioritetsniveau, og niveau 17 er det laveste. Operatører med et højere prioritetsniveau evalueres først.
- L-> R betyder venstre mod højre associativitet.
- R-> L betyder højre mod venstre associativitet.
Konklusion
Dette handler om operatørerne i C ++.
Vi har diskuteret næsten alle operatører. Nogle specifikke operatorer, der findes i ovenstående forrangstabel, som vi ikke har diskuteret, vil blive diskuteret i henhold til de emner, vi dækker i vores kommende tutorials.
=> Se her for at udforske den komplette C ++ tutorials-liste
Anbefalet læsning
- Unix Shell Script Aritmetiske og Boolske operatøreksempler
- Python-operatører
- Nyt / Slet operatører i C ++ med eksempler
- Python-datatyper
- Unix betingede erklæringer: hvis så andre og relationelle operatører
- Python DateTime-tutorial med eksempler
- HTML-injektionsvejledning: Typer og forebyggelse med eksempler
- Klip kommando i Unix med eksempler
