14.7.5 Subtraction operator

王朝other·作者佚名  2006-03-10
窄屏简体版  字體: |||超大  

For an operation of the form x - y, binary operator overload resolution (?4.

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 outside the range of the result type 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 IEC 60559 arithmetic.

The following table lists the

results of all possible combinations of nonzero finite values, zeros,

infinities, and NaNs. 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 +8 -8 NaN

x z x x -8 +8 NaN

+0 -y +0 +0 -8 +8 NaN

-0 -y -0 +0 -8 +8 NaN

+8 +8 +8 +8 NaN +8 NaN

-8 -8 -8 -8 -8 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. The scale of the result, before any rounding, is the larger of

the scales of the two operands.

Decimal subtraction is equivalent to using the subtraction operator of type

System.Decimal.

?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.

C# LANGUAGE SPECIFICATION

162

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 both operands are of

some delegate type D. (If

the operands have different delegate types, a compile-time error occurs.)

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 (?2.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 (?4.9.8).) 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. [Example:

For example:

using System;

delegate void D(int x);

class Test

{

public static void M1(int i) { /* ? */ }

public static void M2(int i) { /* ? */ }

}

class Demo

{

static void Main() {

D cd1 = new D(Test.M1);

D cd2 = new D(Test.M2);

D cd3 = cd1 + cd2 + cd2 + cd1; // M1 + M2 + M2 + M1

cd3 -= cd1; // => M1 + M2 + M2

cd3 = cd1 + cd2 + cd2 + cd1; // M1 + M2 + M2 + M1

cd3 -= cd1 + cd2; // => M2 + M1

cd3 = cd1 + cd2 + cd2 + cd1; // M1 + M2 + M2 + M1

cd3 -= cd2 + cd2; // => M1 + M1

cd3 = cd1 + cd2 + cd2 + cd1; // M1 + M2 + M2 + M1

cd3 -= cd2 + cd1; // => M1 + M2

cd3 = cd1 + cd2 + cd2 + cd1; // M1 + M2 + M2 + M1

cd3 -= cd1 + cd1; // => M1 + M2 + M2 + M1

}

}

end example]

 
 
 
免责声明:本文为网络用户发布,其观点仅代表作者个人观点,与本站无关,本站仅提供信息存储服务。文中陈述内容未经本站证实,其真实性、完整性、及时性本站不作任何保证或承诺,请读者仅作参考,并请自行核实相关内容。
 
 
© 2005- 王朝網路 版權所有 導航