枚举加法与减法和转换

发布于 2024-11-27 05:46:55 字数 340 浏览 3 评论 0原文

为什么加法需要强制转换而减法无需强制转换就可以工作？请参阅下面的代码以了解我要问的内容

public enum Stuff
{
    A = 1,
    B = 2,
    C = 3
}

var resultSub = Stuff.A - Stuff.B; // Compiles
var resultAdd = Stuff.A + Stuff.B; // Does not compile
var resultAdd2 = (int)Stuff.A + Stuff.B; // Compiles

注意：对于加法和减法，在上面的所有三个示例中，结果是否超出（枚举）范围并不重要。

原文

Why does addition require a cast but subtraction works without a cast? See the code below to understand what I am asking

public enum Stuff
{
    A = 1,
    B = 2,
    C = 3
}

var resultSub = Stuff.A - Stuff.B; // Compiles
var resultAdd = Stuff.A + Stuff.B; // Does not compile
var resultAdd2 = (int)Stuff.A + Stuff.B; // Compiles

note: For both addition and subtraction it does not matter whether result is out of range (of the enum) or not in all three examples above.

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

泼猴你往哪里跑 2024-12-04 05:46:55

好问题 - 我很惊讶第一行和第三行有效。

然而，它们在 C# 语言规范中得到支持 - 在第 7.8.4 节中，它讨论了枚举添加：

每个枚举类型都隐式提供以下预定义运算符，其中 E 是枚举类型，U 是 E 的基础类型：
E 运算符 +(E x, U y)
E 运算符 +(U x, E y)
在运行时，这些运算符的计算方式完全为 (E)((U)x + (U)y)

在第 7.8.5 节中：

每个枚举类型都隐式提供以下预定义运算符，其中 E 是枚举类型，U 是 E 的基础类型：
U 运算符 -(E x, E y)
该运算符的计算方式与(U)((U)x - (U)y))完全相同。换句话说，该运算符计算 x 和 y 的序数值之间的差，结果的类型是枚举的基础类型。
E 运算符 -(E x, U y);
该运算符的计算方式与(E)((U)x - y)完全相同。换句话说，该运算符从枚举的基础类型中减去一个值，产生一个枚举值。

这就是为什么编译器会有这样的行为 - 因为这是 C# 规范所说的:)

我不知道这些运算符的存在，而且我从来没有故意看到它们被使用过。我怀疑它们存在的原因埋藏在 Eric Lippert 偶尔深入研究的语言设计会议笔记中的某个地方 - 但如果他们因为添加功能而没有带来什么好处而感到遗憾，我也不会感到惊讶。话又说回来，也许它们在某些情况下确实很有用:)

Good question - I was surprised that the first and third lines worked.

However, they are supported in the C# language specification - in section 7.8.4, it talks about enumeration addition:

Every enumeration type implicitly provides the following pre-defined 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)
At runtime, these operators are ealuated exactly as (E)((U)x + (U)y)

And in section 7.8.5:

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

So that's why the compiler behaves like that - because it's what the C# spec says to do :)

I wasn't aware that any of these operators exist, and I've never knowingly seen them used. I suspect the reasons for their existence are buried somewhere in the language design meeting notes that Eric Lippert occasionally dives into - but I also wouldn't be surprised if they were regretted as adding features for little benefit. Then again, maybe they're really useful in some situations :)

回复收藏 0 原文