Scrigroup - Documente si articole

Username / Parola inexistente      

Home Documente Upload Resurse Alte limbi doc  
AccessAdobe photoshopAlgoritmiAutocadBaze de dateCC sharp
CalculatoareCorel drawDot netExcelFox proFrontpageHardware
HtmlInternetJavaLinuxMatlabMs dosPascal
PhpPower pointRetele calculatoareSqlTutorialsWebdesignWindows
WordXml


Arithmetic operators - Multiplication, Division, Addition

C sharp



+ Font mai mare | - Font mai mic



Arithmetic operators

The *, /, %, +, and - operators are called the arithmetic operators.



multiplicative-expression:
unary-expression
multiplicative-expression
* unary-expression
multiplicative-expression
/ unary-expression
multiplicative-expression
% unary-expression

additive-expression:
multiplicative-expression
additive-expression
+ multiplicative-expression
additive-expression
- multiplicative-expression

Multiplication operator

For an operation of the form x * y, binary operator overload resolution (7.2.4) is applied to select a specific operator implementation. The operands are converted to the parameter types of the selected operator, and the type of the result is the return type of the operator.

The predefined multiplication operators are listed below. The operators all compute the product of x and y.

Integer multiplication:

int operator *(int x, int y);
uint operator *(uint x, uint y);
long operator *(long x, long y);
ulong operator *(ulong x, ulong y);

In a checked context, if the product is outside the range of the result type, a System.OverflowException is thrown. In an unchecked context, overflows are not reported and any significant high-order bits of the result are discarded.

Floating-point multiplication:

float operator *(float x, float y);
double operator *(double x, double y);

The product is computed according to the rules of IEEE 754 arithmetic. The following table lists the results of all possible combinations of nonzero finite values, zeros, infinities, and NaN's. In the table, x and y are positive finite values. z is the result of x * y. If the result is too large for the destination type, z is infinity. If the result is too small for the destination type, z is zero.

+y

-y

+0

-0

+∞

-∞

NaN

+x

+z

-z

+0

-0

+∞

-∞

NaN

-x

-z

+z

-0

+0

-∞

+∞

NaN

+0

+0

-0

+0

-0

NaN

NaN

NaN

-0

-0

+0

-0

+0

NaN

NaN

NaN

+∞

+∞

-∞

NaN

NaN

+∞

-∞

NaN

-∞

-∞

+∞

NaN

NaN

-∞

+∞

NaN

NaN

NaN

NaN

NaN

NaN

NaN

NaN

NaN

Decimal multiplication:

decimal operator *(decimal x, decimal y);

If the resulting value is too large to represent in the decimal format, a System.OverflowException is thrown. If the result value is too small to represent in the decimal format, the result is zero.

Division operator

For an operation of the form x / y, binary operator overload resolution (7.2.4) is applied to select a specific operator implementation. The operands are converted to the parameter types of the selected operator, and the type of the result is the return type of the operator.

The predefined division operators are listed below. The operators all compute the quotient of x and y.

Integer division:

int operator /(int x, int y);
uint operator /(uint x, uint y);
long operator /(long x, long y);
ulong operator /(ulong x, ulong y);

If the value of the right operand is zero, a System.DivideByZeroException is thrown.

The division rounds the result towards zero, and the absolute value of the result is the largest possible integer that is less than the absolute value of the quotient of the two operands. The result is zero or positive when the two operands have the same sign and zero or negative when the two operands have opposite signs.

If the left operand is the maximum negative int or long and the right operand is -1, an overflow occurs. In a checked context, this causes a System.OverflowException to be thrown. In an unchecked context, the overflow is not reported and the result is instead the value of the left operand.

Floating-point division:

float operator /(float x, float y);
double operator /(double x, double y);

The quotient is computed according to the rules of IEEE 754 arithmetic. The following table lists the results of all possible combinations of nonzero finite values, zeros, infinities, and NaN's. In the table, x and y are positive finite values. z is the result of x / y. If the result is too large for the destination type, z is infinity. If the result is too small for the destination type, z is zero.

+y

-y

+0

-0

+∞

-∞

NaN

+x

+z



-z

+∞

-∞

+0

-0

NaN

-x

-z

+z

-∞

+∞

-0

+0

NaN

+0

+0

-0

NaN

NaN

+0

-0

NaN

-0

-0

+0

NaN

NaN

-0

+0

NaN

+∞

+∞

-∞

+∞

-∞

NaN

NaN

NaN

-∞

-∞

+∞

-∞

+∞

NaN

NaN

NaN

NaN

NaN

NaN

NaN

NaN

NaN

NaN

NaN

Decimal division:

decimal operator /(decimal x, decimal y);

If the value of the right operand is zero, a System.DivideByZeroException is thrown. If the resulting value is too large to represent in the decimal format, a System.OverflowException is thrown. If the result value is too small to represent in the decimal format, the result is zero.

Remainder operator

For an operation of the form x % y, binary operator overload resolution (7.2.4) is applied to select a specific operator implementation. The operands are converted to the parameter types of the selected operator, and the type of the result is the return type of the operator.

The predefined remainder operators are listed below. The operators all compute the remainder of the division between x and y.

Integer remainder:

int operator %(int x, int y);
uint operator %(uint x, uint y);
long operator %(long x, long y);
ulong operator %(ulong x, ulong y);

The result of x % y is the value produced by x - (x / y) * y. If y is zero, a System.DivideByZeroException is thrown. The remainder operator never causes an overflow.

Floating-point remainder:

float operator %(float x, float y);
double operator %(double x, double y);

The following table lists the results of all possible combinations of nonzero finite values, zeros, infinities, and NaN's. In the table, x and y are positive finite values. z is the result of x % y and is computed as x - n * y, where n is the largest possible integer that is less than or equal to x / y. This method of computing the remainder is analogous to that used for integer operands, but differs from the IEEE 754 definition (in which n is the integer closest to x / y).

+y

-y

+0

-0

+∞

-∞

NaN

+x

+z

+z

NaN

NaN

x

x

NaN

-x

-z

-z

NaN

NaN

-x

-x

NaN

+0

+0

+0

NaN



NaN

+0

+0

NaN

-0

-0

-0

NaN

NaN

-0

-0

NaN

+∞

NaN

NaN

NaN

NaN

NaN

NaN

NaN

-∞

NaN

NaN

NaN

NaN

NaN

NaN

NaN

NaN

NaN

NaN

NaN

NaN

NaN

NaN

NaN

Decimal remainder:

decimal operator %(decimal x, decimal y);

If the value of the right operand is zero, a System.DivideByZeroException is thrown. If the resulting value is too large to represent in the decimal format, a System.OverflowException is thrown. If the result value is too small to represent in the decimal format, the result is zero.

Addition operator

For an operation of the form x + y, binary operator overload resolution (7.2.4) is applied to select a specific operator implementation. The operands are converted to the parameter types of the selected operator, and the type of the result is the return type of the operator.

The predefined addition operators are listed below. For numeric and enumeration types, the predefined addition operators compute the sum of the two operands. When one or both operands are of type string, the predefined addition operators concatenate the string representation of the operands.

Integer addition:

int operator +(int x, int y);
uint operator +(uint x, uint y);
long operator +(long x, long y);
ulong operator +(ulong x, ulong y);

In a checked context, if the sum is outside the range of the result type, a System.OverflowException is thrown. In an unchecked context, overflows are not reported and any significant high-order bits of the result are discarded.

Floating-point addition:

float operator +(float x, float y);
double operator +(double x, double y);

The sum is computed according to the rules of IEEE 754 arithmetic. The following table lists the results of all possible combinations of nonzero finite values, zeros, infinities, and NaN's. In the table, x and y are nonzero finite values, and z is the result of x + y. If x and y have the same magnitude but opposite signs, z is positive zero. If x + y is too large to represent in the destination type, z is an infinity with the same sign as x + y. If x + y is too small to represent in the destination type, z is a zero with the same sign as x + y.

y

+0

-0

+∞

-∞

NaN

x

z

x

x

+∞

-∞

NaN

+0

y

+0

+0

+∞

-∞

NaN

-0

y

+0

-0

+∞

-∞

NaN

+∞

+∞

+∞

+∞

+∞

NaN

NaN

-∞

-∞

-∞

-∞

NaN

-∞

NaN

NaN

NaN

NaN

NaN



NaN

NaN

NaN

Decimal addition:

decimal operator +(decimal x, decimal y);

If the resulting value is too large to represent in the decimal format, a System.OverflowException is thrown. If the result value is too small to represent in the decimal format, the result is zero.

Enumeration addition. Every enumeration type implicitly provides the following predefined operators, where E is the enum type, and U is the underlying type of E:

E operator +(E x, U y);
E operator +(U x, E y);

The operators are evaluated exactly as (E)((U)x + (U)y).

String concatenation:

string operator +(string x, string y);
string operator +(string x, object y);
string operator +(object x, string y);

The binary + operator performs string concatenation when one or both operands are of type string. If an operand of string concatenation is null, an empty string is substituted. Otherwise, any non-string argument is converted to its string representation by invoking the virtual ToString() method inherited from type object. If ToString() returns null, an empty string is substituted.

The result of the string concatenation operator is a string that consists of the characters of the left operand followed by the characters of the right operand. The string concatenation operator never returns a null value. A System.OutOfMemoryException may be thrown if there is not enough memory available to allocate the resulting string.

Delegate combination. Every delegate type implicitly provides the following predefined operator, where D is the delegate type:

D operator +(D x, D y);

The binary + operator performs delegate combination when both operands are of some delegate type D. If the first operand is null, the result of the operation is the value of the second operand (even if that operand is also null). Otherwise, if the second operand is null, then the result of the operation is the value of the first operand. Otherwise, the result of the operation is a new delegate instance that, when invoked, invokes the first operand and then invokes the second operand.

Subtraction operator

For an operation of the form x - y, binary operator overload resolution (7.2.4) is applied to select a specific operator implementation. The operands are converted to the parameter types of the selected operator, and the type of the result is the return type of the operator.

The predefined subtraction operators are listed below. The operators all subtract y from x.

Integer subtraction:

int operator -(int x, int y);
uint operator -(uint x, uint y);
long operator -(long x, long y);
ulong operator -(ulong x, ulong y);

In a checked context, if the difference is outside the range of the result type, a System.OverflowException is thrown. In an unchecked context, overflows are not reported and any significant high-order bits of the result are discarded.

Floating-point subtraction:

float operator -(float x, float y);
double operator -(double x, double y);

The difference is computed according to the rules of IEEE 754 arithmetic. The following table lists the results of all possible combinations of nonzero finite values, zeros, infinities, and NaN's. In the table, x and y are nonzero finite values, and z is the result of x - y. If x and y are equal, z is positive zero. If x - y is too large to represent in the destination type, z is an infinity with the same sign as x - y. If x - y is too small to represent in the destination type, z is a zero with the same sign as x - y.

y

+0

-0

+∞

-∞

NaN

x

z

x

x

-∞

+∞

NaN

+0

-y

+0

+0

-∞

+∞

NaN

-0

-y

-0

+0

-∞

+∞

NaN

+∞

+∞

+∞

+∞

NaN

+∞

NaN

-∞

-∞

-∞

-∞

-∞

NaN

NaN

NaN

NaN

NaN

NaN

NaN

NaN

NaN

Decimal subtraction:

decimal operator -(decimal x, decimal y);

If the resulting value is too large to represent in the decimal format, a System.OverflowException is thrown. If the result value is too small to represent in the decimal format, the result is zero.

Enumeration subtraction. Every enumeration type implicitly provides the following predefined operator, where E is the enum type, and U is the underlying type of E:

U operator -(E x, E y);

This operator is evaluated exactly as (U)((U)x - (U)y). In other words, the operator computes the difference between the ordinal values of x and y, and the type of the result is the underlying type of the enumeration.

E operator -(E x, U y);

This operator is evaluated exactly as (E)((U)x - y). In other words, the operator subtracts a value from the underlying type of the enumeration, yielding a value of the enumeration.

Delegate removal. Every delegate type implicitly provides the following predefined operator, where D is the delegate type:

D operator -(D x, D y);

The binary - operator performs delegate removal when one or both operands are of a delegate type D. If the first operand is null, the result of the operation is null. Otherwise, if the second operand is null, then the result of the operation is the value of the first operand. Otherwise, both operands represent invocation lists (15.1) having one or more entries, and the result is a new invocation list consisting of the first operand's list with the second operand's entries removed from it, provided the second operand's list is a proper contiguous subset of the first's. (For determining subset equality, corresponding entries are compared as for the delegate equality operator.) Otherwise, the result is the value of the left operand. Neither of the operands' lists is changed in the process. If the second operand's list matches multiple subsets of contiguous entries in the first operand's list, the right-most matching subset of contiguous entries is removed. If removal results in an empty list, the result is null.

The example

delegate void D(int x);

class Test

public static void M2(int i)
}

class Demo

}shows a variety of delegate subtractions.





Politica de confidentialitate | Termeni si conditii de utilizare



DISTRIBUIE DOCUMENTUL

Comentarii


Vizualizari: 1084
Importanta: rank

Comenteaza documentul:

Te rugam sa te autentifici sau sa iti faci cont pentru a putea comenta

Creaza cont nou

Termeni si conditii de utilizare | Contact
© SCRIGROUP 2024 . All rights reserved