标签: implicit-conversion

是否有 C++14 替代 C++20 中引入的显式(expr)?

TL;DR:我正在寻找与以下 C++20 MWE 等效的 C++14:

template<int sz>
struct bits {
  int v; // note explicit(expr) below
  explicit(sz > 1) operator bool() const { return bool(v); }
};

int main() {
  bool c = bits<1>{1}; // Should work
  bool d = bits<3>{1}; // Should fail
}
Run Code Online (Sandbox Code Playgroud)

语境:

bits<sz>我们有一个表示长度为位向量的C++ 类sz。过去,对 all 的转换bool是隐式的sz,但事实证明这很容易出错,因此我们改为operator bool()显式转换。

然而,1-bit位向量(在我们的上下文中)几乎完全等同于布尔值,因此当 时最好是operator bool()隐式的sz == 1。

explicit(sz > 1)这可以在C++20中实现,但我们的目标是 C++14。

我尝试重载 …

c++ implicit-conversion template-meta-programming c++14 c++20

10
推荐指数
1
解决办法
498
查看次数

java.lang.Boolean到scala.Boolean的问题

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)

java boolean scala implicit-conversion

9
推荐指数
1
解决办法
7585
查看次数

对集合的隐式转换

本周我遇到了关于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)

c# linq implicit-conversion

9
推荐指数
4
解决办法
7567
查看次数

当两者都是32位宽时,在C(或C++)中使用`unsigned long`和`unsigned int`是否存在可观察到的差异?

我正在使用带有编译器的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类型.
我正在寻找一个样本(表达式或片段)使用常量,一元/二元运算符,强制转换等,根据更改的类型定义,使用不同但正确的编译结果.

c c++ language-lawyer implicit-conversion

9
推荐指数
2
解决办法
1476
查看次数

如何为Scala中的任何Traversable实现通用算法?

我正在实现一个通用算法来返回基于另外两个集合的集合.问题可以简化为

def add[Repr <: Traversable[_]](coll1: Repr, coll2: Repr) = coll1 ++ coll2
Run Code Online (Sandbox Code Playgroud)

当我将算法应用于我定义为的集合A时,会出现问题

class A[T] extends Iterable[(Int,T)] with IterableLike[(Int,T), A[T]] { ... }
Run Code Online (Sandbox Code Playgroud)

即,A的类型参数与继承的Iterable的类型参数不同.Map使用类似的方法.

地图示例:

scala> val m1 = Map("a" -> 1, "b" -> 1, "c" -> 1)
m1: scala.collection.immutable.Map[java.lang.String,Int] = Map(a -> 1, b -> 1, c -> 1)

scala> val m2 = Map("a" -> 2, "c" -> 1)
m2: scala.collection.immutable.Map[java.lang.String,Int] = Map(a -> 2, c -> 1)
Run Code Online (Sandbox Code Playgroud)

将m1和m2作为参数应用add会导致List:

scala> add(m1,m2)
res3: Traversable[Any] = List((a,1), (b,1), (c,1), (a,2), (c,1)) …
Run Code Online (Sandbox Code Playgroud)

generics collections scala implicit-conversion scala-collections

9
推荐指数
1
解决办法
1399
查看次数

Func <MyType>隐式转换为MyType

鉴于以下课程:

public class MyType
{
    public static implicit operator MyType(Func<MyType> wrapper) {
        return wrapper();
    }
}
Run Code Online (Sandbox Code Playgroud)

从隐式演员Func<MyType>到MyType,我假设以下是可能的:

public MyType MyTypeWrapper() {
    return new MyType();
}

public void MyTestMethod() {
    MyType m = MyTypeWrapper; // not a call!
}
Run Code Online (Sandbox Code Playgroud)

但是我得到了:

无法将方法组"MyTypeWrapper"转换为非委托类型"Test.MyType".你打算调用这个方法吗?

其中,不幸的是对我,对搜索时(如我预期的一半),导致吨 的 问题,这个问题的答案是:

嘿,你打瞌睡; 折腾()结束了WhateverMethod!

现在,当我输入这个时,我注意到显式转换实际上是编译的:

MyType m = (MyType) MyTypeWrapper;
Run Code Online (Sandbox Code Playgroud)

为什么我不能隐式转换一个Func<MyType>来MyType为我所描述?

c# callback implicit-conversion

9
推荐指数
2
解决办法
349
查看次数

Visual Studio调试与发布版本:比较int和float missmatch

看看这个例子:

#include <stdio.h>

int main() {

  int i= 16777217;
  float f = 16777216.0;
  float g = i;

  if( i == f )
    printf("eq\n");
  else
    printf("neq\n");

  if( g == f )
    printf("eq\n");
  else
    printf("neq\n");

  return 0;
}
Run Code Online (Sandbox Code Playgroud)

其中,在发布模式下使用Visual Studio 2010 C++(VS),gcc或g ++(4.9.2)具有输出

eq
eq
Run Code Online (Sandbox Code Playgroud)

这对我来说是合理的:在第一次比较期间,i隐式转换为浮点数,其中尾数中的有效位被截断.因此,两个i和f具有比较平等同位模式.在第二个中if,相同的转换适用但在定义和初始化时已经执行g.

但是,在调试模式下使用VS,结果是

neq
eq
Run Code Online (Sandbox Code Playgroud)

看来,第一次比较期间的隐式转换if(作为C和C++中通常的算术转换的一部分)并未应用.这是真的?是否存在VS机制,可以在比较浮点数和整数(转换为更高精度的int/float)时防止此类误报?根据MSDN VS C++遵循的标准.

我用这个函数检查了位表示.对于所有编译器,它产生

i = 00000001000000000000000000000001
f = 01001011100000000000000000000000
g = 01001011100000000000000000000000
Run Code Online (Sandbox Code Playgroud)

float.h在VS状态,#define FLT_MANT_DIG 24 …

c c++ type-conversion visual-studio-2010 implicit-conversion

9
推荐指数
1
解决办法
215
查看次数

MySQL奇怪的行为用逗号分隔的数字列表

我有一个非常复杂的问题,但我把它缩小到这个,首先,让我给你一些测试数据:

运行这个:

CREATE TABLE `test` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `value` text NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=MyISAM AUTO_INCREMENT=1 DEFAULT CHARSET=latin1;

INSERT INTO test (value) VALUES
(1),
('1'),
('1,2'),
('3');
Run Code Online (Sandbox Code Playgroud)

现在运行此查询:

SELECT * FROM test WHERE value = 1;
Run Code Online (Sandbox Code Playgroud)

在这种情况下,我希望只获得前两行,其中值作为数字1或'1'字符输入,但由于某种原因,这是我得到的:

1, 1
2, 1
3, 1,2
Run Code Online (Sandbox Code Playgroud)

我的问题是,为什么我得到第三排?

注意:这是我的mysql版本:5.6.28-0ubuntu0.14.04.1

此外,我已经通过使用FIND_IN_SET解决了我的原始问题,并且我知道将逗号分隔的列表类型结构放在一起并不是一个好主意,也就是说,它应该首先使用连接表来完成.不幸的是,我在一个非常庞大的系统中工作,并且目前这种改变是不切实际的.

我只是对这种特定行为发生的原因感兴趣.

mysql implicit-conversion

9
推荐指数
1
解决办法
147
查看次数

防止隐式转换但允许列表初始化?

假设我有一个FunctionWrapper像这样定义的类:

struct FunctionWrapper
{
  FunctionWrapper(std::function<void()> f);

  // ... plus other members irrelevant to the question
};
Run Code Online (Sandbox Code Playgroud)

我想,以防止隐式转换std::function<void()>到FunctionWrapper,但允许构建FunctionWrapper使用括号初始化语法(即使用初始化列表用一个参数).换句话说,我想这样:

void foo();
void wrap(FunctionWrapper);

wrap(foo); // (1) error
wrap({foo}); // (2) OK
wrap(FunctionWrapper{foo}); // (3) OK
Run Code Online (Sandbox Code Playgroud)

有没有办法实现这一目标?我上面定义类的方法不是它:这允许隐式转换,因此(1)编译.

如果我添加explicit到构造函数:

struct FunctionWrapper
{
  explicit FunctionWrapper(std::function<void()> f);

  // ... plus other members irrelevant to the question
};
Run Code Online (Sandbox Code Playgroud)

它也没有帮助,因为它"太过分"并且不允许(2)以及(1).

有没有办法实现"中间地带"并且(2)编译而(1)产生错误?

c++ explicit implicit-conversion uniform-initialization

9
推荐指数
1
解决办法
193
查看次数

C#方法重载分辨率和用户定义的隐式转换

在存在用户定义的隐式转换和转换优先级的情况下,我尝试查找有关方法重载解析的一些信息.

这段代码:

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 …

c# implicit-conversion .net-4.6.1

9
推荐指数
1
解决办法
208
查看次数