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
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) 我正在使用带有编译器的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类型.
我正在寻找一个样本(表达式或片段)使用常量,一元/二元运算符,强制转换等,根据更改的类型定义,使用不同但正确的编译结果.
我正在实现一个通用算法来返回基于另外两个集合的集合.问题可以简化为
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
鉴于以下课程:
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为我所描述?
看看这个例子:
#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
我有一个非常复杂的问题,但我把它缩小到这个,首先,让我给你一些测试数据:
运行这个:
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解决了我的原始问题,并且我知道将逗号分隔的列表类型结构放在一起并不是一个好主意,也就是说,它应该首先使用连接表来完成.不幸的是,我在一个非常庞大的系统中工作,并且目前这种改变是不切实际的.
我只是对这种特定行为发生的原因感兴趣.
假设我有一个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)产生错误?
在存在用户定义的隐式转换和转换优先级的情况下,我尝试查找有关方法重载解析的一些信息.
这段代码:
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 …