为什么 scala 没有类似 C++ 的 const 语义？

Question

在C++中。我可以将大多数东西声明为 const，例如：
变量：const int i=5;
Scala 有 val i=5，但这只会阻止重新分配，而不会更改对象，如以下示例所示：
C++：

const int i[]={1,2,3,4};
i[2]=5; //error

Scala:

val a=Array(1,2,3,4)
a(2)=5 //a is now Array(1, 2, 5, 4)

成员函数的情况会变得更糟：
C++：

class Foo {
int i;
int iPlusFive() const {return i+5;}
int incrementI(){ return ++i; }
}

I can be sure, that calling iPlusFive won't change the object and that I won't accidentally call incrementI on a const object.

当谈到集合时，C++ 延续了 const 集合的 const 正确性：只需将向量声明为 const 并且无法更改它。将非常量向量分配给const向量，编译器不会复制任何内容，并且会阻止您更改当前const集合中的任何内容。

Scala 有 scala.collection.mutable.whatever 和 scala.collection.immutable.whatever，你不能仅仅将可变集合转换为不可变集合，而且你仍然可以使用它们的非常量成员函数来更改收集的对象。

为什么 scala 拥有一个非常棒的类型系统，却没有任何与 C++ const 关键字相媲美的东西？

编辑： Margus 建议使用import scala.collection.mutable。 我的解决方案是使用

import scala.collection.mutable.HashMap
import scala.collection.immutable.{HashMap => ConstHashMap}

This will make the mutable HashMap available as HashMap and the immutable als ConstHashMap, however I still like the C++ approach better.

Answer 1

我不喜欢 C++ const 逻辑的一点是它与引用有关，而不是与被引用的对象有关。如果我有一个“const T *”，则不能保证持有非常量指针的人不会修改该对象的状态。因此，它无助于避免多线程系统中的竞争条件，也无助于实现持久性容器。

在我看来，拥有不可变类的概念非常有帮助，并且标准库中缺乏不可变容器在任何语言中都是一个错误。由于这些应该表现出可观察的不变性，但出于效率原因可能需要能够改变内部/不可见状态，我认为 const 语法没有什么帮助。

Scala 具有我们需要直接使用或基于其他不可变类的不可变类。这是非常有价值的。额外的语法可能是一个很好的补充，但我可以没有它。

Answer 2

因为 C++ const 在复杂系统中并不是那么好。

我可以确定，调用 iPlusFive 不会更改对象，并且我不会意外地对 const 对象调用incrementI。

不，你不能，因为实现（可能在某个看不见的库中）可以消除常量。如果没有 const，其他语言必须以更安全的方式强制执行不变性（例如，请参阅 @Margus 的答案中的 Collections.unmodifyingList() ）。

Const 只是编译器读取的文档。文档通常很有帮助，但有时会产生误导。

当涉及到集合时，C++ 继续使用 const 集合来保持 const 正确性：只需将向量声明为 const，并且无法更改它。

对我来说，聚合是 const 经常失败的地方。例如，我经常想声明一个方法不会更改向量，但可能会更改它的成员（或返回非常量成员引用）。我必须将其全部设为常量或全部非常量，或者为每种组合发明新的类型变体。

“可变”弥补了一些聚合问题，但引入了更多的复杂性和误用。

Answer 3

在我看来，Scala 只是提供了更大的灵活性，不会将引用的不变性与其背后结构的[可能的]可变性混合在一起，使您能够根据正在处理的问题做出设计决策。

Answer 4

_{所有 Scala 代码都转换为 Java 代码，这就是我用 Java 制作示例的原因。}

这是如何在 Java 中执行此操作：

    Integer x[] = new Integer[]{1,2,3,4}; 
    final List<Integer> CONST = Collections.unmodifiableList(Arrays.asList(x));

那么您问发生了什么？ CONST 距离实际数组只有 1 步，它可以隐藏实际数组和 Collection 元素，如果使用简单数组，这是不可能的。如果您仍然想修改常量集合，则需要复制它并进行修改。

来源：链接

具有不可修改内容的数组？

Java没有提供a的概念
const 数组：即一个数组
可以交换为新数组（在 C++ 中
术语，“指针可以修改”），
但其元素不能改变。
但是，如果您需要这个
功能，解决方案是
一般来说很像提供
对任何其他对象的只读访问
如下所述。所以有几个
可能性是：

• 您可以通过将列表传递给来创建不可修改的列表
  Collections.unmodifyingList() （尽管
  在这种情况下，变量将是
  声明为 List 类型，而不是类型
  将其标记为“不可修改”——如
  下面讨论，任何修改尝试
  它会在运行时被发现）；
• 您可以围绕私有数组创建一个包装对象，并提供
  公共方法可以读但不能写
  它的元素；
• 您可以使用只读 IntBuffer（或 FloatBuffer 等）：...

来源： Java 等效项 - const 从 C++ 的角度来看。

因此 Scala 的等效项是：

    val A = Set(1, 2, 3, 4)

    val A = List(1, 2, 3, 4)

这应该翻译为：

    scala.collection.immutable.List[java.lang.Integer] A = List(1, 2, 3, 4)

这可以解释我对 IttayD 评论的回应，为什么 java 6 与 c++ 编译器不同：

具体化泛型

目前，泛型已实现
使用擦除，这意味着
泛型类型信息不是
在运行时可用，这使得一些
一种很难写的代码。泛型
以这种方式实施以支持
向后兼容旧版本
非通用代码。具体化泛型
将使泛型类型
运行时可用的信息，
这将打破传统的非通用
代码。然而，尼尔·加夫特
提议仅使类型具体化
如果指定，以免破坏
向后兼容性。

资料来源：链接

说起来很愚蠢，但 Java 常量命名约定是使用大写字母表示变量。其他阅读您代码的人会立即知道标识符是一个固定的常量值，无法更改。

来源：链接

...您不能只是将可变集合转换为不可变集合，...

如果您想同时使用集合的可变版本和不可变版本，一个有用的约定是仅导入包 collection.mutable。

import scala.collection.mutable

来源： Scala Collection API

不确定你的意思转换，但你可能可以这样做：

val a = scala.collection.mutable.List[Int](1, 2, 3)
val A = scala.collection.immutable.List[Int](a.toArray())