在Scala(2.7.7final)中,该Predef.println方法被定义为具有以下签名:
def println (x : Any) : Unit
Run Code Online (Sandbox Code Playgroud)
怎么来,那么以下工作:
scala> println(1,2)
(1,2)
Run Code Online (Sandbox Code Playgroud)
编译器是否自动将以逗号分隔的参数列表转换为元组?通过什么魔术?这里是否存在隐式转换,如果是,那么哪一个?
georgii@gleontiev:~$ scala
Welcome to Scala version 2.8.1.final (Java HotSpot(TM) 64-Bit Server VM, Java 1.6.0_24).
Type in expressions to have them evaluated.
Type :help for more information.
scala> val jbool = java.lang.Boolean.TRUE
jbool: java.lang.Boolean = true
scala> val sbool = true
sbool: Boolean = true
scala> def sboolMethod(sbool: Boolean) = print("got scala.Boolean " + sbool)
sboolMethod: (sbool: Boolean)Unit
scala> sboolMethod(sbool)
got scala.Boolean true
scala> sboolMethod(jbool)
<console>:9: error: type mismatch;
found : java.lang.Boolean
required: scala.Boolean
sboolMethod(jbool)
^
scala> implicit def jbool2sbool(bool: java.lang.Boolean): …Run Code Online (Sandbox Code Playgroud) 本周我遇到了关于C#集合中隐式转换的问题.虽然这(使用implicit)可能不是我们的最终方法,但我想至少完成代码以提供团队作为选项.我将问题归结为以下示例案例:
我的示例中有两个类:一个代表业务对象(Foo),另一个代表此业务项(FooVO)的客户端版本(View Object),如下所定义...
public class Foo
{
public string Id {get; set;}
public string BusinessInfo {get; set;}
}
public class FooVO
{
public string Id {get; set;}
public static implicit operator FooVO( Foo foo )
{
return new FooVO { Id = foo.Id };
}
}
Run Code Online (Sandbox Code Playgroud)
我的问题是当我有一个Foo对象列表,并希望使用我的隐式运算符将它们转换为FooVO对象列表.
List<Foo> foos = GetListOfBusinessFoos(); // Get business objects to convert
Run Code Online (Sandbox Code Playgroud)
我试过了
List<FooVO> fooVOs = foos; // ERROR
Run Code Online (Sandbox Code Playgroud)
和
List<FooVO> fooVOs = (List<FooVO>) foos; // ERROR
Run Code Online (Sandbox Code Playgroud)
乃至
List<FooVO> fooVOs = foos.Select( x …Run Code Online (Sandbox Code Playgroud) 我在Scala中理解Int被隐式转换为RichInt.在源代码中发生了什么(我正在浏览Scala源代码,但我找不到它......)
我正在使用带有编译器的MPC56XX(嵌入式系统),其中a int和a long都是32位宽.
在必需的软件包中,我们对32位宽类型有以下定义:
typedef signed int sint32;
typedef unsigned int uint32;
Run Code Online (Sandbox Code Playgroud)
在一个新版本中,没有太多文档就改变了:
typedef signed long sint32;
typedef unsigned long uint32;
Run Code Online (Sandbox Code Playgroud)
我可以看出为什么这会是一件好事:整数在short和之间有转换等级long,所以理论上在使用第一组定义时可以应用额外的转换.
我的问题:鉴于包裹作者强加给我们的上述变化,是否存在可以想象的情况,这种变化会改变编译的代码,正确导致不同的结果?
我熟悉"通常的一元转换"和"通常的二进制转换",但我很难想出一个具体的情况,这可能会破坏我现有的代码.但它真的无关紧要吗?
我目前正在使用C89/C94在纯C环境中工作,但我对C和C++问题都很感兴趣.
编辑:我知道混合int时sint32可能会产生不同的结果重新定义.但我们不允许直接使用原始的C类型,只允许使用typedef类型.
我正在寻找一个样本(表达式或片段)使用常量,一元/二元运算符,强制转换等,根据更改的类型定义,使用不同但正确的编译结果.
标准库类模板std::bitset<N>有一个构造函数(C++ 11及更高版本,unsigned longC++ 11之前的参数)
constexpr bitset(unsigned long long) noexcept
Run Code Online (Sandbox Code Playgroud)
与许多最佳实践指南相反,此单参数构造函数未标记为explicit.这背后的理由是什么?
c++ explicit-constructor unsigned-long-long-int bitset implicit-conversion
我一直在使用Scala中的类型类模式,但是当我使用的类型是通用的时,我无法弄清楚如何实现隐式伴随对象.
例如,假设我已经为类型类定义了一个特征,它提供了将事物放入Boxes的函数.
case class Box[A](value: A)
trait Boxer[A] {
def box(instance: A): Box[A]
def unbox(box: Box[A]): A
}
implicit object IntBoxer extends Boxer[Int] {
def box(instance: Int) = Box(instance)
def unbox(box: Box[Int]) = box.value
}
def box[A : Boxer](value: A) = implicitly[Boxer[A]].box(value)
def unbox[A : Boxer](box: Box[A]) = implicitly[Boxer[A]].unbox(box)
Run Code Online (Sandbox Code Playgroud)
这按预期工作,允许我提供Boxer各种类型的实现.但是,当我想要采取的类型本身就是通用的时候,我不知道如何做到这一点.假设我想能够使用我Boxer的任何一个Seq[A].objectScala中的s不能包含类型参数,所以我不知道该去哪里:
// Will not compile - object cannot have type arguments
implicit object SeqBoxer[A] extends Boxer[Seq[A]] { ... } …Run Code Online (Sandbox Code Playgroud) 我正在使用gcc 4.9进行嵌入式ARM编程.我一直在使用-Wconversion交换机,因为它是我公司的默认开发工具配置.我正在使用stdint.h 类型(uint8_t,uint32_t等).
每次执行复合赋值或简单添加时,编译器都会创建警告.例如:
uint8_t u8 = 0;
uint16_t u16;
// These cause warnings:
u8 += 2;
u8 = u16 >> 8;
Run Code Online (Sandbox Code Playgroud)
u8 = (uint8_t)(u8 + 2);
u8 = (uint8_t)(u16 >> 8);
Run Code Online (Sandbox Code Playgroud)
除了这个丑陋之外,我还在不断地说服铸造通常是不好的做法.
我的问题:
-Wconversion并让编译器为我进行隐式转换,我会失去什么吗?c casting type-conversion compiler-warnings implicit-conversion
在存在用户定义的隐式转换和转换优先级的情况下,我尝试查找有关方法重载解析的一些信息.
这段代码:
class Value
{
private readonly int _value;
public Value(int val)
{
_value = val;
}
public static implicit operator int(Value value)
{
return value._value;
}
public static implicit operator Value(int value)
{
return new Value(value);
}
}
class Program
{
static void ProcessValue(double value)
{
Console.WriteLine("Process double");
}
static void ProcessValue(Value value)
{
Console.WriteLine("Process Value");
}
static void Main(string[] args)
{
ProcessValue(new Value(10));
ProcessValue(10);
Console.ReadLine();
}
}
Run Code Online (Sandbox Code Playgroud)
产生输出:
Process Value
Process Value
Run Code Online (Sandbox Code Playgroud)
因此,看起来编译器选择了用户定义的转换,而不是从int到double的内置隐式转换(内置转换是隐含的,因为来自此页面的信息https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/implicit-numeric-conversions-table).
我试图在规范中找到一些相关的东西,但没有成功.
为什么选择编译器ProcessValue(Value …
当x是来自用户定义的类的对象时,在Console.WriteLine(x)中完成的隐式转换的顺序是什么:
class Vector
{
public int x = 12;
public static implicit operator double(Vector v1)
{
return 3.14;
}
public static implicit operator int(Vector v1)
{
return 42;
}
public override string ToString()
{
return this.x.ToString();
}
}
static void Main(string[] args)
{
Vector v11 = new Vector();
Console.WriteLine(v11);
}
Run Code Online (Sandbox Code Playgroud)
为什么我得到42,而不是3.14或"12"?为什么我不能向字符串添加额外的隐式转换/ CW(int)和CW(字符串)/之间存在歧义的编译器错误:
public static implicit operator string(Vector v1)
{
return "42";
}
Run Code Online (Sandbox Code Playgroud)
我知道我应该避免使用隐式演员,但仅仅是为了好奇!