相关常数

你可以定义具有“关联函数”的 traits, structs, enums ：

1. struct Struct;

3. impl Struct {
4. fn foo() {
5. println!("foo is an associated function of Struct");
6. }
7. }

9. fn main() {
10. Struct::foo();
11. }

这个叫做“关联函数”，因为它关联了相关的类型，也就是说，它们附加到类型本身，而不是任何特定的实例。

Rust 1.20 中为关联函数增加了新的功能：

1. struct Struct;

3. impl Struct {
4. const ID: u32 = 0;
5. }

7. fn main() {
8. println!("the ID of Struct is: {}", Struct::ID);
9. }

其中，常量 ID 关联到 Struct 上，如果函数一样，关联常量也可以工作在 trait 和 enum 上。

Trait 具有额外的能力和相关的常数，为他们提供额外的力量。使用特征，您可以像使用关联类型一样 使用关联常量： 通过声明它，但不给它一个值。然后，特征的实现者在实现时声明其值：

1. trait Trait {
2. const ID: u32;
3. }

5. struct Struct;

7. impl Trait for Struct {
8. const ID: u32 = 5;
9. }

11. fn main() {
12. println!("{}", Struct::ID);
13. }

在此功能之前，如果要创建表示浮点数的特征，则必须如下：

1. trait Float {
2. fn nan() -> Self;
3. fn infinity() -> Self;
4. // ...
5. }

这有点笨拙，但更重要的是，因为它们是函数，所以它们不能用于常量表达式，即使它们只返回常量。 因此，Float 的设计也必须包含常量：

1. mod f32 {
2. const NAN: f32 = 0.0f32 / 0.0f32;
3. const INFINITY: f32 = 1.0f32 / 0.0f32;

5. impl Float for f32 {
6. fn nan() -> Self {
7. f32::NAN
8. }
9. fn infinity() -> Self {
10. f32::INFINITY
11. }
12. }
13. }

关联常量让你可以更清晰的表达，如下：

1. trait Float {
2. const NAN: Self;
3. const INFINITY: Self;
4. // ...
5. }

继续实现如下：

1. mod f32 {
2. impl Float for f32 {
3. const NAN: f32 = 0.0f32 / 0.0f32;
4. const INFINITY: f32 = 1.0f32 / 0.0f32;
5. }
6. }

更加清晰，更通用。