标签: implicit-conversion

好的,公平的警告:这是我上周的荒谬问题的后续行动.虽然我认为这个问题并不荒谬.无论如何,这里是:

以前荒谬的问题:

假设我有一些T带有子类的基本特征A,B并且C,我可以声明一个集合Seq[T],例如,可以包含类型的值A,B和C.让子类型更明确,让我们使用Seq[_ <: T]类型绑定语法.

现在假设我有一个TC[_]带有成员的类型类A,B并且C(其中"成员"表示编译器可以TC[A]在隐式作用域中找到一些等等).与上面类似,我想Seq[_ : TC]使用上下文绑定语法声明一个类型的集合.

这不是合法的Scala,并且试图模仿可能会让你觉得自己是一个坏人.请记住,上下文绑定语法(正确使用时!)desugars到正在定义的类或方法的隐式参数列表,这在这里没有任何意义.

新前提:

因此,我们假设类型类实例(即隐式值)是不可能的,而在这种情况下我们需要使用隐式转换.我有一些类型V("v"应该代表"view",fwiw),以及范围内的隐式转换A => V,B => V以及C => V.现在我可以填充一个Seq[V],尽管如此A,B并且C不相关.

但是,如果我想要什么东西都是隐式转换既视图的集合V1和V2？我不能说Seq[V1 with V2]因为我的隐含转换并没有神奇地聚合这种方式.

隐式转换的交集？

我这样解决了我的问题:

// a …

应用隐式转换时,IntelliJ会为转换后的代码加下划线.是否可以以某种方式导航到应用的转换？

我希望能够执行以下操作,但是在调用useMap时失败了.我该如何进行此转换？

scala> import scala.collection.JavaConversions._
import scala.collection.JavaConversions._

scala> import scala.collection.JavaConverters._
import scala.collection.JavaConverters._

scala> def useMap(m: java.util.Map[java.lang.Integer, java.lang.Float]) = m
useMap: (m: java.util.Map[Integer,Float])java.util.Map[Integer,Float]

scala> val v: Map[Int, Float] = Map()
v: Map[Int,Float] = Map()

scala> useMap(v)
<console>:10: error: type mismatch;
 found   : scala.collection.immutable.Map[Int,scala.Float]
 required: java.util.Map[Integer,java.lang.Float]
              useMap(v)
                     ^

它似乎适用于Map [String,String],但不适用于Map [Int,Float].

假设我有一个List[Int],我想调用toString每个元素,并将结果作为a Vector[String].

在Scala中执行此操作的方法有哪些？是否有最少量显式输入的解决方案？- 即,我想指定我想要一个Vector而不是一个List,但我希望String从过滤函数中推断出该参数.

或者我应该明确传递一个CanBuildFrom实例？我从哪里得到这些 - 对于Seqs,Sets和Maps？

#include<iostream>
using namespace std;

struct B{};

struct A
{
    A(const B &)
    {
        cout<<"A(const B &)"<<endl;
    }
    A(B &&)
    {
        cout<<"A(B &&)"<<endl;
    }
};

A get()
{
    B b;
    return b;
}

int main()
{
    get();
}

我用VC++ 14.2和GCC 5.4.0测试了代码,它们都输出:

A(B &&)

为什么输出不是

A(const B &)

？

这段代码与此有何关系copy elision？(但A和B是不同的类型,所以copy elision不应该在这里工作)

我知道在 Java 中整数文字默认是int，所以如果我写这样的东西

byte byteValue = 2;

Java 自动将文字值2（默认为 int）转换为字节。如果我写同样的事情

byte byteValue = 4/2;

RHS 被评估为一个 int 并隐式转换为一个字节。

但是为什么在以下两种情况下不会发生隐式转换？

int n1 = 4;
byte value = n1/2;

或在此

byte n1 = 4;
byte value = n1/2;

我知道这两个示例的 RHS 都被评估为int。但是为什么Java不像前两种情况那样将其隐式转换为字节。是否只有在存在文字时才会隐式转换为较小的数据类型？

在Scala中,使用隐式类型转换来增强类的功能与其他可能的实现选择相比,是否存在显着的CPU或内存影响？

例如,考虑一个愚蠢的字符串操作函数.此实现使用字符串连接:

object Funky {
  def main(args: Array[String]) {
    args foreach(arg => println("Funky " + arg))
  }
}

此实现通过使用隐式类型转换隐藏成员方法背后的串联:

class FunkyString(str: String) {
  def funkify() = "Funky " + str
}

object ImplicitFunky {
  implicit def asFunkyString(str: String) = new FunkyString(str)

  def main(args: Array[String]) {
    args foreach(arg => println(arg.funkify()))
  }
}

两者都做同样的事情:

scala> Funky.main(Array("Cold Medina", "Town", "Drummer"))        
Funky Cold Medina
Funky Town
Funky Drummer

scala> ImplicitFunky.main(Array("Cold Medina", "Town", "Drummer"))
Funky Cold Medina
Funky Town
Funky Drummer

有任何性能差异吗？一些具体的考虑因素:

Scala是否内联对asFunkyString方法的隐式调用？

Scala实际上是为每个arg创建一个新的包装器FunkyString对象,还是可以优化掉额外的对象分配？

假设FunkyString有3种不同的方法(funkify1,funkify2和funkify3),并且foreach的主体连续调用每个方法: …

我在Nullable隐式转换之间的交互中遇到了一些有趣的行为.我发现从值类型提供引用类型的隐式转换,它允许Nullable在我反对期望编译错误时将类型传递给需要引用类型的函数.以下代码演示了这一点:

static void Main(string[] args)
{
    PrintCatAge(new Cat(13));
    PrintCatAge(12);
    int? cat = null;
    PrintCatAge(cat);
}

private static void PrintCatAge(Cat cat)
{
    if (cat == null)
        System.Console.WriteLine("What cat?");
    else
        System.Console.WriteLine("The cat's age is {0} years", cat.Age);
}

class Cat
{
    public int Age { get; set; }
    public Cat(int age)
    {
        Age = age;
    }

    public static implicit operator Cat(int i)
    {
        System.Console.WriteLine("Implicit conversion from " + i);
        return new Cat(i);
    }
}

输出:

The cat's age …

据我所知,隐式转换可能导致可能难以理解的代码,或代码遭遇其他问题(甚至可能是错误？),这就是为什么它们需要显式启用才能在代码中使用而不会收到警告.

但是,假设隐式转换在很大程度上(如果不是大部分时间)用于包装具有另一种类型的对象的对象,那么隐式类也是如此 - 如果我错了,我会感激你纠正我 - 为什么前者需要进口scala.language.implicitConversions但后者不需要？

object Main extends App {
  implicit class StringFoo(x: String) {
    def fooWithImplicitClass(): Unit =
      println("foo with implicit class")
  }
  // => silence.

  "asd".fooWithImplicitClass()

  /************************/

  class Foo(x: String) {
    def fooWithImplicitDef(): Unit =
      println("foo with implicit def")
  }
  implicit def string2Foo(x: String) = new Foo(x)
  // => warning: implicit conversion method string2Foo should be enabled

  "asd".fooWithImplicitDef()
}

我正在阅读标准并试图弄清楚为什么没有演员表就无法解决此代码.

void foo(char c) { }

// Way bigger than char
void foo(unsigned long int) { }

int main()
{
   foo(123456789); // ambiguous
   foo((unsigned long int) 123456789); // works
}

这就是它所说的:

4.13整数转换排名[conv.rank]

每个整数类型都有一个整数转换等级,定义如下:

- 任何无符号整数类型的等级应等于相应有符号整数类型的等级.

- char的等级应等于signed char和unsigned char的等级.

特别是,我的jimmies的沙沙声是它没有说任何无符号整数类型,只是unsigned char.我的猜测是,char通过转换被提升为无符号类型.这是真的？