【SpinalHDL】Scala编程中的class及case class-EW帮帮网

本篇文章仅简单介绍在spinalhdl编程中遇到的比较常见的2中类定义方式：class及case class。对于不太了解JAVA或Scala编码又开始学习SpinalHDL的人进行入门介绍。

在 SpinalHDL 中，case class 和 class 都是用来定义数据结构或对象的关键字，它们在某些方面相似，但也有一些显著的差异。

1.概念概述

1.1 相同点

都可以用来定义数据结构：case class 和 class 都可以用来创建自定义的数据类型。
都可以定义属性和函数：无论是 case class 还是 class 都可以包含属性和函数。

1.2 差异点

模式匹配：case class 通常用于模式匹配，它们自动为模式匹配生成unapply函数。而class则需要手动编写相应的匹配函数。
默认的equals和hashCode函数：case class 自动生成了 equals 和 hashCode 函数，这使得它们在比较对象时更方便。而对于 class，需要手动实现这些函数。
可变性：case class 中的属性默认是不可变的（immutable），而 class 中的属性可以是可变的（mutable）。
复制：case class 提供了 copy 函数，可以轻松地创建对象的副本并修改其中的属性，而 class 则需要手动编写相应的复制函数。
默认构造器参数：在 case class 中，构造函数的参数默认是 val，而在 class 中，默认是 var。

2.使用技巧

选择合适的情境：根据需求选择合适的关键字。如果需要简单的数据传输对象或者模式匹配，可以使用 case class。如果需要更多的控制和灵活性，可以使用 class。
利用模式匹配：在需要对对象进行模式匹配的场景下，选择使用 case class，这样可以更轻松地编写模式匹配代码。
不可变性：在可能的情况下，推荐使用不可变的数据结构，因为它们更容易理解和维护，并且更安全。
重载equals和hashCode函数：如果需要在 class 中实现自定义的对象比较逻辑，记得重载 equals 和 hashCode 函数。
利用copy函数：如果需要在不修改原始对象的情况下创建对象的副本并进行修改，可以使用 case class 提供的 copy 函数。

3.case class独特函数

3.1 equals/hashCode函数

在 SpinalHDL 中，case class 自动生成的 equals 和 hashCode 函数遵循以下规则：

equals 函数：自动生成的 equals 函数会比较两个对象的所有属性是否相等。
hashCode 函数：自动生成的 hashCode 函数会基于对象的所有属性计算出一个哈希值。

这样设计的目的是为了确保当两个 case class 的对象具有相同的属性值时，它们的 equals 函数返回 true，并且它们的 hashCode 函数返回的哈希值也相同。

以下是一个详细的例子，假设我们有一个简单的 case class 表示一个二维点：

case class Point(x: Int, y: Int)

对于这个 Point 类，SpinalHDL 会自动生成 equals 和 hashCode 函数。下面是它们的实现：

override def equals(obj: Any): Boolean = obj match {
  case other: Point => this.x == other.x && this.y == other.y
  case _ => false
}

override def hashCode: Int = {
  val prime = 31
  var result = 1
  result = prime * result + x
  result = prime * result + y
  result
}

这里的 equals 函数比较了两个 Point 对象的 x 和 y 属性是否相等，而 hashCode 函数则基于 x 和 y 属性计算出一个哈希值。下面是一个示例演示如何使用这个 Point 类及其自动生成的 equals 和 hashCode 函数：

val point1 = Point(3, 4)
val point2 = Point(3, 4)
val point3 = Point(5, 6)

println(point1 == point2)  // 输出 true，因为 point1 和 point2 的属性值相等
println(point1 == point3)  // 输出 false，因为 point1 和 point3 的属性值不相等

val map = Map(point1 -> "A", point2 -> "B")
println(map(point1))  // 输出 "A"，因为 point1 和 point2 被视为相等的键
println(map(point2))  // 输出 "B"，因为 point1 和 point2 被视为相等的键
println(map(point3))  // 抛出 NoSuchElementException，因为 point3 不在 map 中

在这个示例中，我们创建了两个 Point 对象 point1 和 point2，它们的属性值相同，因此它们的 equals 函数返回 true。然后我们将这两个对象作为键存储在一个 Map 中，并成功地使用它们来检索相应的值。

3.2 copy 函数

在 SpinalHDL 中，case class 提供了一个 copy 函数，用于创建对象的副本并修改其中的属性。这个函数使得我们可以在不修改原始对象的情况下，方便地创建新的对象并修改其中的属性。
下面是 copy 函数的语法：

def copy(...): ThisType

其中，ThisType 是 case class 的类型。
以下是一个示例说明如何使用 case class 的 copy 函数：
假设我们有一个简单的 case class 表示一个二维点：

case class Point(x: Int, y: Int)

现在我们创建一个 Point 对象，然后我们使用 copy 函数创建一个新的 Point 对象，并修改其中的属性：

val originalPoint = Point(3, 4)
val modifiedPoint = originalPoint.copy(x = 5, y = 6)

在这个例子中，originalPoint.copy(x = 5, y = 6) 创建了一个新的 Point 对象，其 x 属性被修改为 5，y 属性被修改为 6。原始的 originalPoint 对象保持不变。
我们也可以只修改其中的部分属性，而不是全部属性。例如，我们可以只修改 x 属性，而保持 y 属性不变：

val modifiedX = originalPoint.copy(x = 10)

这个例子中，originalPoint.copy(x = 10) 创建了一个新的 Point 对象，其 x 属性被修改为 10，而 y 属性保持不变。
通过 copy 函数，我们可以方便地创建对象的副本并修改其中的属性，而不需要手动重复构造对象的其他部分。这使得代码更加简洁和易于维护。

4.使用场景

4.1 case class 场景

1.数据传输对象（DTO）：当需要表示简单的数据结构或数据传输对象时，通常使用 case class 更合适。例如，表示一个寄存器的配置参数或一个数据包的头部信息等。

case class RegisterConfig(address: Int, width: Int)

2.模式匹配：如果需要在模式匹配中使用对象，并且希望能够方便地提取对象的属性值，推荐使用 case class。因为它们自动生成了 unapply 函数，可以轻松地进行模式匹配。

val config = RegisterConfig(0x1000, 32)
config match {
  case RegisterConfig(addr, width) => println(s"Address: $addr, Width: $width")
  case _ => println("Unknown configuration")
}

3.不可变性：如果需要创建不可变的数据结构，即对象创建后不可修改其属性值，建议使用 case class。因为 case class 的属性默认是不可变的。

4.2 class 场景

1.需要可变性：如果需要创建可变的数据结构，即对象创建后可以修改其属性值，推荐使用 class。因为 class 的属性可以是可变的。

class Counter(var value: Int) {
  def increment(): Unit = value += 1
}

2.更多的控制和灵活性：如果需要更多的控制和灵活性，例如自定义 equals 和 hashCode 函数、手动实现复制函数等，建议使用 class。因为在 class 中这些行为需要手动实现，可以更灵活地控制。

class Person(name: String, age: Int) {
  // Custom equals method
  override def equals(obj: Any): Boolean = obj match {
    case other: Person => this.name == other.name && this.age == other.age
    case _ => false
  }
  // Custom hashCode method
  override def hashCode(): Int = {
    val prime = 31
    var result = 1
    result = prime * result + name.hashCode
    result = prime * result + age
    result
  }
  // Manual copy method
  def copy(name: String = this.name, age: Int = this.age): Person = new Person(name, age)
}

3.需要继承：如果需要创建可继承的类层次结构，即定义一个基类，并创建多个子类来扩展其功能，建议使用 class。因为 class 支持继承，可以更灵活地构建类的层次结构。

class Shape(var color: String) {
  def draw(): Unit = println(s"Drawing a $color shape")
}
class Circle(color: String, var radius: Double) extends Shape(color) {
  override def draw(): Unit = println(s"Drawing a $color circle with radius $radius")
}
val circle = new Circle("red", 5.0)

综上所述，根据具体的需求和场景选择合适的关键字是很重要的，这样可以使代码更加清晰、易于理解和维护。

5.类例化

5.1 case class 实例化

1.不需要使用 new 关键字：在实例化 case class 时，不需要使用 new 关键字。可以直接使用类名和参数列表来创建对象。

case class Point(x: Int, y: Int)
val point = Point(3, 4) // 实例化一个 Point 对象，无需使用 new 关键字

2.参数列表可以省略括号：如果 case class 的构造函数没有参数，可以省略括号。

case class EmptyClass()
val empty = EmptyClass  // 无需括号

3.自动生成的函数：case class 自动生成了一个伴生对象，并在其中定义了一个 apply及unapply函数，用于创建对象。这样使得可以直接使用类名和参数列表来创建对象，就像调用一个工厂函数一样。

5.2 class 实例化

1.需要使用 new 关键字：在实例化 class 时，需要使用 new 关键字。

class Point(var x: Int, var y: Int)
val point = new Point(3, 4)  // 使用 new 关键字实例化 Point 对象

2.参数列表不能省略括号：无论构造函数是否有参数，都需要使用括号来表示构造对象时传递的参数。

class EmptyClass()
val empty = new EmptyClass()  // 需要括号

3.没有自动生成的 apply 函数：class 没有自动生成的伴生对象和 apply 函数，因此无法像 case class 那样使用类名和参数列表来创建对象。
总的来说，case class 在实例化时更简洁和方便，而 class 则需要使用 new 关键字，并且不能像 case class 那样省略括号。

6. apply及unapply函数

6.1 unapply函数

unapply 函数是 case class 自动生成的一个伴生对象函数，用于在模式匹配中提取对象的属性值。它的主要作用是将对象的属性值提取出来，并将其作为元组返回。
例如，对于一个简单的 case class 定义：

case class Person(name: String, age: Int)

Person 类的伴生对象会自动生成一个 unapply 函数，其定义类似于：

object Person {
  def unapply(person: Person): Option[(String, Int)] = 
    Some(person.name, person.age)
}

在模式匹配中，可以使用 unapply 函数提取 Person 对象的属性值：

val person = Person("Alice", 30)
person match {
  case Person(name, age) => println(s"Name: $name, Age: $age")
  case _ => println("Unknown person")
}

在这个例子中，unapply 函数将 Person 对象的 name 和 age 属性值提取出来，并作为元组返回，然后在模式匹配中被成功地匹配。

6.2 apply函数

与 unapply 函数不同，apply 函数是用于创建对象的，而不是用于模式匹配。case class 会自动生成一个伴生对象，并在其中定义了一个 apply 函数，用于创建对象。

val person = Person.apply("Alice", 30) // 使用 apply 方法创建 Person 对象

因此，在 case class 中，apply 函数是用于创建对象的，而 unapply 函数是用于模式匹配的。

【SpinalHDL】Scala编程中的class及case class