枚举vs不可变D [英] enum vs immutable in D

问题描述

 枚举i = 2有什么区别？ 
 enum s =Hello; 
  

和

  immutable i = 2; 
 immutable s =Hello; 
  

在D 2.0？

解决方案

枚举是用户定义的类型，而不是变量。 枚举e = 2; 是一个
短的东西像这样的枚举：int {e = 2} （即一个匿名
枚举一个成员 e ），请参见文档。
根据定义，匿名枚举的所有成员将被放置到当前的
范围中。因此， e 是放置在当前作用域中的类型成员，其行为为
，如 literal 。另一方面，
immutable i = 2; 实际上创建一个变量 i 类型为int

这种差异有以下几个后果：

• 枚举e 将没有内存位置，没有地址（不是左值），因为
  既不是类型也不是其成员有地址。即你不能像 auto ptr =& e; （就像你不能做 auto ptr =& 2; ）。 immutable
i 另一方面是一个正常的变量（只是不可变的）。


• 所讨论的，
  可变变量可以在编译时或运行时初始化，
  ，而
  编译时必须知道一个类型（其所有成员定义类型）。


• 编译器可以简单地替换所有出现的 e 与 2 。对于我它
  通常必须创建一个内存位置（尽管优化编译器
  可能有时可以避免这种情况）。因此，对于枚举的
  编译期间的工作负载可能会稍低一点，而
  二进制值稍微小些。


• 数组有一个惊人的区别。对于枚举uint [2] E = [0，1]; 和
  immutable uint [2] I = [0，1] ; 访问枚举，例如 E [0] ，可以
  比 immutable 数组的数量级更慢。 I [0] ，
  特别是数组 E 和 code>变大。这是因为对于
immutable 数组，它只是一个正常的数组查找，例如一个全局
变量。对于枚举，但是它看起来像在数组被使用之前每
创建一个数组。在一个全局枚举的函数内部（不要
问我，为什么，但是编译器真的似乎只是用
替换外观在这种情况下也是如此）。我从来没有尝试，但会猜测
同样适用于枚举字符串和其他非平凡类型。



总结一下：当我使用编译时常量时，通常会采用枚举，除非
这些常量是数组或我需要一个内存位置，其他原因。

What's the difference between

enum i = 2;
enum s = "Hello";

and

immutable i = 2;
immutable s = "Hello";

in D 2.0?

解决方案

An enum is a user-defined type, not a variable. enum e = 2; is a short-hand for something like this enum : int { e = 2 } (i.e. an anonymous enum with one member e), see the documentation. By definition, all members of an anonymous enum are placed into the current scope. So, e is a type member placed into the current scope, where it behaves like a literal. immutable i = 2; on the other hand actually creates a variable i of type int.

This difference has a couple of consequences:

• enum e will have no memory location and no address (is no lvalue), since neither a type nor its members have an address. I.e. you cannot do something like auto ptr = &e; (just like you cannot do auto ptr = &2;). immutable i on the other hand is a normal variable (just immutable).
• As discussed by Jonathan, immutable variables can be initialized at compile time or at run-time, whereas a type (with all its members defining the type) must be known at compile time.
• The compiler can simply replace all appearances of e with 2. For i it usually has to create a memory location (although an optimizing compiler might be able to avoid this sometimes). For this reason, the workload during compilation for an enum might be expected to be somewhat lower, and the binary somewhat smaller.
• There is a surprising difference for arrays. For enum uint[2] E = [0, 1]; and immutable uint[2] I = [0, 1]; the access to the enum, e.g. E[0], can be orders of magnitude slower than for the immutable array, e.g. I[0], especially as the arrays E and I get bigger. This is so because for an immutable array, it is just a normal array lookup to, say, a global variable. For the enum however it looks like the array gets created every time before it gets used, e.g. inside a function for a global enum (don't ask me, why, but the compiler really seems to simply replace the appearance with the value in this case, too). I have never tried but would guess that the same applies to enum strings and other non-trivial types.

To sum up: when I use compile-time constants, I usually take enum unless those constants are arrays or I need a memory location for some other reason.

这篇关于枚举vs不可变D的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！