问题标签 [implicit-conversion]

Scala 2.8 规范在第 7.3 节中说（突出显示是我的）：

隐式参数和方法也可以定义称为视图的隐式转换。从类型 S 到类型 T 的视图由具有函数类型 S=>T 或 (=>S)=>T 的隐式值或可转换为该类型值的方法定义。视图适用于两种情况。

1. 如果表达式 e 的类型为 T，并且 T不符合表达式的预期类型 pt。在这种情况下，搜索适用于 e 并且其结果类型符合pt 的隐式 v。搜索与隐式参数的情况一样进行，其中隐式范围是 T => pt 之一。如果找到这样的视图，则表达式 e 将转换为 v(e)。

[...]

鉴于上述和以下事实：

1. Long不是 的子类型java.lang.Comparable[Long]，即不符合类型TwhereT <: java.lang.Comaparable[Long]
2. Predef包含implicit def longWrapper (x: Long) : RichLong
3. RichLong是 的子类型java.lang.Comparable[Long]，即符合类型TwhereT <: java.lang.Comaparable[Long]

我希望隐式转换应用于Long遇到的地方，并且需要一个子类型java.lang.Comparable[Long]。然而：

如果值被显式转换，结果与预期一致：

为什么不隐式应用转换函数？

我正在查看 LINQPad 中的一些代码高尔夫，想知道为什么：

主要是为什么第一个有效，而第二个会引发“'string'和'int'之间没有隐式转换”错误。

我有一个带有 INT 类型 ID 字段的表。

我正在做一些数据验证并注意到

和

完美运行，但如果我使用

它给了我同样的结果！这怎么可能？

第 6.1 节隐式转换因此定义了身份转换：

身份转换从任何类型转换为相同类型。这种转换的存在使得已经具有所需类型的实体可以说是可转换为该类型。

现在，这样的句子的目的是什么？

（在 §6.1.6 隐式引用转换中）

隐式引用转换是：

• [...]
• 从任何引用类型到引用类型 T，如果它具有到引用类型 T₀的隐式标识或引用转换，并且T₀具有到 的标识转换T。

和：

（在 §6.1.7 装箱转换中）

• 如果值类型具有到接口类型₀I的装箱转换并且₀具有到 的标识转换，则值类型具有到接口类型的装箱转换。III

最初它们似乎是多余的（同义词）。但他们一定是有目的的，所以他们为什么在那里？

您能否举一个T₁、T_{2两种类型的示例，如果}不是上面引用的段落，则T₁不会隐式转换为_2吗？T

尝试编译时出现以下错误：

Btree.scala:9：错误：找不到参数排序的隐式值：Ordering[K] 抽象类 Node[K,V] 扩展 TreeMap[K,V]

TreeMap 应该接受我提供的隐式 Ordering[A] val。也许隐式参数需要在实例化 Btree(TreeMap) 的对象 Tester 中？我更愿意将隐式声明保留在 Btree 类中，因为我希望 Ordering 有一个实现 Comparable[K] 的类型 K。说得通？

我刚刚遇到了这行代码：

哪里length2返回一个double。0.0 等于 0 NULL, 和/或让我有点困惑false。

这是 C++ 标准的一部分还是未定义的行为？

使用如下隐式运算符有什么问题吗：

我在想我可以以这种方式将对象的实例视为值类型，但是看到我从未见过这样的例子，我想也许有理由不做这样的事情，有人可以指出？

在我的实际代码中，我正在考虑将其作为数据抽象层的一部分，以便我可以返回带有描述底层数据的信息的对象，但允许逻辑代码在它需要知道的所有内容时将其视为值类型是值，同时使用泛型保持良好和类型安全。

为什么 Scala 不能优化以下内容：

一个。

至：

湾。

?

为什么在这种情况下必须使用结构类型？我希望 Scala 编译器执行此优化，因为以样式b编写太难看（因为，1. 逻辑的局部性丢失，2. 您必须为这些额外的显式类不必要地发明名称），并且a的性能要差得多比b。

我问的最后一个问题是我在试图理解另一件事时偶然发现的……我也无法理解（不是我的一天）。

这是一个很长的问题陈述，但至少我希望这个问题可能对很多人有用，而不仅仅是我。

我的代码如下：

表达式 1 和 3 完美运行，而表达式 2 无法编译。

如果我理解正确，会发生什么：

表达式 1

1. c isconst通过使用标准转换序列（仅包含一个限定转换）隐式转换为。
2. V<float>(const S<T> & s)被调用并且const V<float>对象生成的时间（我们称之为t）。它已经是 const 限定的，因为它是一个时间值。
3. a转换为 const 类似于c。
4. operator+(const V<float> & a, const V<float> & b)被调用，导致const V<float>我们可以称之为q的时间类型。
5. V<float>::operator=(const & V<float>)调用默认值。

我到这里还好吗？如果我犯了最细微的错误，请告诉我，因为我试图尽可能深入地了解隐式转换......

表达式 3

1. c转换为V<float>. 为此，我们有一个用户定义的转换序列：
   1.1。第一个标准转换：S<float>通过const S<float>资格转换。
   1.2. 用户定义的转换：const S<float>通过构造函数V<float>。 1.3 二级标准转换：通过资格转换。V<float>(const S<T> & s)
V<float>const V<float>
2. V<float>::operator=(const & V<float>)调用默认值。

表达式 2？

我不明白的是为什么第二个表达式有问题。为什么以下顺序是不可能的？

1. c转换为V<float>. 为此，我们有一个用户定义的转换序列：
   1.1。初始标准转换：S<float>到const S<float>通过资格转换。
   1.2. 用户定义的转换：const S<float>通过构造函数V<float>。 1.3. 最终标准转换：通过资格转换。 V<float>(const S<T> & s)
V<float>const V<float>
2. 步骤 2 到 6 与表达式 1 的情况相同。

在阅读了 C++ 标准之后，我：'嘿！也许问题与 13.3.3.1.2.3 有关！其中指出：

如果自定义转换由模板转换函数指定，则第二个标准转换序列必须具有精确匹配秩。

但事实并非如此，因为资格转换具有完全匹配的排名......

我真的一点头绪都没有...

好吧，不管你有没有答案，谢谢你阅读到这里:)

在广泛阅读ISO/IEC 14882 编程语言 – C++之后，我仍然不确定为什么const需要使用单个参数构造函数将隐式转换为用户定义的类型，如下所示

从第 4 节第 3 行开始

当且仅当声明 T t=e; 时，表达式 e 可以隐式转换为类型 T；对于一些发明的临时变量 t (8.5) 是良构的。某些语言结构要求将表达式转换为布尔值。出现在这种上下文中的表达式 e 被称为在上下文中转换为 bool 并且当且仅当声明 bool t(e); 对于一些发明的临时变量 t (8.5) 是良构的。任一隐式转换的效果与执行声明和初始化然后使用临时变量作为转换的结果相同。如果 T 是左值引用类型 (8.3.2)，则结果为左值，否则为右值。当且仅当初始化将表达式 e 用作左值时，表达式 e 才用作左值。

之后，我在 8.5 第 6 行中找到了与用户定义类型相关的初始化程序部分

如果程序要求对 const 限定类型 T 的对象进行默认初始化，则 T 应是具有用户提供的默认构造函数的类类型。

最后，我在 12.3 第 2 行结束了关于用户定义的转换，其中指出

用户定义的转换仅适用于明确的情况（10.2、12.3.2）。

不用说，10.2 和 12.3.2 没有回答我的问题。

1. 有人可以阐明const对隐式转换有什么影响吗？
2. 使用const12.3 第 2 行的转换是否“明确”？
3. 是否会const以某种方式影响第 4 节中讨论的左值与右值？