<?xml version="1.0"?>
<clause number="14.7.5" title="Subtraction operator">
  <paragraph>For an operation of the form x  -y, binary operator overload resolution (<hyperlink>14.2.4</hyperlink>) 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. </paragraph>
  <paragraph>The predefined subtraction operators are listed below. The operators all subtract y from x. <list><list_item> Integer subtraction: <code_example><![CDATA[
int operator -(int x, int y);  
uint operator -(uint x, uint y);  
long operator -(long x, long y);  
ulong operator -(ulong x, ulong y);  
]]></code_example>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. </list_item><list_item> Floating-point subtraction: <code_example><![CDATA[
float operator -(float x, float y);  
double operator -(double x, double y);  
]]></code_example>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 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. <table_line>y +0 <unicode>150</unicode>0 +<infinity/> <unicode>150</unicode><infinity/> NaN </table_line>
<table_line>x z x x <unicode>150</unicode><infinity/> +<infinity/> NaN </table_line>
<table_line>+0 <unicode>150</unicode>y +0 +0 <unicode>150</unicode><infinity/> +<infinity/> NaN </table_line>
<table_line><unicode>150</unicode>0 <unicode>150</unicode>y <unicode>150</unicode>0 +0 <unicode>150</unicode><infinity/> +<infinity/> NaN </table_line>
<table_line>+<infinity/> +<infinity/> +<infinity/> +<infinity/> NaN +<infinity/> NaN </table_line>
<table_line><unicode>150</unicode><infinity/><unicode>150</unicode><infinity/><unicode>150</unicode><infinity/><unicode>150</unicode><infinity/><unicode>150</unicode><infinity/> NaN NaN </table_line>
<table_line>NaN NaN NaN NaN NaN NaN NaN </table_line>
</list_item><list_item> Decimal subtraction: <code_example><![CDATA[
decimal operator {UNICODE_150}(decimal x, decimal y);  
]]></code_example>If the resulting value is too large to represent in the <keyword>decimal</keyword> 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. </list_item><list_item> 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: <code_example><![CDATA[
U operator -(E x, E y);  
]]></code_example>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. <code_example><![CDATA[
E operator -(E x, U y);  
]]></code_example>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. </list_item><list_item> Delegate removal. Every delegate type implicitly provides the following predefined operator, where D is the delegate type: <code_example><![CDATA[
D operator -(D x, D y);  
]]></code_example>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 (<hyperlink>22.1</hyperlink>) 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 (<hyperlink>14.9.8</hyperlink>).) 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>[Example: For example: <code_example><![CDATA[
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  
   }  
}  
]]></code_example>end example]</example> </list_item></list></paragraph>
</clause>
