# 7.7.4 Addition operator

**Visual Studio .NET 2003**

For an operation of the form `x`

`+`

`y`

, binary operator overload resolution (Section 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 outside the range of the result type 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`

.

y | +0 | –0 | +∞ | –∞ | 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 |
NaN |

–∞ |
–8 |
–8 |
–8 |
NaN |
–8 |
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. The scale of the result, before any rounding, is the larger of the scales of the two operands.

Decimal addition is equivalent to using the addition operator of type `System.Decimal`

.

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

using System; class Test { static void Main() { string s = null; Console.WriteLine("s = >" + s + "<"); // displays s = >< int i = 1; Console.WriteLine("i = " + i); // displays i = 1 float f = 1.2300E+15F; Console.WriteLine("f = " + f); // displays f = 1.23+E15 decimal d = 2.900m; Console.WriteLine("d = " + d); // displays d = 2.900 } }

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 operands have different delegate types, a compile-time error occurs.) If the first operand is `null`

, the result of the operation is the value of the second operand (even if that 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. For examples of delegate combination, see Section 7.7.5 and Section 15.3. Since `System.Delegate`

is not a delegate type, `operator +`

is not defined for it.