Operadores aritméticos (referencia de C#)Arithmetic operators (C# Reference)

Los operadores siguientes realizan operaciones aritméticas con tipos numéricos:The following operators perform arithmetic operations with numeric types:

Estos operadores admiten todos los tipos numéricos integrales y de punto flotante.Those operators support all integral and floating-point numeric types.

Operador de incremento ++Increment operator ++

El operador de incremento unario ++ incrementa su operando en 1.The unary increment operator ++ increments its operand by 1. El operando debe ser una variable, un acceso de propiedad o un acceso de indexador.The operand must be a variable, a property access, or an indexer access.

El operador de incremento se admite en dos formas: el operador de incremento posfijo (x++) y el operador de incremento prefijo (++x).The increment operator is supported in two forms: the postfix increment operator, x++, and the prefix increment operator, ++x.

Operador de incremento de postfijoPostfix increment operator

El resultado de x++ es el valor de x antes de la operación, tal y como se muestra en el ejemplo siguiente:The result of x++ is the value of x before the operation, as the following example shows:

int i = 3;
Console.WriteLine(i);   // output: 3
Console.WriteLine(i++); // output: 3
Console.WriteLine(i);   // output: 4

Operador de incremento prefijoPrefix increment operator

El resultado de ++x es el valor de x después de la operación, tal y como se muestra en el ejemplo siguiente:The result of ++x is the value of x after the operation, as the following example shows:

double a = 1.5;
Console.WriteLine(a);   // output: 1.5
Console.WriteLine(++a); // output: 2.5
Console.WriteLine(a);   // output: 2.5

Operador de decremento --Decrement operator --

El operador de decremento unario -- disminuye su operando en 1.The unary decrement operator -- decrements its operand by 1. El operando debe ser una variable, un acceso de propiedad o un acceso de indexador.The operand must be a variable, a property access, or an indexer access.

El operador de decremento se admite en dos formas: el operador de decremento posfijo (x--) y el operador de decremento prefijo (--x).The decrement operator is supported in two forms: the postfix decrement operator, x--, and the prefix decrement operator, --x.

Operador de decremento de postfijoPostfix decrement operator

El resultado de x-- es el valor de x antes de la operación, como se muestra en el ejemplo siguiente:The result of x-- is the value of x before the operation, as the following example shows:

int i = 3;
Console.WriteLine(i);   // output: 3
Console.WriteLine(i--); // output: 3
Console.WriteLine(i);   // output: 2

Operador de decremento de prefijoPrefix decrement operator

El resultado de --x es el valor de x después de la operación, tal y como se muestra en el ejemplo siguiente:The result of --x is the value of x after the operation, as the following example shows:

double a = 1.5;
Console.WriteLine(a);   // output: 1.5
Console.WriteLine(--a); // output: 0.5
Console.WriteLine(a);   // output: 0.5

Operadores unarios más y menosUnary plus and minus operators

El operador + unario devuelve el valor de su operando.The unary + operator returns the value of its operand. El operador unario - calcula la negación numérica del operando.The unary - operator computes the numeric negation of its operand.

Console.WriteLine(+4);     // output: 4

Console.WriteLine(-4);     // output: -4
Console.WriteLine(-(-4));  // output: 4

uint a = 5;
var b = -a;
Console.WriteLine(b);            // output: -5
Console.WriteLine(b.GetType());  // output: System.Int64

Console.WriteLine(-double.NaN);  // output: NaN

El operador unario - no es compatible con el tipo ulong.The unary - operator doesn't support the ulong type.

Operador de multiplicación *Multiplication operator *

El operador de multiplicación * calcula el producto de sus operandos:The multiplication operator * computes the product of its operands:

Console.WriteLine(5 * 2);         // output: 10
Console.WriteLine(0.5 * 2.5);     // output: 1.25
Console.WriteLine(0.1m * 23.4m);  // output: 2.34

El operador unario * es el operador de direccionamiento indirecto del puntero.The unary * operator is the pointer indirection operator.

Operador de división /Division operator /

El operador de división / divide su primer operando por su segundo operando.The division operator / divides its first operand by its second operand.

División de enterosInteger division

Para los operandos de tipos enteros, el resultado del operador / es de un tipo entero y equivale al cociente de los dos operandos redondeados hacia cero:For the operands of integer types, the result of the / operator is of an integer type and equals the quotient of the two operands rounded towards zero:

Console.WriteLine(13 / 5);    // output: 2
Console.WriteLine(-13 / 5);   // output: -2
Console.WriteLine(13 / -5);   // output: -2
Console.WriteLine(-13 / -5);  // output: 2

Para obtener el cociente de los dos operandos como número de punto flotante, use el tipo float, double o decimal:To obtain the quotient of the two operands as a floating-point number, use the float, double, or decimal type:

Console.WriteLine(13 / 5.0);       // output: 2.6

int a = 13;
int b = 5;
Console.WriteLine((double)a / b);  // output: 2.6

División de punto flotanteFloating-point division

Para los tipos float, double y decimal, el resultado del operador / es el cociente de los dos operandos:For the float, double, and decimal types, the result of the / operator is the quotient of the two operands:

Console.WriteLine(16.8f / 4.1f);   // output: 4.097561
Console.WriteLine(16.8d / 4.1d);   // output: 4.09756097560976
Console.WriteLine(16.8m / 4.1m);   // output: 4.0975609756097560975609756098

Si uno de los operandos es decimal, otro operando no puede ser float ni double, ya que ni float ni double se convierte de forma implícita a decimal.If one of the operands is decimal, another operand can be neither float nor double, because neither float nor double is implicitly convertible to decimal. Debe convertir explícitamente el operando float o double al tipo decimal.You must explicitly convert the float or double operand to the decimal type. Para obtener más información sobre las conversiones implícitas entre tipos numéricos, consulte Tabla de conversiones numéricas implícitas.For more information about implicit conversions between numeric types, see Implicit numeric conversions table.

Operador de resto %Remainder operator %

El operador de resto % calcula el resto después de dividir su primer operando entre el segundo.The remainder operator % computes the remainder after dividing its first operand by its second operand.

Resto enteroInteger remainder

En el caso de los operandos de tipos enteros, el resultado de a % b es el valor producido por a - (a / b) * b.For the operands of integer types, the result of a % b is the value produced by a - (a / b) * b. El signo de resto distinto de cero es el mismo que el del primer operando, como se muestra en el ejemplo siguiente:The sign of the non-zero remainder is the same as that of the first operand, as the following example shows:

Console.WriteLine(5 % 4);   // output: 1
Console.WriteLine(5 % -4);  // output: 1
Console.WriteLine(-5 % 4);  // output: -1
Console.WriteLine(-5 % -4); // output: -1

Use el método Math.DivRem para calcular los resultados de la división de enteros y del resto.Use the Math.DivRem method to compute both integer division and remainder results.

Resto de punto flotanteFloating-point remainder

En el caso de los operandos float y double, el resultado de x % y para x e y finitos es el valor z, de modo queFor the float and double operands, the result of x % y for the finite x and y is the value z such that

  • el signo de z, si no es cero, es el mismo que el signo de x;The sign of z, if non-zero, is the same as the sign of x.
  • el valor absoluto de z es el valor producido por |x| - n * |y|, donde n es el entero más grande posible que sea menor o igual que |x| / |y|, y |x| e |y| son los valores absolutos de x e y, respectivamente.The absolute value of z is the value produced by |x| - n * |y| where n is the largest possible integer that is less than or equal to |x| / |y| and |x| and |y| are the absolute values of x and y, respectively.

Nota

Este método de cálculo del resto es análogo al usado para los operandos enteros, pero difiere de IEEE 754.This method of computing the remainder is analogous to that used for integer operands, but differs from the IEEE 754. Si necesita la operación de resto conforme con IEEE 754, use el método Math.IEEERemainder.If you need the remainder operation that complies with the IEEE 754, use the Math.IEEERemainder method.

Para información sobre el comportamiento del operador % con operandos no finitos, vea la sección Operador de resto de la Especificación del lenguaje C#.For information about the behavior of the % operator with non-finite operands, see the Remainder operator section of the C# language specification.

En el caso de los operandos decimal, el operador de resto % es equivalente al operador de resto del tipo System.Decimal.For the decimal operands, the remainder operator % is equivalent to the remainder operator of the System.Decimal type.

En el ejemplo siguiente se muestra el comportamiento del operador de resto con operandos de punto flotante:The following example demonstrates the behavior of the remainder operator with floating-point operands:

Console.WriteLine(-5.2f % 2.0f); // output: -1.2
Console.WriteLine(5.9 % 3.1);    // output: 2.8
Console.WriteLine(5.9m % 3.1m);  // output: 2.8

Operador de suma +Addition operator +

El operador de suma + calcula la suma de sus operandos:The addition operator + computes the sum of its operands:

Console.WriteLine(5 + 4);       // output: 9
Console.WriteLine(5 + 4.3);     // output: 9.3
Console.WriteLine(5.1m + 4.2m); // output: 9.3

También puede usar el operador + para la concatenación de cadenas y la combinación de delegados.You also can use the + operator for string concatenation and delegate combination. Para obtener más información, consulte Operadores + y +=.For more information, see the + and += operators article.

Operador de resta -Subtraction operator -

El operador de resta - resta su segundo operando del primero:The subtraction operator - subtracts its second operand from its first operand:

Console.WriteLine(47 - 3);      // output: 44
Console.WriteLine(5 - 4.3);     // output: 0.7
Console.WriteLine(7.5m - 2.3m); // output: 5.2

También puede usar el operador - para la eliminación de delegados.You also can use the - operator for delegate removal. Para obtener más información, vea el artículo Operador -.For more information, see the - operator article.

Asignación compuestaCompound assignment

Para un operador binario op, una expresión de asignación compuesta con el formatoFor a binary operator op, a compound assignment expression of the form

x op= y

es equivalente ais equivalent to

x = x op y

salvo que x solo se evalúa una vez.except that x is only evaluated once.

En el ejemplo siguiente se muestra el uso de la asignación compuesta con operadores aritméticos:The following example demonstrates the usage of compound assignment with arithmetic operators:

int a = 5;
a += 9;
Console.WriteLine(a);  // output: 14

a -= 4;
Console.WriteLine(a);  // output: 10

a *= 2;
Console.WriteLine(a);  // output: 20

a /= 4;
Console.WriteLine(a);  // output: 5

a %= 3;
Console.WriteLine(a);  // output: 2

A causa de las promociones numéricas, el resultado de la operación op podría no ser convertible de forma implícita en el tipo T de x.Because of numeric promotions, the result of the op operation might be not implicitly convertible to the type T of x. En tal caso, si op es un operador predefinido y el resultado de la operación es convertible de forma explícita en el tipo T de x, una expresión de asignación compuesta con el formato x op= y es equivalente a x = (T)(x op y), excepto que x solo se evalúa una vez.In such a case, if op is a predefined operator and the result of the operation is explicitly convertible to the type T of x, a compound assignment expression of the form x op= y is equivalent to x = (T)(x op y), except that x is only evaluated once. En el ejemplo siguiente se muestra ese comportamiento:The following example demonstrates that behavior:

byte a = 200;
byte b = 100;

var c = a + b;
Console.WriteLine(c.GetType());  // output: System.Int32
Console.WriteLine(c);  // output: 300

a += b;
Console.WriteLine(a);  // output: 44

Los operadores += y -= también se usan para suscribirse y cancelar la suscripción a eventos.You also use the += and -= operators to subscribe to and unsubscribe from events. Para obtener más información, vea Procedimientos para suscribir y cancelar la suscripción a eventos.For more information, see How to: subscribe to and unsubscribe from events.

Prioridad y asociatividad de los operadoresOperator precedence and associativity

En la lista siguiente se ordenan los operadores aritméticos de la prioridad más alta a la más baja:The following list orders arithmetic operators starting from the highest precedence to the lowest:

  • Operadores de incremento x++ y decremento x-- posfijosPostfix increment x++ and decrement x-- operators
  • Operadores de incremento ++x y decremento --x prefijos, y operadores unarios + y -.Prefix increment ++x and decrement --x and unary + and - operators
  • Operadores de multiplicación *, / y %.Multiplicative *, /, and % operators
  • Operadores de suma adición + y -.Additive + and - operators

Los operadores aritméticos binarios son asociativos a la izquierda.Binary arithmetic operators are left-associative. Es decir, los operadores con el mismo nivel de prioridad se evalúan de izquierda a derecha.That is, operators with the same precedence level are evaluated from left to right.

Use los paréntesis, (), para cambiar el orden de evaluación impuesto por la prioridad y la asociatividad de operadores.Use parentheses, (), to change the order of evaluation imposed by operator precedence and associativity.

Console.WriteLine(2 + 2 * 2);   // output: 6
Console.WriteLine((2 + 2) * 2); // output: 8

Console.WriteLine(9 / 5 / 2);   // output: 0
Console.WriteLine(9 / (5 / 2)); // output: 4

Para obtener la lista completa de los operadores de C# ordenados por nivel de prioridad, vea Operadores de C#.For the complete list of C# operators ordered by precedence level, see C# operators.

Desbordamiento aritmético y división por ceroArithmetic overflow and division by zero

Si el resultado de una operación aritmética está fuera del intervalo de valores finitos posibles del tipo numérico implicado, el comportamiento de un operador aritmético depende del tipo de sus operandos.When the result of an arithmetic operation is outside the range of possible finite values of the involved numeric type, the behavior of an arithmetic operator depends on the type of its operands.

Desbordamiento aritmético de enterosInteger arithmetic overflow

La división de enteros por cero siempre produce una DivideByZeroException.Integer division by zero always throws a DivideByZeroException.

En el caso de desbordamiento aritmético de enteros, el comportamiento resultante lo controla un contexto de comprobación de desbordamiento, que puede ser comprobado o no comprobado:In case of integer arithmetic overflow, an overflow checking context, which can be checked or unchecked, controls the resulting behavior:

  • En un contexto comprobado, si el desbordamiento se produce en una expresión constante, se produce un error de compilación.In a checked context, if overflow happens in a constant expression, a compile-time error occurs. De lo contrario, si la operación se realiza en tiempo de ejecución, se inicia una excepción OverflowException.Otherwise, when the operation is performed at run time, an OverflowException is thrown.
  • En un contexto no comprobado, el resultado se trunca mediante el descarte de los bits de orden superior que no caben en el tipo de destino.In an unchecked context, the result is truncated by discarding any high-order bits that don't fit in the destination type.

Junto con las instrucciones comprobadas y no comprobadas, puede usar los operadores checked y unchecked para controlar el contexto de comprobación de desbordamiento, en el que se evalúa una expresión:Along with the checked and unchecked statements, you can use the checked and unchecked operators to control the overflow checking context, in which an expression is evaluated:

int a = int.MaxValue;
int b = 3;

Console.WriteLine(unchecked(a + b));  // output: -2147483646
try
{
    int d = checked(a + b);
}
catch(OverflowException)
{
    Console.WriteLine($"Overflow occured when adding {a} to {b}.");
}

De forma predeterminada, las operaciones aritméticas se producen en un contexto no comprobado.By default, arithmetic operations occur in an unchecked context.

Desbordamiento aritmético de punto flotanteFloating-point arithmetic overflow

Las operaciones aritméticas con los tipos float y double nunca inician una excepción.Arithmetic operations with the float and double types never throw an exception. El resultado de las operaciones aritméticas con esos tipos puede ser uno de varios valores especiales que representan infinito y no un número:The result of arithmetic operations with those types can be one of special values that represent infinity and not-a-number:

double a = 1.0 / 0.0;
Console.WriteLine(a);                    // output: Infinity
Console.WriteLine(double.IsInfinity(a)); // output: True

Console.WriteLine(double.MaxValue + double.MaxValue); // output: Infinity

double b = 0.0 / 0.0;
Console.WriteLine(b);                // output: NaN
Console.WriteLine(double.IsNaN(b));  // output: True

Para los operandos del tipo decimal, el desbordamiento aritmético siempre inicia una excepción OverflowException y la división por cero siempre inicia una excepción DivideByZeroException.For the operands of the decimal type, arithmetic overflow always throws an OverflowException and division by zero always throws a DivideByZeroException.

Errores de redondeoRound-off errors

Debido a las limitaciones generales de la representación de punto flotante de los números reales y la aritmética de punto flotante, en los cálculos con tipos de punto flotante se pueden producir errores de redondeo.Because of general limitations of the floating-point representation of real numbers and floating-point arithmetic, the round-off errors might occur in calculations with floating-point types. Es decir, es posible que el resultado de una expresión difiera del resultado matemático esperado.That is, the produced result of an expression might differ from the expected mathematical result. En el ejemplo siguiente se muestran varios de estos casos:The following example demonstrates several such cases:

Console.WriteLine(.41f % .2f); // output: 0.00999999

double a = 0.1;
double b = 3 * a;
Console.WriteLine(b == 0.3);   // output: False
Console.WriteLine(b - 0.3);    // output: 5.55111512312578E-17

decimal c = 1 / 3.0m;
decimal d = 3 * c;
Console.WriteLine(d == 1.0m);  // output: False
Console.WriteLine(d);          // output: 0.9999999999999999999999999999

Para obtener más información, vea los comentarios en las páginas de referencia de System.Double, System.Single o System.Decimal.For more information, see remarks at System.Double, System.Single, or System.Decimal reference pages.

Posibilidad de sobrecarga del operadorOperator overloadability

Un tipo definido por el usuario puede sobrecargar los operadores unarios (++, --, + y -), los operadores binarios (*, /, %, + y -) y los operadores aritméticos.A user-defined type can overload the unary (++, --, +, and -) and binary (*, /, %, +, and -) arithmetic operators. Cuando se sobrecarga un operador binario, también se sobrecarga de forma implícita el operador de asignación compuesta correspondiente.When a binary operator is overloaded, the corresponding compound assignment operator is also implicitly overloaded. Un tipo definido por el usuario no puede sobrecargar de forma explícita un operador de asignación compuesta.A user-defined type cannot explicitly overload a compound assignment operator.

Especificación del lenguaje C#C# language specification

Para más información, vea las secciones siguientes de la Especificación del lenguaje C#:For more information, see the following sections of the C# language specification:

Vea tambiénSee also