Generics 关于Scala泛型：找不到元素类型T的类清单

对于以下功能：

def reverse[T](a: Array[T]): Array[T] = {
    val b = new Array[T](a.length)
    for (i <- 0 until a.length)
        b(i) = a(a.length -i - 1)
    b
}

def reverse[T]（a:Array[T]）：Array[T]={
val b=新数组[T]（a.长度）
对于（i，只需将上下文绑定到方法声明：

def reverse[T : ClassManifest](a: Array[T]): Array[T] = ...

为了构造数组，必须在编译时知道数组的具体类型。该类型由编译器通过隐式类清单参数提供。也就是说，数组构造函数的签名实际上是

Array[T](size: Int)(implicit m: ClassManifest[T]): Array[T]

为了提供此参数，在调用数组构造函数时，作用域中必须有ClassManifest。因此，反向方法还必须采用隐式ClassManifest参数：

def reverse[T](a: Array[T])(implicit m: ClassManifest[T]): Array[T] = ...
// or equivalently
def reverse[T : ClassManifest](a: Array[T]): Array[T] = ...

使用[T:ClassManifest]时，后一种更简单的表示法称为。
如果在声明泛型类型参数时显示为不推荐使用[T:ClassTag]
，则以下方法有效：


（T:ClassManifest），但它在Scala2.11中显示为不推荐使用
（T:舱单）
（T:ClassTag），工作正常，看起来是一个完美的解决方案，因为编译器给出的错误是：
找不到元素类型T的类标记



可以在上下文绑定中使用
Manifest
而不是
ClassManifest
。有什么区别？好问题。我只是想弄清楚同样的事情：-）Manifest似乎是scala.reflect.Manifest的类型别名，ScalaDoc中没有记录它（可能是因为它的编译器魔力？）.出于这个原因，我倾向于选择ClassManifest，只是为了清楚起见。
ClassManifest
只要求编译器知道类型的类。
Manifest
要求编译器也知道它的所有类型参数。例如，For
List[String]
，前者只需要了解
List
，而后者需要
List[String]
。要创建Java数组，您只需要前者。ClassManifest vs Manifest问题已在
package com.github.sandip.adt

import scala.reflect.ClassTag

class QueueUsingArray[T](capacity: Int) {
  var array = new Array[T](capacity)

  private var front = -1
  private var rare = -1

  def enqueue(data: T) = {
    array(rare + 1) = data
    rare += 1
  }

  def dequeue: T = {
    front += 1
    array(front)
  }

  def isEmpty() = {
    !nonEmpty
  }

  def nonEmpty: Boolean = {
    rare > front
  }

}

object Main {
  def main(args: Array[String]): Unit = {
    val queue = new QueueUsingArray[Int](10)
    queue.enqueue(10)
    queue.enqueue(20)
    while (queue.nonEmpty) {
      println(queue.dequeue)
    }
  }
}