14.13.2 Compound assignment

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

An operation of the form x op= y is processed by applying binary operator

overload resolution (?4.2.4) as

if the operation was written x op y. Then,

?If the return type of the selected operator is implicitly convertible to

the type of x, the operation is

evaluated as x = x op y, except that x is evaluated only once.

?Otherwise, if the selected operator is a predefined operator, if the

return type of the selected operator is

explicitly convertible to the type of x, and if y is implicitly convertible

to the type of x, then the

operation is evaluated as x = (T)(x op y), where T is the type of x, except

that x is evaluated only

once.

?Otherwise, the compound assignment is invalid, and a compile-time error

occurs.

The term ?evaluated only once? means that in the evaluation of x op y, the

results of any constituent

expressions of x are temporarily saved and then reused when performing the

assignment to x. [Example: For

example, in the assignment A()[B()] += C(), where A is a method returning

int[], and B and C are

methods returning int, the methods are invoked only once, in the order A,

B, C. end example]

When the left operand of a compound assignment is a property access or

indexer access, the property or

indexer must have both a get accessor and a set accessor. If this is not

the case, a compile-time error

occurs.

Chapter 14 Expressions

175

The second rule above permits x op= y to be evaluated as x = (T)(x op y) in

certain contexts. The rule

exists such that the predefined operators can be used as compound operators

when the left operand is of type

sbyte, byte, short, ushort, or char. Even when both arguments are of one of

those types, the

predefined operators produce a result of type int, as described in ?4.2.6.2.

Thus, without a cast it would

not be possible to assign the result to the left operand.

The intuitive effect of the rule for predefined operators is simply that x

op= y is permitted if both of

x op y and x = y are permitted. [Example: In the example

byte b = 0;

char ch = 抃0?

int i = 0;

b += 1; // Ok

b += 1000; // Error, b = 1000 not permitted

b += i; // Error, b = i not permitted

b += (byte)i; // Ok

ch += 1; // Error, ch = 1 not permitted

ch += (char)1; // Ok

the intuitive reason for each error is that a corresponding simple

assignment would also have been an error.

end example]

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