14.2.2 Operator overloading

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

All unary and binary operators have predefined implementations that are

automatically available in any

expression. In addition to the predefined implementations, user-defined

implementations can be introduced

by including operator declarations in classes and structs (?7.9).

User-defined operator implementations

always take precedence over predefined operator implementations: Only when

no applicable user-defined

operator implementations exist will the predefined operator implementations

be considered, as described in

?4.2.3 and ?4.2.4.

The overloadable unary operators are:

+ - ! ~ ++ -- true false

[Note: Although true and false are not used explicitly in expressions (and

therefore are not included in

the precedence table in ?4.2.1), they are considered operators because

they are invoked in several

expression contexts: boolean expressions (?4.16) and expressions involving

the conditional (?4.12), and

conditional logical operators (?4.11). end note]

The overloadable binary operators are:

+ - * / % & | ^ << >> == != > < >= <=

Only the operators listed above can be overloaded. In particular, it is not

possible to overload member

access, method invocation, or the =, &&, ||, ?:, checked, unchecked, new,

typeof, as, and

is operators.

When a binary operator is overloaded, the corresponding assignment

operator, if any, is also implicitly

overloaded. [Example: For example, an overload of operator * is also an

overload of operator *=. This is

described further in ?4.13. end example] The assignment operator itself

(=) cannot be overloaded. An

assignment always performs a simple bit-wise copy of a value into a

variable.

Cast operations, such as (T)x, are overloaded by providing user-defined

conversions (?3.4).

Element access, such as a[x], is not considered an overloadable operator.

Instead, user-defined indexing is

supported through indexers (?7.8).

In expressions, operators are referenced using operator notation, and in

declarations, operators are referenced

using functional notation. The following table shows the relationship

between operator and functional

notations for unary and binary operators. In the first entry, op denotes

any overloadable unary prefix

operator. In the second entry, op denotes the unary postfix ++ and --

operators. In the third entry, op

denotes any overloadable binary operator. [Note: For an example of

overloading the ++ and -- operators see

?7.9.1. end note]

Operator notation Functional notation

op x operator op(x)

x op operator op(x)

x op y operator op(x, y)

User-defined operator declarations always require at least one of the

parameters to be of the class or struct

type that contains the operator declaration. [Note: Thus, it is not

possible for a user-defined operator to have

the same signature as a predefined operator. end note]

User-defined operator declarations cannot modify the syntax, precedence, or

associativity of an operator.

[Example: For example, the / operator is always a binary operator, always

has the precedence level

specified in ?4.2.1, and is always left-associative. end example]

[Note: While it is possible for a user-defined operator to perform any

computation it pleases,

implementations that produce results other than those that are intuitively

expected are strongly discouraged.

For example, an implementation of operator == should compare the two

operands for equality and return

an appropriate bool result. end note]

The descriptions of individual operators in ?4.5 through ?4.13 specify

the predefined implementations of

the operators and any additional rules that apply to each operator. The

descriptions make use of the terms

unary operator overload resolution, binary operator overload resolution,

and numeric promotion,

definitions of which are found in the following sections.

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