Menú

Operadors C #: aritmètica, relacional, assignació i lògica

  • Principal
  • Altres
  • Operadors C #: aritmètica, relacional, assignació i lògica

c operators arithmetic

Els operadors de C # són símbols especials per indicar l'operació que el programa ha de realitzar. Aquest tutorial explica detalladament els operadors C # amb exemples:

En el nostre tutorial anterior, vam conèixer les declaracions condicionals a C #. També vam aprendre a utilitzar instruccions if, if-else i if-else if per definir diferents condicions.

Una declaració condicional com ara 'si' també es coneix com a declaració de presa de decisions, ja que proporciona a l'usuari un mecanisme per definir un resultat basat en una decisió definida pels operadors.

Els operadors ofereixen una manera de definir decisions basades en lògica, operacions aritmètiques, comparació, etc.

=> Vegeu la nostra sèrie completa d’entrenaments C # aquí

Operadors de C #

Què aprendreu:

Operadors de C #

Els operadors de C # són símbols especials que denoten l'operació que el programa ha de realitzar als operands. Per exemple, es poden utilitzar per avaluar una variable o realitzar una operació sobre una variable per fer una expressió adequada.

C # ofereix una àmplia varietat d'operadors com ara operadors aritmètics, operadors relacionals, operadors d'assignacions, operadors lògics, operaris unaris, etc. En aquest tutorial, parlarem d'alguns dels operadors importants juntament amb el seu ús.

Operadors aritmètics

L'operador aritmètic permet al programa realitzar operacions algebraiques generals contra valors numèrics.

Hi ha cinc operadors bàsics presents en el llenguatge de programació C #.

  • Addició (símbol '+'): Realitzeu l'addició d'operands.
  • Resta (símbol '-'): Realitza restes d'operands.
  • Divisió (símbol '/'): Realitza la divisió d'operands.
  • Multiplicació (símbol '*'): Realitza multiplicacions en operands.
  • Mòdul (símbol '%'): Retorna el recordatori després de la divisió de l'enter.

Exemple:

int a = 10; int b = 5; int result; result = a + b; result = a - b; result = a * b; result = a / b; result = a % b;
  1. El resultat de la primera operació serà 15, és a dir, la suma a dos enters.
  2. El resultat de la segona operació serà 5, és a dir, resta de dos enters.
  3. El resultat de la tercera operació serà 50, és a dir, multiplicació entre dos enters.
  4. El resultat de la quarta operació serà 2, és a dir, la sortida de la divisió de dos enters.
  5. El resultat de la cinquena operació serà 0, ja que no quedarà cap recordatori quan es divideixin dos enters donats.

Cal recordar que el resultat de l’operació dependrà del tipus de dades utilitzat per emmagatzemar-ne el resultat.

Per tant, si la divisió de dos valors enters retorna un valor flotant i si el resultat s’assigna a una variable sencera, la part decimal es perdrà a causa de diferents tipus de dades. Per obtenir més informació sobre els tipus de dades i la conversió, si us plau visiteu el nostre tutorial anterior.

L'operador de mòdul és diferent dels altres operadors, retorna el valor del recordatori a partir de la divisió de nombres enters. Diguem que si dividim 20 per 6, l’operador de divisió retornarà una resposta com a 3 (el quocient) i l’operador de mòdul retornarà 2, és a dir, el recordatori de la divisió.

A part dels cinc operadors definits anteriorment, C # també ofereix dos operadors especials que augmenten o redueixen el valor d'una variable en 1.

Aquests són:

  • Operador d'increment : Es denota amb el símbol “++”
  • Operador de decrement : Es denota amb el símbol '- -'

Aquests operadors es poden pre-fixar o sufixar amb variables per al funcionament.

Exemple:

int a = 10; int b = 5; int increment; int decrement; increment = a++; decrement = b--;

A l'exemple anterior, la resposta per a l'increment serà d'11, és a dir, el valor de a s'incrementarà en 1. Mentre que la resposta per a la disminució serà de 4, és a dir, el valor de b es reduirà en 1.

Operadors relacionals

Qualsevol relació entre els dos operands es valida mitjançant l'ús d'operadors relacionals. Els operadors relacionals retornen valors booleans. Si la relació entre dos operands es valida amb èxit, tornarà 'true' i, si falla la validació, es retornarà 'false'.

Els operadors relacionals s’utilitzen principalment en la presa de decisions o per definir les condicions dels bucles.

Vegem els operadors relacionals que ofereix C #:

  • Més gran que l'operador: (denotat per '>'): valida més que la relació entre operands.
  • Menys que operador: (denotat per '<“): Validates less than the relation between operands.
  • Operador igual a: (denotat per '=='): valida la igualtat de dos operands.
  • Més gran o igual a (denotat per '> ='): valida més o igual a la relació entre els dos operands.
  • Menys o igual a (denotat per '<=”): Validates less than or equals to the relations between the two operands.
  • No igual: (denotat per '! ='): no valida una relació igual entre els dos operands.
int a = 10; int b = 5; bool validate; validate = a > b; //1 Console.WriteLine(validate); validate = a = b; //4 Console.WriteLine(validate); validate = a <= b; //5 Console.WriteLine(validate); validate = a != b; //6 Console.WriteLine(validate);

La sortida del programa anterior serà:

  1. a> b retornarà 'True'.
  2. a
  3. a == b retornarà 'Fals'.
  4. a> = b retornarà 'True' ja que a és superior a b i l'operador busca una avaluació satisfactòria d'alguna de les condicions donades per retornar un valor real. Com que l'exemple donat torna 'True' en ambdós casos, l'operador retornarà true.
  5. a<=b will return “False” as a is neither less than b nor equal to b.
  6. a! = b retornarà 'True' ja que a no és igual a b.

Operadors de tasques

Els operadors d'assignació s'utilitzen per assignar valor a una variable. Generalment s’utilitzen abans que un operador aritmètic.

Vegem els operadors de tasques que ofereix C #:

(i) Igual a (“=”): És un dels operadors d'assignació més senzills. Assigna el valor d'un operant a un altre. és a dir, el valor de l’operand del costat dret a l’operant del costat esquerre.

Examp el: a = b

(ii) Afegeix igual a l'operador de tasques: Com el seu nom indica, és una combinació de més '+' i igual a '='. S'escriu com a '+ =' i afegeix l'operand a la part dreta a l'operand esquerre i emmagatzema el valor final a l'operand esquerre.

Exemple: a + = b significa (a = a + b)

(iii) Resta operador de tasca igual: De manera similar a la suma igual, resta el valor de l’operand dret de l’operand esquerre i, a continuació, assigna el valor a l’operand esquerre.

Exemple: a - = b significa (a = a-b)

(iv) Divisió igual a l’operador de tasques: Divideix el valor de l’operand dret amb l’operand esquerre i després emmagatzema el resultat a l’operand esquerre.

Exemple: a / = b mitjana (a = a / b)

(v) Multiplicar igual a l'operador de tasques: Multiplica el valor de l’operand dret amb l’operand esquerre i després emmagatzema el resultat a l’operand esquerre.

Exemple: a * = b significa (a = a * b)

(vi) Mòdul igual a l'operador d'assignació: Troba el mòdul de l’operand esquerre i dret i emmagatzema el valor a l’operand esquerre.

Exemple:

a %=b means (a= a%b)

A continuació es mostra un programa per tenir més claredat:

millor eliminació de programari maliciós per a Windows 7
int a = 10; int b = 5; a += b; //1 Console.WriteLine(a); a -= b; //2 Console.WriteLine(a); a /= b; //3 Console.WriteLine(a); a *= b; //4 Console.WriteLine(a); a %= b; //5 Console.WriteLine(a);

Sortida

  1. El primer valor retornarà 15, és a dir, a = a + b.
  2. El segon operador retornarà 10, és a dir, a = a-b.
  3. El tercer operador retornarà 2, és a dir, a = a / b.
  4. El quart operador retornarà 50, és a dir, a = a * b.
  5. El cinquè operador retornarà 0, és a dir, a = a% b.

Operadors lògics

Els operadors lògics s’utilitzen per realitzar operacions lògiques. Els operadors lògics funcionen amb expressions booleanes i retornen un valor booleà. Els operadors lògics s’utilitzen amb els operadors condicionals en bucles i declaracions de presa de decisions.

Operadors lògics i el seu ús.

# 1) Operador i lògic

Símbol: '&&'

L’operador AND retorna true quan els dos valors són true. Si algun dels valors és fals, es tornarà fals.

Per exemple, A & B tornarà a ser cert si tant A com B són certs, si algun o tots dos són falsos, tornarà a ser fals.

# 2) Operador O Lògic

Símbol: '||'

O l’operador torna cert si alguna de les condicions / operands és certa. Es tornarà fals quan tots dos operands són falsos.

Per exemple, A || B retorna cert si el valor de qualsevol de A o B és cert. Tornarà fals si A i B tenen valors falsos.

# 3) Lògic NO operador

Símbol: '!'

L'operador NOT s'utilitza per invertir la conclusió lògica de qualsevol condició. Si la condició és certa, tornarà a ser falsa i, si la condició és falsa, tornarà a ser certa.

Exemple, ! (A || B) retorna fals si “A || B” retorna cert i retornarà cert si “A || B” retorna fals.

Exemple de programa:

int a = 10; int b = 5; bool result; // AND operator result = (a == b) && (a>b) Console.WriteLine(result); //OR Operator result = (a == b) || (a>b) Console.WriteLine(result); //NOT Operator result = !((a == b) || (a>b)) Console.WriteLine(result);

La sortida del programa anterior serà:

  1. El primer valor retornarà fals ja que una de les condicions és a dir, a == b és falsa.
  2. El segon operador tornarà cert com una de les condicions, és a dir, a> b és certa.
  3. El tercer operador retornarà fals, és a dir, la negació del resultat de l’operador OR.

Conclusió

En aquest tutorial, hem après sobre els diferents tipus d'operadors del llenguatge de programació C #. Vam conèixer l’ús i els símbols d’aquests operadors. L'operador aritmètic el fa servir el programa per realitzar operacions algebraiques senzilles com suma, resta, multiplicació, divisió, etc.

Els operadors relacionals són els que s'utilitzen per validar una relació entre els dos operands com si fossin iguals, majors que, inferiors a, etc. Els operadors d'assignació s'utilitzen per assignar valors a una variable. Un exemple més senzill de l'operador d'assignació és 'igual a'. Els operadors lògics s’utilitzen per realitzar operacions lògiques com AND, OR, NOT, etc.

Els operadors s’utilitzen àmpliament per declarar condicions en declaracions de presa de decisions, mentre s’utilitzen bucles o mentre es realitzen operacions algebraiques.

=> Consulteu aquí la nostra última guia de formació C #

Lectura recomanada

^