c operators types
Un estudi complet dels operadors en C ++ amb exemples:
En aquest Sèrie d'entrenament intensiu en C ++, hem après sobre els diversos conceptes de C ++ com ara variables, classes d'emmagatzematge, qualificadors de tipus, etc. als nostres tutorials anteriors. També vam conèixer com podem modificar aquestes variables.
Per fer aquestes modificacions, hem de realitzar operacions sobre aquestes variables i constants i per fer aquestes operacions fem ús dels operadors.
Els operadors són símbols que actuen sobre variables o altres entitats que es diuen operands i realitzen operacions matemàtiques o lògiques per modificar els seus valors i produir resultats en conseqüència.
Què aprendreu:
què és una clau de seguretat de xarxa
Operadors en C ++
Els operadors constitueixen la base bàsica de qualsevol llenguatge de programació. Sense operadors, no podem modificar ni manipular les entitats dels llenguatges de programació i, per tant, no podem produir els resultats desitjats. C ++ és molt ric en operadors integrats que parlarem detalladament en aquest tutorial.
En C ++, la majoria dels operadors són operadors binaris, és a dir, aquests operadors requereixen dos operands per realitzar una operació. Pocs operadors com l'operador ++ (increment) són l'operador unari, cosa que significa que només operen en un operant.
També hi ha un operador ternari en C ++ anomenat Operador Condicional que pren tres operands. Aprendrem això en detall a la part posterior del tutorial.
Tipus d'operadors en C ++
Els operadors en C ++ es classifiquen com es mostra a continuació:
Explorem detalladament cada tipus d'operador C ++.
Operadors aritmètics
Els operadors aritmètics s’utilitzen per realitzar operacions matemàtiques bàsiques en operands.
C ++ admet les següents operacions aritmètiques:
Operador | Binari / unari | Descripció |
---|---|---|
- | Unari | Operador de disminució: disminueix el valor de l’operant en 1 |
+ | Binari | Addició de dos operands |
- | Binari | Resta de dos operands |
* | Binari | Multiplicació de dos operands |
/ | Binari | Divisió de dos operands |
% | Binari | Operador de mòdul: el resultat és la resta de la divisió |
++ | Unari | Operador d’increment: augmenta el valor de l’operant en 1 |
L'exemple següent mostra els primers cinc operadors aritmètics en C ++
#include #include using namespace std; int main() { int op1=3,op2=4; float op3=10.1,op4=5.4; cout<<'Operands are op1 = '< Els següents operadors aritmètics que parlarem són ++ i -. S’anomenen operadors d’increment i decrement respectivament. L'operador d'increment augmenta el valor de l'operand en 1 mentre que l'operador de disminució disminueix el valor de l'operand en 1.
L’expressió x ++ equival a
x + = 1;
x = x + 1;
De la mateixa manera, l'expressió x és equivalent a
x - = 1;
x = x-1;
Els operadors d'increment i decrement es poden col·locar com a prefix i com a sufix a l'operand. Depenent de la seva ubicació, aquests operadors tenen un significat diferent a l'avaluació d'una expressió.
Quan es col·loca com a prefix, l'operació d'increment / decrement es coneix respectivament com a preincrement o predecrement, respectivament. Quan es col·loca com a sufix, l'operació d'increment / decrement es denomina operació postincrement o postdecrement respectivament.
Sempre que hi ha expressions, en cas de preincrement o predecreixement, primer es realitza l'operació (increment o decrement) i després es fa l'assignació. En el cas de postincrement o postdecrement, l'assignació es fa primer i l'operació es realitza després.
Podem entendre-ho millor utilitzant el següent exemple.
#include #include using namespace std; int main() { int x=4,y; y = ++x; cout<<'PreIncrement:Value of x = '< A la segona expressió y = x–, el valor de x que ara és 5, s’assignarà primer a y i després es reduirà el valor de x. Per tant, a la sortida, podem veure que per a l’operació post-decrement, el valor de y és 5 mentre que x és 4.
Operadors lògics
Els operadors lògics s’utilitzen per avaluar una combinació de condicions / restriccions per obtenir un valor resultant. El resultat de l'avaluació d'una expressió booleana és booleà, que és veritable o falsa.
C ++ admet els següents operadors lògics:
Operador Descripció 7 L-> R <<
>> Desplaça't cap a l'esquerra cap a cap
Canvieu a la dreta cap a la dreta && Lògic AND: retorna cert si ambdues condicions són certes, en cas contrari retorna fals. || OR lògic: torna cert si una de les condicions és certa. Torna fals quan ambdues condicions són falses. ! Lògic NO: nega la condició.
C ++ utilitza un mètode de curtcircuit per avaluar expressions lògiques. En això, C ++ ha d’avaluar només la primera expressió / operand de l’expressió lògica per proporcionar el resultat. Per exemple, per a l'operador AND lògic (&&), C ++ avalua només la primera expressió. Si és fals, el resultat serà fals encara que la segona condició sigui certa.
De la mateixa manera, per a OR (||) lògic, avalua només la primera expressió. Si la primera expressió és certa, el resultat serà cert, de manera que no cal avaluar la segona expressió.
A continuació es mostra un exemple que mostra l'ús d'operadors lògics.
#include #include using namespace std; int main() int a=10, b=8,c=12,d=14; if(!(a==0)) cout<<'a is not zero'< Sortida:
a no és zero
Lògic I és cert
L 'OR lògic és cert
En el programa anterior, hem utilitzat tots els tres operadors lògics per avaluar expressions i imprimir els resultats.
Operadors relacionals
Els operadors relacionals o de comparació s’utilitzen per comparar dos operands. El resultat de l'avaluació és cert o fals.
C ++ admet els següents operadors relacionals:
Operador Descripció ! ERROR! operador inesperat '=' Avalua si dos operands són iguals. Retorna vertader si igual resta torna fals. ! = (no és igual a) Complements 'igual a' operador. Retorna cert si els operands no són iguals. Altrament fals. <(less than) Retorna cert si el primer operant és inferior al segon. Altrament fals. <=(less than equal to) Retorna cert si el primer operand és inferior o igual al segon operant. Altrament fals. > (superior a) Retorna cert si el primer operant és superior a segon. Altrament fals. > = (major que igual a) Retorna cert si el primer operant és més gran que igual al segon. Altrament fals.
Consulteu l'exemple de programa següent per entendre els operadors relacionals.
#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'< Sortida:
a no és igual a b
c no és igual a d
(a + b) inferior a / igual a (c + d)
(a-b) superior a / igual a (d-c)
Al programa anterior, veiem l’ús dels operadors relacionals i la forma en què avaluen les expressions proporcionades.
Tingueu en compte que podem proporcionar no només valors, sinó també variables i expressions en els enunciats condicionals.
Operadors de bits
Els operadors de bits a C ++ operen en bits dels operands proporcionats. Els operadors de bits només s’apliquen a tipus integrals com a enter, caràcter, etc., i no a tipus de dades com float, double, etc.
A continuació es mostren els operadors de bits compatibles amb C ++:
Operadors Descripció & (Binari I) Realitza operacions I en bits de l’operand 1 i 2. | (OR binari) Realitza una operació OR en bits de l’operand 1 i 2. ^ (XOR binari) Realitza l'operació XOR als bits de l'operand 1 i 2. ~ (Complement binari) Pren un operand i inverteix els seus bits. <<( Binary left shift operator) Desplaça els bits del primer operand cap a l'esquerra cap a un nombre de bits especificat pel segon operand. >> (Operador de desplaçament binari a la dreta) Desplaça els bits del primer operand cap a la dreta a diversos llocs especificats pel segon operand.
Aquests operadors de bits operen en operands de manera a bits. Les taules de veritat per a les operacions AND, OR i XOR es donen a continuació.
Considereu a i b com dos bits sobre els quals s'han de realitzar operacions AND, OR i XOR.
Les taules de veritat corresponents són les següents:
a 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
Prenem un exemple per entendre les operacions bitwise.
Sigui a = 8 i b = 4
La representació binària de a i b és la següent:
a = agost 1000
a = 4 0100
a & b 0000 = 0
a | b 1100 = 12
a ^ b 1100 = 12
A l'exemple anterior, veiem que el AND a bits de 8 i 4 és 0. OR a bit a bit de 8 i 4 és 12 i XOR a bit a bit de 8 i 4 també és 12.
Aquesta és la manera en què els operadors de bits realitzen les operacions a bits.
Un exemple que demostra els operadors Bitwise.
#include #include using namespace std; int main() int a=8,b=4,c; c = a&b; cout<<'Result of & : '< Sortida:
Resultat de &: 0
Resultat de | : 12
Resultat de ^: 12
Resultat de<< by 2 bits: 32
Resultat de >> per 2 bits: 1
Resultat de ~: -4
Al programa anterior, vam demostrar l’ús d’operadors de bits i també vam imprimir la sortida de cadascuna de les operacions.
Operadors de tasques
L'operador d'assignació '=' s'utilitza per assignar un valor a una variable. El LHS de l'operador d'assignació és una variable i RHS és el valor que s'ha d'assignar a la variable. El valor del costat dret ha de ser del mateix tipus que el de la variable del costat esquerre.
Tingueu en compte la diferència entre els operadors ‘=’ i ‘==’. El primer és l’operador d’assignació i el darrer és l’operador d’igualtat.
L'operació d'assignació es fa de dreta a esquerra. A part de l’operador d’assignació ‘=’, hi ha altres variacions d’operador d’assignació que es coneixen com a ‘operadors d’assignació composta’. Aquests operadors realitzen una operació a més de l'assignació.
La taula següent ens proporciona una descripció d’aquests operadors d’assignació.
Operador Descripció = Assigna el valor de l'operand RHS a l'operand LHS + = Afegeix operand RHS a operand LHS i assigna el resultat en operand LHS. - = Resta l'operand RHS a l'operand LHS i assigna el resultat a l'operand LHS * = multiplica l'operand RHS a l'operand LHS i assigna el resultat a l'operand LHS / = divideix l'operand RHS a l'operand LHS i assigna el resultat a l'operand LHS
Com es mostra a la taula anterior, si x i y són operands, x + = y equival a x = x + y.
De la mateixa manera,
x - = y equival a x = x-y.
x * = y equival a x = x * y.
x / = y equival a x = x / y.
L'exemple de programació següent mostra aquests operadors d'assignació.
#include #include using namespace std; int main() { int x,y; cout<>y; x = y; cout<<'
Value of x = '< Sortida:
Introduïu la variable d'entrada y: 4
preguntes i respostes de l'entrevista datastage pdf
Valor de x = 4
a + = b: 8
c - = b: 3
a * = b: 40
b / = c: 1
En l'exemple anterior, hem demostrat els operadors d'assignació i d'assignació composta.
Nota: També podem combinar els altres operadors binaris com%,<>, &, |, ^, etc. en sentències d'assignació composta a més de les que ja estan demostrades.
Altres operadors
Fins ara hem explorat tots els principals operadors de C ++. Hi ha alguns operadors addicionals de C ++ que necessiten la nostra atenció.
Aquests operadors inclouen:
(i) mida de l'operador
sizeof és un operador unari que s'utilitza àmpliament en C i C ++. Sizeof retorna la mida del seu operand. El valor de retorn sol ser un tipus d’integral sense signar que es denota per ‘size_t’.
L'operador Sizeof té molts usos en llenguatges C i C ++. Es pot utilitzar per esbrinar la mida de les variables, matrius o expressions i fins i tot per assignar els blocs de memòria.
(ii) Operador ternari condicional
L'operador condicional a C ++ es pot utilitzar com a substitut de la sentència if-else.
La sintaxi general de l'operador condicional és:
Condició? expressió1: expressió2;
Si la condició és certa, s'avaluarà l'expressió 1. Si la condició és falsa, s'avaluarà expression2.
Tingueu en compte que expression1 i expression2 han de ser dels mateixos tipus de dades per evitar possibles errors.
Lectura suggerida => Operador ternari en C #
(iii) Operador de comes
L’operador de coma que es representa com a testimoni ‘,’ es pot utilitzar tant com a operador com a separador.
Com a operador, s’utilitza una coma quan hi ha més d’una expressió per avaluar. Només s’assigna l’expressió més dreta a LHS.
Per exemple,tingueu en compte la següent expressió.
x = (i = 4, i + 1);
En aquesta expressió, tenim dues expressions a la part dreta separades amb una coma. Aquí la coma actua com a operador. En primer lloc, s’avaluarà l’expressió, y = 4. Aleshores, la següent expressió y + 1 s’avaluarà mitjançant el resultat de la primera expressió, és a dir, y = 4. Així, el valor de y + 1 serà 5 i aquest valor s’assignarà a x.
Com a separador, es pot utilitzar una coma en qualsevol lloc per separar definicions, llista de paràmetres, etc.
(iv) Operador d'accés de membres
Hi ha dos operadors que s’utilitzen per accedir als membres individuals de classes, estructures o unions en C ++. Aquests són l'operador de punts (.) I l'operador de fletxa (->). Aprendrem aquests operadors en detall quan aprenem programació orientada a objectes en C ++.
L'exemple següent mostra l'ús de sizeof, coma i operador condicional.
#include #include using namespace std; int main() { int x,y; x = (y=3,y+4); cout<<'Value of x = '< Sortida:
Valor de x = 7
La variable x és superior a 5
sizeof (x): 4 sizeof (y): 4
A continuació es mostra la captura de pantalla del mateix.
què són les proves de fum i les proves de seny
Com es mostra al programa anterior, primer tenim dues variables declarades i separades per una coma. (coma com a separador). A continuació, tenim un operador de comes amb dues expressions. Com podem veure a la sortida, el valor de l’expressió més a la dreta s’assigna a la variable x. A continuació, demostrem l'operador condicional per avaluar si x és inferior a 5.
Finalment, demostrem l’ús de l’operador sizeof. Aquí fem servir l’operador sizeof per obtenir la mida de les variables xey. Com que ambdues són variables senceres, la mida retornada és de 4 bytes.
(v) Precedència i associació de l’operador
Ja hem vist gairebé tots els operadors C ++ i sabem que es poden utilitzar en expressions per dur a terme operacions específiques. Però les expressions que hem vist en exemples són senzilles i directes. No obstant això, en funció dels nostres requisits, les expressions tendeixen a ser cada vegada més complexes.
Aquestes expressions complexes tindran més d’un operador i molts operands. En aquesta situació, hem d'avaluar quin operador s'ha d'avaluar primer.
Per exemple, tingueu en compte la següent expressió.
x = 4 + 5/3;
Aquí tenim operadors + i / i hem de decidir quina expressió s’avaluarà primer. En termes matemàtics, sabem que la divisió es durà a terme abans de la suma. Així, l’expressió es convertirà en x = 4 + (5/3) = 5.
Però quan el compilador s’enfronta a aquesta situació, també hem de tenir un mecanisme similar per decidir l’ordre de les operacions, de manera que pugui avaluar correctament l’expressió.
Aquest ordre en què s'avaluen els operadors d'una expressió composta s'anomena 'Precedència' de l'operador. C ++ ha definit la precedència per a tots els operadors i primer s’avaluen els operadors amb precedència més alta.
Què passa quan tenim dos operadors una al costat de l’altra en una expressió amb la mateixa precedència? Aquí és on apareix l’associativitat d’un operador.
L’associativitat indica al compilador si avalua una expressió de seqüència d’esquerra a dreta o de seqüència de dreta a esquerra. Així, utilitzant la precedència i l’associativitat d’un operador, podem avaluar eficaçment una expressió i obtenir el resultat desitjat.
C ++ proporciona una taula que consisteix en la precedència i l’associativitat de diversos operadors que utilitza.
Aquesta taula es presenta a continuació.
Precedència / Associativitat Operador Descripció 1 Cap ::
:: Operador de resolució d'abast
(unari)
(binari) 2 L-> R ()
()
()
{}
type ()
escriu {}
[]
.
->
++
-
typeid
const_cast
cast_dinàmic
reinterpret_cast
emissió_estàtica Parèntesis
Funció de trucada
Inicialització
Inicialització uniforme (C ++ 11)
Repartiment funcional
Repartiment funcional (C ++ 11)
Subíndex de matriu
Accés de membres des de l'objecte
Accés de membres des de l'objecte ptr
Post-increment
Postdecrement
Informació del tipus d’execució
Llença const
Repartiment comprovat per tipus en temps d'execució
Emetre un tipus a un altre. Emetre comprovat el tipus en temps de compilació 3 R-> L +
-
++
-
!
~
(tipus)
mida de
&
*
nou
nou []
esborrar
esborra [] Unari més
Unari menys
Preincrement
Pre-decrement
Lògic NO
Bitwise NO
Repartiment a l'estil C.
Mida en bytes
Adreça de
Dereferència
Assignació dinàmica de memòria
Assignació de matriu dinàmica
Supressió dinàmica de la memòria
Supressió de matriu dinàmica 4 L-> R -> *
. * Selector de punter de membre
Selector d'objectes membres 5 L-> R *
/
% Multiplicació
Divisió
Mòdul 6 L-> R +
- Addició
Resta 8 L-> R <
<=
>
> = Comparació inferior a
Comparació inferior o igual
Comparació superior a
Comparació superior o igual 9 L-> R ! ERROR! caràcter il·legal '!' Igualtat
Desigualtat 10 L-> R & A bit a bit I 11 L-> R ^ XOR a bits 12 L-> R | OR a bit 13 L-> R && Lògic I 14 L-> R || OR lògic 15 R-> L ?:
=
* =
/ =
% =
+ =
- =
<<=
>> =
& =
| =
^ = Condicional (vegeu la nota següent)
Tasca
Assignació de multiplicació
Assignació de divisió
Assignació del mòdul
Assignació d’addicions
Tasca de resta
Assignació de desplaçament a l’esquerra per bits
Assignació de desplaçament a la dreta cap a un bit
Assignació de bits i bits
Assignació OR a bits
Assignació XOR a bits 16 R-> L llançar Expressió de llançament 17 L-> R , Operador de coma
Notes:
- El nivell de precedència 1 és el nivell de precedència més alt i el nivell 17 és el més baix. Els operadors amb un nivell de precedència més alt s’avaluen primer.
- L-> R significa associativitat d’esquerra a dreta.
- R-> L significa associativitat de dreta a esquerra.
Conclusió
Tot es tracta dels operadors de C ++.
Hem parlat de gairebé tots els operadors. Alguns operadors específics que estan presents a la taula de precedències anteriors i que no hem discutit, es discutiran d'acord amb els temes que tractem als nostres propers tutorials.
=> Vegeu aquí per explorar la llista completa de tutorials de C ++
Lectura recomanada
- Exemples d'operadors aritmètics i booleans d'escriptura Shell Unix
- Operadors de Python
- Operadors nous / suprimits de C ++ amb exemples
- Tipus de dades Python
- Enunciats condicionals Unix: si és així i operadors relacionals
- Tutorial de Python DateTime amb exemples
- Tutorial sobre injecció d'HTML: tipus i prevenció amb exemples
- Talla l'ordre a Unix amb exemples